# packages

pkgId: 8db3a78dd58841ae08df7356f05cffdc7fa0a14bd5ccfeb5bbb8969317189ec3
name: python-AFMReader
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Read and retrieve data from various AFM file formats.
url: https://github.com/AFM-SPM/afmreader
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AFMReader-0.0.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  [![PyPI version](https://badge.fury.io/py/AFMReader.svg)](https://badge.fury.io/py/AFMReader)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/AFMReader)
  [![Code style: 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)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Code style: flake8](https://img.shields.io/badge/code%20style-flake8-456789.svg)](https://github.com/psf/flake8)
  <!-- [![codecov](https://codecov.io/gh/AFM-SPM/AFMReader/branch/dev/graph/badge.svg)]
  (https://codecov.io/gh/AFM-SPM/AFMReader) -->
  [![pre-commit.ci
  status](https://results.pre-commit.ci/badge/github/AFM-SPM/AFMReader/main.svg)](https://results.pre-commit.ci/latest/github/AFM-SPM/AFMReader/main)
  [![fair-software.eu](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8B-yellow)](https://fair-software.eu)

  </div>
  <div align="center">

  [![Downloads](https://static.pepy.tech/badge/afmreader)](https://pepy.tech/project/afmreader)
  [![Downloads](https://static.pepy.tech/badge/afmreader/month)](https://pepy.tech/project/afmreader)
  [![Downloads](https://static.pepy.tech/badge/afmreader/week)](https://pepy.tech/project/afmreader)

  </div>

  A library for loading various Atomic Force Microscopy (AFM) file formats into Python. This library is primarily intended
  for use with [TopoStats](https://github.com/AFM-SPM/TopoStats).

  Supported file formats

  | File format | Description    |
  |-------------|----------------|
  | `.asd`      | High-speed AFM |
  | `.ibw`      | [WaveMetrics](https://www.wavemetrics.com/)  |
  | `.spm`      | [Bruker's Format](https://www.bruker.com/)  |
  | `.jpk`      | [Bruker](https://www.bruker.com/) |
  | `.topostats`| [TopoStats](https://github.com/AFM-SPM/TopoStats)  |
  | `.gwy`      | [Gwydion](<http://gwyddion.net>) |

  Support for the following additional formats is planned. Some of these are already supported in TopoStats and are
  awaiting refactoring to move their functionality into AFMReader these are denoted in bold below.

  | File format | Description                                             | Status                                     |
  |-------------|---------------------------------------------------------|--------------------------------------------|
  | `.nhf`      | [Nanosurf](https://www.nanosurf.com/en/)                | To Be Implemented.                         |
  | `.aris`     | [Imaris Oxford Instruments](https://imaris.oxinst.com/) | To Be Implemented.                         |
  | `.tiff`     | [Park Systems](https://www.parksystems.com/)            | To Be Implemented.                         |



  If you wish to process AFM images supported by `AFMReader` it is recommend you use
  [TopoStats](https://github.com/AFM-SPM/TopoStats) to do so, however the library can be used on its own.



  You can open `.topostats` files using the `load_topostats` function. Just pass in the path to the file.

  ```python
  from AFMReader.topostats import load_topostats

  image, pixel_to_nanometre_scaling_factor, metadata = load_topostats(file_path="./my_topostats_file.topostats")
  ```



  You can open `.spm` files using the `load_spm` function. Just pass in the path to the file and the
  channel name that you want to use. (If in doubt use one of the following: "Height", "ZSensor",
  "Height Sensor").

  ```python
  from AFMReader.spm import load_spm

  image, pixel_to_nanometre_scaling_factor = load_spm(file_path="./my_spm_file.spm", channel="Height")
  ```



  You can open `.gwy` files using the `load_gwy` function. Just pass in the path to the file and the
  channel name that you want to use. (If in doubt use one one of the following: "Height", "ZSensor",
  "Height Sensor").

  ```python
  from AFMReader.gwy import load_gwy

  image, pixel_to_nanometre_scaling_factor = load_gwy(file_path="./my_gwy_file.gwy", channel="Height")
  ```



  You can open `.asd` files using the `load_asd` function. Just pass in the path to the file and the channel name that you
  want to use. (If in doubt use the `"TP"` topography channel).

  Note: For `.asd` files, there seem to only ever be two channels in one file. `"TP"` (topography) is the main one you
  will want to use unless you know you specifically want something else.

  Other channels: `"ER"` - Error, `"PH"` - Phase

  ```python
  from AFMReader.asd import load_asd

  frames, pixel_to_nanometre_scaling_factor, metadata = load_asd(file_path="./my_asd_file.asd", channel="TP")
  ```



  You can open `.ibw` files using the `load_ibw` function. Just pass in the path to the file
  and the channel name that you want to use. (If in doubt, use `HeightTracee` (yes, with the
  extra 'e'), `ZSensorTrace`, or `ZSensor`).

  ```python
  from AFMReader.ibw import load_ibw

  image, pixel_to_nanometre_scaling_factor = load_ibw(file_path="./my_ibw_file.ibw", channel="HeightTracee")
  ```



  You can open `.jpk` files using the `load_jpk` function. Just pass in the path
  to the file and the channel name you want to use. (If in doubt, use `height_trace` or `measuredHeight_trace`).

  ```python
  from AFMReader.jpk import load_jpk

  image, pixel_to_nanometre_scaling_factor = load_jpk(file_path="./my_jpk_file.jpk", channel="height_trace")
  ```



  Bug reports and feature requests are welcome. Please search for existing issues, if none relating to your bug/feature
  are found then feel free to create a new [issue](https://github.com/AFM-SPM/AFMReader/issues/new) detailing what
  went wrong or the feature you would like to see implemented.

  Pull requests are also welcome, please note that we have a [Code of
  Conduct](https://github.com/AFM-SPM/AFMReader/blob/main/CODE_OF_CONDUCT.md).



  We use [pre-commit](https://pre-commit.com) to apply linting via [ruff](https://github.com/astral-sh/ruff) and
  [pylint](https://pylint.pycqa.org/en/latest/index.html) pre-commit hooks and use the
  [Black](https://github.com/psf/black) and [Flake8](https://github.com/psf/flake8) code styles. To set yourself up for
  contributing after cloning the package and creating a Python virtual environment you should install the development
  dependencies and `pre-commit` as shown below.

  ``` bash


  git clone git@github.com:AFM-SPM/AFMReader.git

  cd AFMReader

  pip install -e .[dev]

  pre-commit install
  ```

  This will ensure that any commits and pull requests you make will pass the [Pre-commit Continuous
  Integration](https://pre-commit.ci). Where possible `ruff` will correct the changes it can, but it may require you to
  address some issues manually, before adding any changes and attempting to commit again.


pkgId: 8d02dbdfe81e32004df887a8571b614e702abc98c5674a619b87fc1bc49ffc35
name: python-AFR
arch: src
version: 3.0.0
epoch: 0
release: 1
url: https://github.com/AFRKZ/AFR
rpm_license: 3-clause BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AFR-3.0.0-1.src.rpm
checksum_type: sha256
summary:
  Statistical toolkit aimed to help statisticians, data analysts, data scientists, bankers and other professionals to analyze financial data

description:
   Package ‘AFR’


  Statistical toolkit aimed to help statisticians, data analysts, data scientists, bankers and other professionals to analyze financial data.

  It was designed by the team of the Agency of the Republic of Kazakhstan for Regulation and Development of Financial Market (ARDFM).

  AFR toolkit offers functions to upload, preliminary check, analyze data and regressions and interpret results.




  Timur Abilkassymov, the Advisor to the Chairperson of the ARDFM.

  Alua Makhmetova, chief specialist of the Department of Banking Analytics and Stress Testing of the ARDFM.

  Sultan Zhaparov, maintainer of the project, chief specialist of the Department of Banking Analytics and Stress Testing of the ARDFM.



  Sultan Zhaparov

  sultan.saldau@gmail.com



  The Agency of the Republic of Kazakhstan for Regulation and Development of Financial Market. The [link](https://www.gov.kz/memleket/entities/ardfm?lang=en)






  AFR has built-in datasets named _macroKZ_ and _finratKZ_ that were gathered by the ARDFM team. More details below.



  Dataset *finratKZ* was gathered during the supervisory procedure of the banking sector of Kazakhstan. ARDFM team analyzed financial statements of the corporate borrowers and calculated financial ratios.

  The data was collected during regular supervisory asset quality review(AQR) procedure. During the AQR corporate borrowers were classified as default and standard (IFRS stage 1).

  **Dataset contains following data** :

  - **Default** - Dummy variable where 0 - standard(IFRS stage 1) borrower, 1 - default borrower
  - **Rev_gr** - Revenue growth rate
  - **EBITDA_gr** - EBITDA growth rate
  - **Cap_gr** - Capital growth rate
  - **CR** - Current ratio
  - **QR** - Quick ratio
  - **Cash_ratio** - Cash ratio
  - **WC_cycle** - Working capital cycle
  - **DTA** - Debt-to-assets
  - **DTE** -Debt-to-equity
  - **LR** - Leverage ratio (Total assets/Total equity)
  - **EBITDA_debt** - EBITDA-to-debt
  - **IC** - Interest coverage (Income statement)
  - **CTI** - Cash-to-income
  - **IC_CF** - Interest coverage (Cash flow statement)
  - **DCR** - Debt coverage ratio (Cash flow from operations/Total debt)
  - **CFR** - Cash flow to revenue
  - **CRA** - Cash return on assets (Cash flow from operations/Total assets)
  - **CRE** - Cash return on equity (Cash flow from operations/Total equity)
  - **ROA** - Return on assets
  - **ROE** - Return on equity
  - **NPM** - Net profit margin
  - **GPM** - Gross profit margin
  - **OPM** - Operating profit margin
  - **RecT** - Receivables turnover
  - **InvT** - Inventory turnover
  - **PayT** - Payables turnover
  - **TA** - Total assets turnover
  - **FA** - Fixed assets turnover
  - **WC** - Working capital turnover

  **Example** :

  .. code-block:: python

      import pandas as pd
      finrat = pd.read_csv('./finratKZ.csv')

  **Reference** :
  The Agency of the Republic of Kazakhstan for Regulation and Development of Financial Market.




  The dataset was gathered by the ARDFM based on Kazakhstan' official and public data from the [Bureau of National Statistics](https://stat.gov.kz/).

  The dataset contains 50 historic macroeconomic and 10 hypothetical financial data over 57 quarters of 2010-2024 period.

  The *macroKZ* dataset will be updated periodically as the official statistical information is released.

  **Dataset contains following data** :

  - **real_gdp** Real GDP
  - **GDD_Agr_R** Real gross value added Agriculture
  - **GDD_Min_R** Real gross value added Mining
  - **GDD_Man_R** Real gross value added Manufacture
  - **GDD_Elc_R** Real gross value added Electricity
  - **GDD_Con_R** Real gross value added Construction
  - **GDD_Trd_R** Real gross value added Trade
  - **GDD_Trn_R** Real gross value added Transportation
  - **GDD_Inf_R** Real gross value added Information
  - **GDD_Est_R** Real gross value added for Real estate
  - **GDD_R** Real gross value added
  - **GDP_DEF** GDP deflator
  - **Rincpop_q** Real population average monthly income
  - **Rexppop_q** Real population average monthly expenses
  - **Rwage_q** Real population average monthly wage
  - **imp** Import
  - **exp** Export
  - **cpi** Inflation
  - **realest_resed_prim** Real price for estate in primary market
  - **realest_resed_sec** Real price for estate in secondary market
  - **realest_comm** Real price for commercial estate
  - **index_stock_weighted** Change in stock value for traded companies
  - **ntrade_Agr** Change in stock value for non-traded companies Agriculture
  - **ntrade_Min** Change in stock value for non-traded companies Mining
  - **ntrade_Man** Change in stock value for non-traded companies Manufacture
  - **ntrade_Elc** Change in stock value for non-traded companies Electricity
  - **ntrade_Con** Change in stock value for non-traded companies Construction
  - **ntrade_Trd** Change in stock value for non-traded companies Trade
  - **ntrade_Trn** Change in stock value for non-traded companies Transportation
  - **ntrade_Inf** Change in stock value for non-traded companies Information
  - **fed_fund_rate** Federal Funds Rate
  - **govsec_rate_kzt_3m** Return on government securities in KZT, 3 m
  - **govsec_rate_kzt_1y** Return on government securities in KZT, 1 year
  - **govsec_rate_kzt_7y** Return on government securities in KZT, 7 years
  - **govsec_rate_kzt_10y** Return on government securities in KZT, 10 years
  - **tonia_rate** TONIA
  - **rate_kzt_mort_0y_1y** Weighted average mortgage lending rate for new loans, less than a year
  - **rate_kzt_mort_1y_iy** Weighted average mortgage lending rate for new loans, more than a year
  - **rate_kzt_corp_0y_1y** Weighted average mortgage lending rate for new loans to non-financial organizations in KZT, less than a year
  - **rate_usd_corp_0y_1y** Weighted average mortgage lending rate for new loans to non-financial organizations in CKB, less than a year
  - **rate_kzt_corp_1y_iy** Weighted average mortgage lending rate for new loans to non-financial organizations in KZT, more than a year
  - **rate_usd_corp_1y_iy** Weighted average mortgage lending rate for new loans to non-financial organizations in CKB, more than a year
  - **rate_kzt_indv_0y_1y** Weighted average mortgage lending rate for consumer loans in KZT, less than a year
  - **rate_kzt_indv_1y_iy** Weighted average mortgage lending rate for consumer loans in KZT, less than a year
  - **usdkzt** USD KZT exchange rate
  - **eurkzt** EUR KZT exchange rate
  - **rurkzt** RUB KZT exchange rate
  - **poil** Price for Brent
  - **realest_resed_prim_rus** Real price for estate in primary market in Russia
  - **realest_resed_sec_rus** Real price for estate in secondary market in Russia
  - **cred_portfolio** credit portfolio
  - **coef_k1** k1 prudential coefficient
  - **coef_k3** k3 prudential coefficient
  - **provisions** provisions
  - **percent_margin** percent margin
  - **com_inc** commissionary income
  - **com_exp** commissionary expenses
  - **oper_inc** operational income
  - **oth_inc** other income
  - **DR** default rate

  **Example** :

  .. code-block:: python

      import pandas as pd
      macro = pd.read_csv('./macroKZ.csv')

  **Reference** :
  The Agency of the Republic of Kazakhstan for Regulation and Development of Financial Market.







  * **adjr2_score**

  Performs calculation of Adjusted R squared (Adj R2) for the given model.

  _Arguments_:

  model: OLS model

  _Result_:

  result: Adj R2 metrics.

  _Example_:

  print(adjr2_score(model))



  * **aic_score**

  Performs calculation of Akaike Information criteria(AIC) for the given model.

  _Arguments_:

  model: OLS model

  _Result_:

  result: AIC metrics.

  _Example_:

  print(aic_score(model))



  * **bic_score**

  Performs calculation of Akaike Information criteria(AIC) for the given model.

  _Arguments_:

  model: OLS model

  _Result_:

  result: AIC metrics.

  _Example_:

  print(bic_score(model))



  * **check_betas**

  Performs all possible subsets regression analysis for the given X and y with with an option to select criterion.
  Possible criteria are r2, AIC, BIC.

  _Arguments_:

  X: The predictor variables.

  y: The response variable
  criteria (str): The information criteria based on which

  intercept (bool): Logical; whether to include intercept term in the models.

  _Result_:

  pandas DataFrame: A table of subsets number, predictor variables and beta coefficients for each subset model.

  _Example_:

  X = macro[['poil', 'cpi', 'usdkzt', 'GDP_DEF', 'exp', 'tonia_rate']]

  y = macro['real_gdp']

  check_betas(X, y, criterion = 'bic', intercept = False)



  * **checkdata**

  Preliminary check of dataset for missing values, numeric format, outliers.

  _Arguments_:

  dataset: name of the CSV file with a dataset for analysis for preliminary check

  _Result_:

  str: A conclusion of the preliminary analysis.

  _Example_:

  import pandas as pd

  macro = pd.read_csv('./load/macroKZ.csv')

  checkdata(macro)



  * **corsel**

  Correlation matrix for a dataset with an option to set a correlation threshold and option to correlation value as a number or boolean True/False.

  _Arguments_:

  data: pandas DataFrame or path to CSV file with a dataset for analysis for preliminary check

  thrs (float): correlation threshold numeric value to use for filtering. Default is 0.65

  value_type (str): type of correlation value as a "numeric" or "boolean" value. Default representation is numeric.

  _Result_:

  pd.DataFrame or boolean : A pair of value name and correlation of the correlation matrix based on the threshold.
  Type of data varies in accordance with a chosen value_type parameter.

  _Example_:

  data = macro[['poil', 'cpi', 'usdkzt', 'GDP_DEF', 'exp', 'GDD_Agr_R', 'rurkzt', 'tonia_rate', 'cred_portfolio', 'fed_fund_rate']]

  corsel(data, thrs = 0.65, value_type = "boolean")



  * **dec_plot**

  The function depicts decomposition of regressors as a stacked barplot.

  _Arguments_:

  model: OLS linear regression model.

  data(pandas.DataFrame): A dataset based on which the model was built.

  _Result_:

  plot : matplotlib figure.

  _Example_:

  model = ols('real_gdp ~ poil + cpi + usdkzt + imp', data = macro).fit()

  dec_plot(model, macro)



  * **opt_size**

  Calculation of the number of observations necessary to generate the regression for a given number of regressors.

  _Arguments_:

  model: OLS linear regression model.

  _Result_:

  size (int) : Number of observations necessary to generate the model.

  _Example_:

  model = ols('real_gdp ~ poil + cpi + usdkzt + imp', data = macro).fit()

  opt_size(model)



  * **pt_multi**

  Estimates the multi-year probability of default using the Pluto and Tasche model.

  _Arguments_:

  portfolio_distribution (numpy array): The distribution of the portfolio loss rate.

  num_defaults (numpy array): The number of defaults observed in each portfolio over the num_years.

  conf_level (float): The confidence level for the estimate.

  num_years (int): Number of years of observations.

  _Result_:

  The estimated multi-year probability of default for each portfolio.

  _Example_:

  portfolio_distribution = np.array([10,20,30,40,10,20])

  num_defaults = np.array([1, 2, 1, 0, 3, 2])

  conf_level = 0.99

  num_years = 3

  pt_multi(portfolio_distribution, num_defaults, conf_level, num_years)



  * **pt_one**

  Estimates the one-year probability of default using the Pluto and Tasche model.

  _Arguments_:

  portfolio_dist (numpy array): The distribution of the portfolio loss rate.

  num_defaults (numpy array): The number of defaults observed in each portfolio.

  conf_level (float): The confidence level for the estimate.

  _Result_:

  The estimated one-year probability of default for each portfolio.

  _Example_:

  portfolio_distribution = np.array([10,20,30,40,10,20])

  num_defaults = np.array([1, 2, 1, 0, 3, 2])

  conf_level = 0.99

  pt_one(portfolio_distribution, num_defaults, conf_level)



  * **reg_test**

  Tests for detecting violation of Gauss-Markov assumptions.

  _Arguments_:

  model : OLS linear regression model.

  _Result_:

  results (dict) : A dictionary containing the results of the four tests.

  _Example_:

  model = ols('real_gdp ~ poil + cpi + usdkzt + imp', data = macro).fit()

  reg_test(model)



  * **regsel_f**

  Allows to select the best model based on stepwise forward regression analysis with all possible models.
  The best model is chosen according to the specified scoring.

  _Arguments_:

  X: independent/predictor variable(-s)

  y: dependent/response variable

  data (pandas.DataFrame): dataset

  p_value (float): Variables with p-value less than {p_value} will enter into the model.

  scoring (str): Statistical metrics used to estimate the best model. The default value is R squared, r2.

  Other possible options for {scoring} are: 'aic' , 'bic', 'sbic', 'accuracy',  'r2', 'adjr2', 'explained_variance' and other.

  _Result_:

  results: The best model and the plot of the coefficients.

  _Example_:

  X = macro[['poil', 'cpi', 'usdkzt', 'GDP_DEF', 'exp', 'tonia_rate']]

  y = macro['real_gdp']

  regsel_f(X, y, macro, scoring = 'aic')



  * **sbic_score**

  Performs calculation of Schwarz Bayesian Information criteria(SBIC) for the given model.

  _Arguments_:

  model: OLS model

  _Result_:

  result: SBIC metrics.

  _Example_:

  model = ols('real_gdp ~ poil + cpi + usdkzt + imp', data = macro).fit()

  print(sbic_score(model))



  * **vif_reg**

  Calculates the variation inflation factors of all predictors in regression models.

  _Arguments_:

  model: OLS linear regression model.

  _Result_:

  vif (pandas DataFrame): A Dataframe containing the vIF score for each independent factor.

  _Example_:

  model = ols('real_gdp ~ poil + cpi + usdkzt + imp', data = macro).fit()

  vif_reg(model)


pkgId: 0154804189b8e31d86c8d6459513aeb42d15c9110852a05c6e51ba7ee23fc1b0
name: python-AFTSA
arch: src
version: 1.0.9
epoch: 0
release: 1
url: https://github.com/colbyeagan/AFTSA
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AFTSA-1.0.9-1.src.rpm
checksum_type: sha256
summary:
  A package for creating evenly distributed and randomized, non overlapping rfc3339 timestamps for conducting statistical time series analysis using your API of choice.

description:
  [//]: # (badges)
  [![Downloads](https://static.pepy.tech/badge/AFTSA)](https://www.pepy.tech/projects/AFTSA)
  [![Repo](https://img.shields.io/badge/repo-github-brightgreen)](https://github.com/colbyeagan/AFTSA)
  [![PyPI](https://img.shields.io/pypi/v/AFTSA)](https://pypi.org/project/AFTSA/#history)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/AFTSA)
  [![PyPI - License](https://img.shields.io/pypi/l/AFTSA)](LICENSE.txt)
  ![PyPI - Format](https://img.shields.io/pypi/format/AFTSA)




  - Python 3.11 package -- Must run in python 3.11

  This Python package is meant for generating timestamps to be called in API or database queries where the data contains a start-time and/or end-time field. Using the functions in thie package, one can stream random or interval spaced timestamp queries into API and Database calls to generate datasets which chart over a specified time period or with randomized analysis in that specified period. This is a very cruical tool if you wish to perform time series analysis with a subset of a database.

  This package currently supports rfc3339 timestamp generation in the %Y-%m-%dT%H:%M:%SZ format. More timestamp formats can easily be added by cloning from github and changing the "return dt.strftime("%Y-%m-%dT%H:%M:%SZ")" statements across the functions you need.
  All tuples and 2d arrays of timestamps will be sorted. To receive unsorted queries, dowload source code from github and remove the sort_timestamps() function from all functions.

  ```
  pip install AFTSA
  ```
  or
  ```
  pip3.11 install AFTSA
  ```

  The usage of this package is simple.

  For functions to perform randomized time series analysis
  ```python
  from AFTSA import randoms
  ```


  For functions to perform specified interval time series analysis
  ```python
  from AFTSA import intervals
  ```






  intervals.one_day_intervals_past_year() is the most straight forward function, taking no arguments. It
  simply returns two arrays where returnValue[0] is the array of start times and returnValue[1] is the array of end times. This function reads your machine's local clock and returns one day ranges in rfc3339 time format for the prior calendar year from the time you call it.
  ```python
  from AFTSA import randoms

  dateLists = intervals.one_day_intervals_past_year()

  for i in range(len(dateLists[0])):
      print(f"{dateLists[0][i]} -- {dateLists[1][i]}")


  """
  2022-09-06T00:00:00Z -- 2022-09-07T00:00:00Z
  2022-09-07T00:00:00Z -- 2022-09-08T00:00:00Z
  2022-09-08T00:00:00Z -- 2022-09-09T00:00:00Z
  2022-09-09T00:00:00Z -- 2022-09-10T00:00:00Z
  2022-09-10T00:00:00Z -- 2022-09-11T00:00:00Z
  2022-09-11T00:00:00Z -- 2022-09-12T00:00:00Z
  ...
  2023-09-02T00:00:00Z -- 2023-09-03T00:00:00Z
  2023-09-03T00:00:00Z -- 2023-09-04T00:00:00Z
  2023-09-04T00:00:00Z -- 2023-09-05T00:00:00Z
  2023-09-05T00:00:00Z -- 2023-09-06T00:00:00Z
  """
  ```



  intervals.one_day_intervals(time_range: int, year: int, month: int, day: int, hour: int = 0, minute: int = 0, second: int = 0)
  returns time_range amount of days of time stamps after the specified date in the remaining arguments. Only up to the day is a required argument. If no hour or more specific range is specified then the timestamps will default to the beginning of the day at hour zero.
  ```python



  dateLists = intervals.one_day_intervals(100, 2020, 10, 5, 15, 45)

  for i in range(len(dateLists[0])):
      print(f"{dateLists[0][i]} -- {dateLists[1][i]}")


  """
  2020-10-05T15:45:00Z -- 2020-10-06T15:45:00Z
  2020-10-06T15:45:00Z -- 2020-10-07T15:45:00Z
  2020-10-07T15:45:00Z -- 2020-10-08T15:45:00Z
  2020-10-08T15:45:00Z -- 2020-10-09T15:45:00Z
  2020-10-09T15:45:00Z -- 2020-10-10T15:45:00Z
  2020-10-10T15:45:00Z -- 2020-10-11T15:45:00Z
  ...
  2021-01-09T15:45:00Z -- 2021-01-10T15:45:00Z
  2021-01-10T15:45:00Z -- 2021-01-11T15:45:00Z
  2021-01-11T15:45:00Z -- 2021-01-12T15:45:00Z
  2021-01-12T15:45:00Z -- 2021-01-13T15:45:00Z
  """
  ```



  intervals.n_day_intervals(num_of_days: int, time_range: int, year: int, month: int, day: int, hour: int = 0, minute: int = 0, second: int = 0): works the same as intervals.one_day_intervals() except there is an extra argument on the beginning where the duration of each range can be changed in increments of one day. In the example below you can see how each range now increments by 5 days each time.

  ```python
  dateLists = intervals.n_day_intervals(5, 100, 2020, 10, 5, 15, 45)

  for i in range(len(dateLists[0])):
      print(f"{dateLists[0][i]} -- {dateLists[1][i]}")


  """
  2020-10-05T15:45:00Z -- 2020-10-10T15:45:00Z
  2020-10-10T15:45:00Z -- 2020-10-15T15:45:00Z
  2020-10-15T15:45:00Z -- 2020-10-20T15:45:00Z
  2020-10-20T15:45:00Z -- 2020-10-25T15:45:00Z
  2020-10-25T15:45:00Z -- 2020-10-30T15:45:00Z
  ...
  2022-01-28T15:45:00Z -- 2022-02-02T15:45:00Z
  2022-02-02T15:45:00Z -- 2022-02-07T15:45:00Z
  2022-02-07T15:45:00Z -- 2022-02-12T15:45:00Z
  """
  ```





  randoms.random_date() returns a tuple with a random one hour time range in the past year
  ```python
  randomHourRange = randoms.random_date()

  print(randomHourRange)


  """
  ('2022-11-16T00:00:00Z', '2022-11-16T01:00:00Z')
  """
  ```



  randoms.random_date_n(n: int) also returns a tuple with a random one hour time range in the past year, however the argument n adjusts the duration of the interval in hour increments.
  ```python
  randomHourRange = randoms.random_date_n(5)

  print(randomHourRange)


  """
  ('2023-06-10T22:00:00Z', '2023-06-11T03:00:00Z')
  """

  ```



  randoms.n_random_hour_ranges(n: int) returns two lists of n random start times and end times (where each start time is one hour before the matching end time) within the past year (month rounding, i.e. if you are in September the time stamps start in October). A non month-rounding version is in progress.

  ```python

  randomDates = randoms.n_random_hour_ranges(100)

  for i in range(len(randomDates[0])):
      print(f"{randomDates[0][i]} -- {randomDates[1][i]}")


  """
  2022-10-03T05:00:00Z -- 2022-10-03T06:00:00Z
  2022-10-03T23:00:00Z -- 2022-10-04T00:00:00Z
  2022-10-08T15:00:00Z -- 2022-10-08T16:00:00Z
  2022-10-16T06:00:00Z -- 2022-10-16T07:00:00Z
  2022-10-18T05:00:00Z -- 2022-10-18T06:00:00Z
  ...
  2023-09-03T11:00:00Z -- 2023-09-03T12:00:00Z
  2023-09-03T18:00:00Z -- 2023-09-03T19:00:00Z
  2023-09-03T21:00:00Z -- 2023-09-03T22:00:00Z
  2023-09-05T21:00:00Z -- 2023-09-05T22:00:00Z
  """
  ```



  randoms.n_random_m_ranges(n: int, m: int) returns two lists of n random start times and end times (where each start time is m hours before the matching end time) within the past year (month rounding, i.e. if you are in September the time stamps start in October). A non month-rounding version is in the works.


  ```python

  randomRanges = randoms.n_random_m_ranges(100, 5)

  for i in range(len(randomRanges[0])):
      print(f"{randomRanges[0][i]} -- {randomRanges[1][i]}")


  """
  2022-10-07T07:00:00Z -- 2022-10-07T12:00:00Z
  2022-10-13T04:00:00Z -- 2022-10-13T09:00:00Z
  2022-10-17T02:00:00Z -- 2022-10-17T07:00:00Z
  2022-10-18T08:00:00Z -- 2022-10-18T13:00:00Z
  2022-10-20T16:00:00Z -- 2022-10-20T21:00:00Z
  2022-10-25T05:00:00Z -- 2022-10-25T10:00:00Z
  """
  ```

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Colby Eagan  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 2061d91711453f1997f0722822f7f2cc95e477b8eb721038105ac38535a10652
name: python-AGCoder
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Code generator class
url: https://pypi.org/project/AGCoder/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AGCoder-1.0.4-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License Copyright (c) [year] [fullname] 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: 94f3e192a5ef736e1f68272992fbaf614a939bb3ad4c3ef6cd1f1a2e4427a515
name: python-AHItoDICOMInterface
arch: src
version: 0.1.3.4
epoch: 0
release: 1
description: More details about the project and features can be found on the project's GitHub page.
url: https://github.com/aws-samples/healthlake-imaging-to-dicom-python-module
rpm_license: MIT-0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AHItoDICOMInterface-0.1.3.4-1.src.rpm
checksum_type: sha256
summary:
  A package to simply export DICOM data from AWS HealthImaging in your application memory or the file system.


pkgId: 58d24668b914c7cdfd6de326c43c85c182e1fac3bd4baf52559e943da921da01
name: python-AI-Chess
arch: src
version: 2.0.8
epoch: 0
release: 1
summary: Basic chess features that includes an AI for decision making in Python
url: https://pypi.org/project/AI-Chess/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AI-Chess-2.0.8-1.src.rpm
checksum_type: sha256
description:
  Basic chess features that includes an AI for decision making in Python







  To install packages run in terminal (Python 3.9+):



          pip install AI-Chess







  To start the board and the AI, do the following:



          >>> from AIchess import *

          >>> aic = AIChess()



  If you want to take a look at the board do this:



          >>> print(aic.board)



  If you want to get the board as a 2D list for easy use and print each row do this:



          >>> [print(sub_list) for sub_list in aic.get_boardAs2DList()]



  If you want to get the board as a flipped 2D list for easy use with white on top and black on bottom but with chess notation like 'a1' still being on white then print each row do this (Extra functions to support this board exist in documentation like automatically flipping the row and col to support this):



          >>> [print(sub_list) for sub_list in aic.get_boardAs2DListFlipped()]



  If you want change the AI algorithmic minimax depth to a higher number for better accuracy at the cost of computational requirement do this (Default: 3; Needs to be greater than 0):



          >>> aic.minimaxDepth = 2



  If you want to use the minimax AI to get one of the best possible moves for whoevers turn it is and use that move on the board then print the board do this (This assumes that the game isn't over for any reason):



          >>> aic.makeChessMove(aic.chessAIMove()[0])

          >>> [print(sub_list) for sub_list in aic.get_boardAs2DList()]







          __init__()



  Initialize the library by creating board: chess.Board which is the starting chess board in the chess library, it is public for you to use however be careful as you can break some functions and minimaxDepth: int which is the depth of the search algorithm. Higher the better but requires move computational power. Single process and needs to be > 0. Default 3.



          chessAIMove() -> List[str]



  Returns a list of the best possible legal_moves for whoevers turn it is in UCI however, it is possible that one or more of the entries can be the string 'claim_draw' instead of a UCI which is to indicate the desire to claim a draw like FIFTY_MOVES or THREEFOLD_REPETITION



          get_whiteBlackPointsDifference(game: chess.Board) -> int



  Returns the point difference between white and black where Pawn: 1, Bishop: 3, Knight: 3, Rook: 5, Queen 9



          makeChessMove(uci: chess.Move | str) -> None



  Needs to be at least pseudo_legal



          listAllPossibleMoves() -> List[Move]



  Lists all possible legal_moves for whoevers turn it is for each piece



          listUCIPosPossibleMoves(uciPos: str) -> List[Move]



  Lists all possible legal_moves for whoevers turn it is for the uciPos like 'a2', or 'b1'

  Returns an empty List if no possible moves



          reset() -> None



  Resets board in chess.Board



          willMoveNeedPawnPromotion(uci: chess.Move | str) -> bool



  Return True if move will result in a pawn promotion, False otherwise



          pieceToPieceType(result: chess.Piece | str) -> int



  Return chess.PieceType as a int



          rowColToUCI(rowColFrom: list[int], rowColTo: list[int]) -> str



  Accepts two List[int] which is the row and col from and to locations

  Returns a str which is a uci representing the inputs



          uciToRowCol(uci: chess.Move | str) -> List[int], List[int]



  Accepts a str which is a uci

  Returns two List[int] which are the row and col from and to representing the inputs



          rowColToUCIPos(row: int col: int) -> str



  Accepts a row and col of a 2D list that is the chess board

  Returns a uciPos which is a single position like a2 or b1 representing the inputs



          uciToRowColPos(uciPos: str) -> int, int



  Accepts a uciPos which is a single position like a2 or b1

  Returns a row and col of a 2D list that is the chess board representing the inputs



          uciToFlippedRowCol(uci: chess.Move | str) -> List[int], List[int]



  Accepts a uci

  Returns two List[int] which are the row and col from and to in a 2D list that is the chess board representing

  the inputs but flipped so that white is on top and black is bottom



          flippedRowColToUCIPos(row: int, col: int) -> str



  Accepts a row and col position that has been flipped so that white is on top and black is on bottom

  Returns a uciPos which is a single position like a2 or b1 representing the inputs



          uciToFlippedRowColPos(uciPos: str) -> int, int



  Accepts a uciPos which is a single position like a2 or b1

  Returns a row and col position that has been flipped so that white is on top and black is on bottom representing the inputs



          flipRowCol(rowColFrom: list[int], rowColTo: list[int]) -> List[int], List[int]



  Accepts two List[int] which is the row and col from and to locations

  Returns two List[int] which is the row and col from and to locations but flipped so that white is one top and black is on bottom



          flipRowColPos(row: int, col: int) -> int, int



  Accepts two int which is the row and col for a location

  Returns two int which is the row and col for a location but flipped so that white is one top and black is on bottom



          get_boardAs2DList() -> List[int][int]



  Returns a 2D list that represents the chess board with white on bottom and black on top for easy use



          get_boardAs2DListFlipped() -> List[int][int]



  Returns a 2D list that represents the chess board but flipped so white is on top and black is on bottom for easy use



          get_isWhiteTurn() -> bool



  Returns a bool where True is if it is white's turn and False if it is black's turn



          get_isStartOfGame() -> bool



  Returns a bool where True is if it is the start of the game and False if it isn't







  For more information on how to use this project visit https://python-chess.readthedocs.io/en/latest/ where some of this project uses.


pkgId: 9bbb49dd6e0993014d238a3c28b3e5ec730c1727da58ab70257f61ace4b2c255
name: python-AI4Water
arch: src
version: 1.6
epoch: 0
release: 1
summary: Platform for developing data driven based models for sequential/tabular data
url: https://github.com/AtrCheema/AI4Water
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AI4Water-1.6-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/AtrCheema/AI4Water/workflows/tf/badge.svg)](https://github.com/AtrCheema/AI4Water/actions)
  [![Documentation Status](https://readthedocs.org/projects/ai4water/badge/?version=latest)](https://ai4water.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://zenodo.org/badge/DOI/10.5194/gmd-2021-139.svg)](https://doi.org/10.5194/gmd-15-3021-2022)
  [![Downloads](https://pepy.tech/badge/ai4water)](https://pepy.tech/project/ai4water)
  [![PyPI version](https://badge.fury.io/py/AI4Water.svg)](https://badge.fury.io/py/AI4Water)
  ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/AtrCheema/AI4Water)
  ![GitHub last commit (branch)](https://img.shields.io/github/last-commit/AtrCheema/AI4Water/master)


  A uniform and simplified framework for rapid experimentation with deep leaning and machine learning based models
  for time series and tabular data. To put into Andrej Karapathy's [words](https://twitter.com/karpathy/status/1350503355299205120)

  `Because deep learning is so empirical, success in it is to a large extent proportional to raw experimental throughput,
   the ability to babysit a large number of experiments at once, staring at plots and tweaking/re-launching what works.
   This is necessary, but not sufficient.`

  The specific purposes of the repository are

  -    compliment the functionality of `keras`/`pytorch`/`sklearn` by making pre and
   post-processing easier for time-series prediction/classification problems (also holds
   true for any tabular data).

  -    save, load/reload or build models from readable json file. This repository
   provides a framework to build layered models using python dictionary and with
   several helper tools which fasten the process of  modeling time-series forecasting.

  -    provide a uniform interface for optimizing hyper-parameters for
   [skopt](https://scikit-optimize.github.io/stable/index.html);
   [sklearn](https://scikit-learn.org/stable/modules/classes.html#hyper-parameter-optimizers)
   based [grid](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html)
   and [random](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RandomizedSearchCV.html);
    [hyperopt](http://hyperopt.github.io/hyperopt/) based
    [tpe](https://papers.nips.cc/paper/2011/file/86e8f7ab32cfd12577bc2619bc635690-Paper.pdf),
    [atpe](https://www.electricbrain.io/blog/learning-to-optimize) or
    [optuna](https://optuna.readthedocs.io/en/stable/) based
    [tpe](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.samplers.TPESampler.html),
    [cmaes](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.samplers.CmaEsSampler.html) etc.
    See [example](https://github.com/AtrCheema/AI4Water/blob/master/examples/hyper_para_opt.ipynb)
    using its application.

  -    cut short the time to write boilerplate code in developing machine learning
   based models.

  -    It should be possible to overwrite/customize any of the functionality of the AI4Water's `Model`
   by subclassing the
   `Model`. So at the highest level you just need to initiate the `Model`, and then need `fit`, `predict` and
   `view_model` methods of `Model` class, but you can go as low as you could go with tensorflow/keras.

  -    All the above functionalities should be available without complicating keras
   implementation.




  An easy way to install ai4water is using pip

      pip install ai4water

  You can also use GitHub link

  	python -m pip install git+https://github.com/AtrCheema/AI4Water.git

  or using setup file, go to folder where repo is downloaded

      python setup.py install

  The latest code however (possibly with fewer bugs and more features) can be installed from `dev` branch instead

      python -m pip install git+https://github.com/AtrCheema/AI4Water.git@dev

  To install the latest branch (`dev`) with all requirements use the following command

      python -m pip install "AI4Water[all] @ git+https://github.com/AtrCheema/AI4Water.git@dev"


  `all` keyword will install all the dependencies. You can choose the dependencies of particular sub-module
  by using the specific keyword. Following keywords are available

   - `hpo` if you want hyperparameter optimization
   - `post_process` if you want postprocessing
   - `exp` for experiments sub-module



  AI4Water consists of several submodules, each of wich responsible for a specific tasks.
  The modules are also liked with each other. For understanding sub-module structure of
  ai4water, [see this article](https://ai4water.readthedocs.io/en/dev/understanding.html)
  <p float="left">
    <img src="/docs/source/imgs/architecture.png" width="800" height="700"/>
  </p>



  Build a `Model` by providing all the arguments to initiate it.

  ```python
  from ai4water import Model
  from ai4water.models import MLP
  from ai4water.datasets import mg_photodegradation
  data, *_ = mg_photodegradation(encoding="le")

  model = Model(
      
      model=MLP(units=24, activation="relu", dropout=0.2),
      
      input_features=data.columns.tolist()[0:-1],
      
      output_features=data.columns.tolist()[-1:],
      lr=0.001,  # learning rate
      batch_size=8,  # batch size
      epochs=500,  # number of epochs to train the neural network
      patience=50,  # used for early stopping
  )
  ```

  Train the model by calling the `fit()` method
  ```python
  history = model.fit(data=data)
  ```

  <p float="left">
    <img src="/docs/source/imgs/mlp_loss.png" width="500" />
  </p>

  After training, we can make predictions from it on test/training data
  ```python
  prediction = model.predict_on_test_data(data=data)
  ```

  <p float="left">
    <img src="/docs/source/imgs/mlp_reg.png" width="400" />
    <img src="/docs/source/imgs/mlp_residue.png" width="400" />
  </p>

  <p float="left">
    <img src="/docs/source/imgs/mlp_line.png" width="400" />
    <img src="/docs/source/imgs/mlp_edf.png" width="400" />
  </p>

  The model object returned from initiating AI4Water's `Model` is same as that of Keras' `Model`
  We can verify it by checking its type
  ```python
  import tensorflow as tf
  isinstance(model, tf.keras.Model)  # True
  ```



  You can use your own pre-processed data without using any of pre-processing tools of AI4Water. You will need to provide
  input output paris to `data` argument to `fit` and/or `predict` methods.
  ```python
  import numpy as np
  from ai4water import Model  # import any of the above model
  from ai4water.models import LSTM

  batch_size = 16
  lookback = 15
  inputs = ['dummy1', 'dummy2', 'dummy3', 'dummy4', 'dummy5']  # just dummy names for plotting and saving results.
  outputs=['DummyTarget']

  model = Model(
              model = LSTM(units=64),
              batch_size=batch_size,
              ts_args={'lookback':lookback},
              input_features=inputs,
              output_features=outputs,
              lr=0.001
                )
  x = np.random.random((batch_size*10, lookback, len(inputs)))
  y = np.random.random((batch_size*10, len(outputs)))

  model.fit(x=x,y=y)

  ```


  The repository can also be used for machine learning based models such as scikit-learn/xgboost based models for both
  classification and regression problems by making use of `model` keyword arguments in `Model` function.
  However, integration of ML based models is not complete yet.
  ```python
  from ai4water import Model
  from ai4water.datasets import busan_beach

  data = busan_beach()  # path for data file

  model = Model(
      
      input_features=['tide_cm', 'wat_temp_c', 'sal_psu', 'rel_hum', 'pcp_mm'],
      output_features = ['tetx_coppml'], # columns in data file to be used as input
      seed=1872,
      val_fraction=0.0,
      split_random=True,
          
          model={"RandomForestRegressor": {}},  # set any of regressor's parameters. e.g. for RandomForestRegressor above used,
      
                )

  history = model.fit(data=data)

  model.predict_on_test_data(data=data)
  ```


  For hyperparameter optimization, replace the actual values of hyperparameters
  with the space.
  ```python

  from ai4water.functional import Model
  from ai4water.datasets import MtropicsLaos
  from ai4water.hyperopt import Real, Integer

  data = MtropicsLaos().make_regression(lookback_steps=1)

  model = Model(
      model = {"RandomForestRegressor": {
          "n_estimators": Integer(low=5, high=30, name='n_estimators', num_samples=10),
         "max_leaf_nodes": Integer(low=2, high=30, prior='log', name='max_leaf_nodes', num_samples=10),
          "min_weight_fraction_leaf": Real(low=0.0, high=0.5, name='min_weight_fraction_leaf', num_samples=10),
          "max_depth": Integer(low=2, high=10, name='max_depth', num_samples=10),
          "min_samples_split": Integer(low=2, high=10, name='min_samples_split', num_samples=10),
          "min_samples_leaf": Integer(low=1, high=5, name='min_samples_leaf', num_samples=10),
      }},
      input_features=data.columns.tolist()[0:-1],
      output_features=data.columns.tolist()[-1:],
      cross_validator = {"KFold": {"n_splits": 5}},
      x_transformation="zscore",
      y_transformation="log",
  )


  model.fit_on_all_training_data(data=data)
  print(model.evaluate_on_test_data(data=data, metrics=["r2_score", "r2"]))


  optimizer = model.optimize_hyperparameters(
     algorithm = "bayes",  # you can choose between `random`, `grid` or `tpe`
      data=data,
      num_iterations=60,
  )


  print(model.evaluate_on_test_data(data=data, metrics=["r2_score", "r2"]))
  ```

  Running the above code will optimize the hyperparameters and generate
  following figures

  <p float="left">
    <img src="/docs/source/imgs/hpo_ml_convergence.png" width="400" />
    <img src="/docs/source/imgs/hpo_fanova_importance_hist.png" width="400" />
  </p>

  <p float="left">
    <img src="/docs/source/imgs/hpo_objective.png" width="500" />
    <img src="/docs/source/imgs/hpo_evaluations.png" width="500" />
  </p>

  <p float="left">
    <img src="/docs/source/imgs/hpo_parallel_coordinates.png" width="500" />
  </p>



  The experiments module is for comparison of multiple models on a single data
  or for comparison of one model under different conditions.

  ```python
  from ai4water.datasets import busan_beach
  from ai4water.experiments import MLRegressionExperiments

  data = busan_beach()

  comparisons = MLRegressionExperiments(
      input_features=data.columns.tolist()[0:-1],
      output_features=data.columns.tolist()[-1:],
      split_random=True
  )

  comparisons.fit(data=data)

  best_models = comparisons.compare_errors(
      'r2',
      data=data,
      cutoff_type='greater',
      cutoff_val=0.1,
      figsize=(8, 9),
      colors=['salmon', 'cadetblue']
  )

  _ = comparisons.taylor_plot(
      data=data,
      figsize=(5, 9),
      exclude=["DummyRegressor", "XGBRFRegressor",
               "SGDRegressor", "KernelRidge", "PoissonRegressor"],
      leg_kws={'facecolor': 'white',
               'edgecolor': 'black','bbox_to_anchor':(2.0, 0.9),
               'fontsize': 10, 'labelspacing': 1.0, 'ncol': 2
              },
  )
  ```

  <p float="left">
    <img src="/docs/source/imgs/exp_r2.png" width="500" />
    <img src="/docs/source/imgs/exp_taylor.png" width="500" />
  </p>

  For more comprehensive and detailed examples see [![Documentation Status](https://readthedocs.org/projects/ai4water-examples/badge/?version=latest)](https://ai4water.readthedocs.io/projects/Examples/en/latest/?badge=latest)


  The library is still under development. Fundamental changes are expected without prior notice or
  without regard of backward compatability.



  [sktime: A Unified Interface for Machine Learning with Time Series](https://github.com/alan-turing-institute/sktime)

  [Seglearn: A Python Package for Learning Sequences and Time Series](https://github.com/dmbee/seglearn)

  [Pastas: Open Source Software for the Analysis of Groundwater Time Series](https://github.com/pastas/pastas)

  [Time Series FeatuRe Extraction on basis of Scalable Hypothesis tests (tsfresh -- A Python package)](https://github.com/blue-yonder/tsfresh)

  [MLAir](https://gmd.copernicus.org/preprints/gmd-2020-332/)

  [pyts: A Python Package for Time Series Classification](https://github.com/johannfaouzi/pyts)

  [Tslearn, A Machine Learning Toolkit for Time Series Data](https://github.com/tslearn-team/tslearn)

  [TSFEL: Time Series Feature Extraction Library](https://doi.org/10.1016/j.softx.2020.100456)

  [catch22](https://github.com/chlubba/catch22)

  [vest](https://github.com/vcerqueira/vest-python)

  [pyunicorn (Unified Complex Network and RecurreNce analysis toolbox](https://github.com/pik-copan/pyunicorn)

  [TSFuse Python package for automatically constructing features from multi-view time series data](https://github.com/arnedb/tsfuse)

  [Catalyst](https://github.com/catalyst-team/catalyst)

  [tsai - A state-of-the-art deep learning library for time series and sequential data](https://github.com/timeseriesAI/tsai)


pkgId: 15b21661da17ed2a5d465e122305fde924c03fb62f57a38575cd2a65b2e2b971
name: python-AIBS
arch: src
version: 0.0.67
epoch: 0
release: 1
summary: A simple, database-centered scraper for anonib.
url: https://github.com/taux1c/AIBS
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AIBS-0.0.67-1.src.rpm
checksum_type: sha256
description:
  AnonIB Web Scraper This is a database-centric web scraper designed for extracting information from AnonIB forums. The scraper is freely available for use, and contributions from the community are welcomed and appreciated.

  Usage Users are free to utilize this tool for their needs without any mandatory requirement for donations. However, if you find the tool helpful, you can make voluntary contributions through the link provided when the browser opens.

  Contributing Feel free to contribute to this project by submitting pull requests. Your contributions can help enhance the functionality and efficiency of the web scraper for the benefit of the community.

  Disclaimer This tool is intended for educational purposes only. It is not affiliated with AnonIB in any way, and any trademarks or intellectual property rights associated with AnonIB belong to their rightful owners. Any laws or terms of service violated by the use of this tool are solely the responsibility of the user, as this tool is meant strictly for educational purposes and not intended for actual use.

  The tool is provided as-is without any warranty. I, as the creator, accept no liability for the usage of this tool.

  Feel free to further modify this disclaimer to ensure it aligns with your intentions and the legal requirements of your project.


pkgId: 66c2c15f1949eda217e5b6858cd449ae6ac3d77bf9235dcd72557d24b2aa4b29
name: python-AICaretaker
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Technology demonstrator self-adapting code
url: https://github.com/greg-d128/caretaker
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AICaretaker-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This is a simple demonstration project. More like this is possible at this point. Use at your own risk. This code is ultimately non-deterministic and nobody knows what might happen.

  Importing this code will give a simple python script rudimentary way of fixing itself.
  This scripts registers itself as a global exception hook, retrieves the source code that failed, executes llm to fix the code, substitutes it back in and continues execution as if nothing happened.

  Simple, eh?





  Configuration area for the module. This is simply a python module that is loaded and referenced. Easy and flexible. Security is not a consideration since:

  A) This project is meant to be a library / agent that is included within another project, having complete and total control of that project.
  B) We are running AI within our code and allowing it to make decisions on the fly.
  C) There is no end-user facing configuration planned at this point.


  System of selecting and listing available models. To be expanded later.
  Key functionality:
  - Assume that capability may change over time. There has to be a method of re-examining capabilities and adding to them.
  - Allow for models to be deleted, even if they were found before.
  - Allow to handle models (at least try to), even if they are new.
  - Optionally allow to download models?


  System of having and selecting one of multiple prompts.
  Key Functionality:
  - Some prompts work with some models, and not others.
  - Some prompts may require different information. Thankfully we can try different prompts and get an error if information is not available.
  - Each prompt should have some way of deciding if a model can be used to evaluate it.



  Currently only one decorator. Others are in the planning stages. Please have a look at issues inside github if you are interested.

  Decorator is capable of catching and monitoring a single feature, while recording information about that section of code.




  Last ditch effort to respond to an unhandled exception. At this stage the program is effectively dead and the stack has unravelled. More testing is needed whether necromancer can restore a complex program, but should work for simple scripts.

  While this mode of running is simple and impressive, it is primairly included here as a demonstration. At the stage of life when necromancer is activated, the program is effectively dead. All the stack has been traversed up and the only remaining thing is to output the stack trace to screen or log. This code will attempt to ressurect and re-start the code execution, which is a very interesting concept.

  At this stage this will only work for simple scripts. If at any point in the stack we catch and then re-raise an exception, necromancer would likely be get very confused.






  Need ollama installed together with
  pip install ollama.

  Need to download an appropriate model and set it inside caretaker/config.py. While you are at it, feel free to improve on the prompt.






  There are several issues with this code. Some (most probably) are fixable.

  1. This package may not install properly at this time.  I am trying to resolve naming issues.

  2. It only modifies the code in memory, does not write it back out to the filesystem.

  3. This code is currently working with ollama only, although it allows for capture of other models and methods of execution (not fully implemented yet). Need to create a process of selecting a best model.

  4. Catching it at global exception hook means the program is already dead. Restarting execution (if the failure happened in a loop, etc), is tricky. Necromancer is a pure demonstration of what might be possible. Decorators are the future.

  5. Several different decorators are in the design / partial implemntation stages. No guarantee any of them work.


pkgId: 6ea25fd768ba3231837274a5f64193826372088edef0dab324bfb516a02d0151
name: python-AICelltype
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: AICelltype: Annotate cell type through gpt-4 without openai key.
url: https://pypi.org/project/AICelltype/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AICelltype-0.0.6-1.src.rpm
checksum_type: sha256
description:
  You can use pip install package directly.
  ```
  pip install AICelltype
  ```
  However I strongly recommend a virtual environment, if you do not have conda please install Miniconda first.
  ```
  conda create -n aicelltype_env python=3.10.0
  conda activate aicelltype_env
  pip install AICelltype
  ```

  tissue_name
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;In theory, tissue_name can be any type of biological tissue.
  gene_list
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Identify one cell type for each row in gene_list.
  model
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;One model should be chosen from `['gpt4', 'qwen-max', 'ERNIE-4.0']`.
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**gpt4**: annotate cell type through gpt4 (default);
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**qwen-max**: annotate cell type through ali qwen model, QWEN_KEY needed, refer to [link](https://help.aliyun.com/zh/dashscope/developer-reference/activate-dashscope-and-create-an-api-key) for a key;
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**ERNIE-4.0**: annotate cell type through  baidu qianfan model, API_KEY and SECRET_KEY needed, refer to [link](https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application) for them.

  ```
  tissue_name = 'human prostate'
  gene_lt = [
      ['KLK3', 'KRT8', 'KLK2', 'MSMB', 'ACPP', 'KLK1', 'KLK4'],
      ['MMRN1', 'FLT4', 'RELN', 'CCL21', 'PROX1', 'LYVE1'],
      ['CD69', 'IL7R', 'CD3D', 'CD3E', 'CD3G', 'ACTA2', 'MYO1B', 'ACTA2', 'ANPEP', 'PDGFRB', 'CSPG4'],
      ['DDX49', 'LOC105371196', 'MTND1P30', 'LOC105373682', 'TAGLN2', 'ZNF836', 'ZNF677', 'COILP1']
  ]

  usage1:
      
      from AICelltype import aicelltype
      cell_lt = aicelltype(tissue_name, gene_lt, model='gpt4')
      print(cell_lt)
  output1:
      ['Prostate Epithelial Cells', 'Lymphatic Endothelial Cells', 'T Cell and Myofibroblast', 'Unknown Cell Type']  # In result, you can get a list with four cell types which have the same order with parameter gene_list.

  usage2:
      
      import os
      os.environ['QWEN_KEY'] = 'your QWEN_KEY'  # Add QWEN_KEY to environ, keep secret to yourself.

      from AICelltype import aicelltype
      cell_lt = aicelltype(tissue_name, gene_lt, model='qwen-max')
      print(cell_lt)
  output2:
      ['Prostate secretory epithelial cell', 'Lymphatic endothelial cell', 'Immune cell (likely T-cell) and smooth muscle cell mixture', 'Unknown cell type']

  usage3:
      
      import os
      os.environ['API_KEY'] = 'your AIP_KEY'  # Add API_KEY to environ, keep secret to yourself.
      os.environ['SECRET_KEY'] = 'your SECRET_KEY'  # Add SECRET_KEY to environ, keep secret to yourself.

      from AICelltype import aicelltype
      cell_lt = aicelltype(tissue_name, gene_lt, model='ERNIE-4.0')
      print(cell_lt)
  output3:
      ['Prostate glandular cells (or Prostate epithelial cells)', 'Lymphatic endothelial cells', 'T-cells (or T-lymphocytes)', 'Unknown cell type (or Possibly cancer-associated cells or Stromal cells; needs further investigation)']  # This model give more explaination.
  ```


pkgId: bb58ae0ea81bf76bfc87b0b7cd91712b1825292e40cc0c51896c9715b31be9b8
name: python-AIFrameWork
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: A library for performaing machine learning tasks with ease
url: https://pypi.org/project/AIFrameWork/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AIFrameWork-0.0.5-1.src.rpm
checksum_type: sha256
description:
  This is a Python library that provides functionality for performing machine learning tasks with ease.



  You can install this library using pip:

  ```bash
  pip install AIFrameWork
  ```
  Usage

  Here is an example of how to use this library.

  SINGLE TARGET REGRESSION

  from my_library import RegressionSingleTarget


  model = RegressionSingleTarget()


  model.fit(X_train, y_train)


  y_pred = model.predict(X_test)


pkgId: e8c3cece25549b5823abf162629de58c0367ae8cbd79aa131db79d28521b99d8
name: python-AIFunction
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: Generate realtime AI Functions!
url: https://github.com/nekumelon/AIFunction
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AIFunction-1.0.9-1.src.rpm
checksum_type: sha256
description:
  Generate realtime AI Functions!



  To install AI Function, run:

  ```bash
  pip install AIFunction
  ```



  To use AIFunction, you must have an OpenAI API key.

  Firstly, add a .env file to your project, and add the following:

  ```
  OPENAI_API_KEY="key_here"
  ```

  Then, import the aiFunction function:

  ```python
  from AIFunction import aiFunction
  ```

  Now, you can use the aiFunction function to generate AI Functions!

  ```python
  print(aiFunction("bitcoin_price", "Returns the current price of bitcoin."));

  ```



  Let's say you want to write a function to get the current time in python. All you have to do is:

  ```python
  from AIFunction import aiFunction

  print(aiFunction("time", "Returns the current time."));

  ```



  AI function uses OpenAI's GPT model to generate the code for the function. It then runs the code and returns the output. If specified, it will also install the required packages for the code.



  AI Functions are not very secure, as they run code without any user testing, and can be used to run malicious code.


pkgId: 444117b3afe191b55c0c04abcc94ec87bc71553635bdfae8106e86654a36707e
name: python-AILungMeasure
arch: src
version: 0.2.3
epoch: 0
release: 1
url: https://doi.org/10.1016/j.ajt.2024.08.015
rpm_license: Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AILungMeasure-0.2.3-1.src.rpm
checksum_type: sha256
summary:
  Automated lung size measurements using deep learning and computer vision on portable chest radiographs.

description:
  [![DOI](https://zenodo.org/badge/DOI/10.1016/j.ajt.2024.08.015.svg)](https://doi.org/10.1016/j.ajt.2024.08.015)




  AILungMeasure is a Python package designed for automated lung size measurements using deep learning and computer vision on portable chest radiographs. This package aims to improve accuracy, reduce variability, and streamline the lung transplantation size matching process.

  ![Model_Framework](https://github.com/MostafaI/AILungMeasure/blob/main/Images/framework.png?raw=true)



  - Automated lung mask extraction from chest radiographs
  - Feature points detection to generate lung height and width measurements
  - Validation against measurements reported by radiologists
  - Robust performance even with technically challenging radiographs



  You can install AILungMeasure via pip:

  ```bash
  pip install AILungMeasure
  ```





  AILungMeasure includes a pre-trained model for lung size measurements. When importing the package, the model will be automalically downloaded and loaded.
  ```python
  import AILungMeasure
  ```



  To get the lung mask, use the `get_mask` function:

  ```python
  input_image = '/path/to/your/image' # can be dicom, jpg, png, etc..
  mask = AILungMeasure.get_mask(input_image)
  ```
  To visualize the mask, use the `show_mask` function:

  ```python
  mask = AILungMeasure.show_mask(input_image)


  matplotlib.pyplot.imshow(mask)
  ```



  To plot the lung measurements, use the `show_measurments` function:

  ```python
  AILungMeasure.show_measurments(input_image , dpi=200) # dpi controls the image resolution
  ```

  To get the measurments, use the `get_measurments` function:
  ```python
  measurments = AILungMeasure.get_measurments(input_image)
  ```
  Note that this will work if the input_image is dicom, which already includes the pixel size in its meta data. The reported measurments will be in mm.
  If you are using jpg, png, etc.. then the returned measurments will be in pixels.



  ```python
  import AILungMeasure

  input_image = '/media/Mostafa12TB/CXRs/dicom-3_15_2024/DICOMS Only/EE0C0DF7'
  AILungMeasure.show_measurments(input_image)
  ```
  ![Model_Framework](https://github.com/MostafaI/AILungMeasure/blob/main/Images/example.png?raw=true)
  ```
  AILungMeasure.get_measurments(input_image)

  {'R-ACPA': 209.51056325555803,
   'R-AMD': 155.81790884489396,
   'L-ACPA': 235.95200821775532,
   'L-AMD': 204.3306113771206,
   'width-at-hilum': 258.89750000000004,
   'width-at-base': 287.53000000000003}
  ```



  If you use this package, please cite the following DOI:
  [AI-Driven Automated Lung Sizing from Chest Radiographs](https://doi.org/10.1016/j.ajt.2024.08.015)





  This project is licensed under the Creative Commons ATTRIBUTION-NONCOMMERCIAL-SHAREALIKE 4.0 INTERNATIONAL.



  For questions or issues, please contact Mostafa Ismail at mostafa.ismail.k@gmail.com.


pkgId: 020303733ff5eccf1270061a796c96e4949b67fbcf97142b92d5aa8bde1249d1
name: python-AIOAladdinConnect
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Python Async API for controlling Genie garage doors connected to Aladdin Connect devices
url: http://github.com/mkmer/AIOAladdinConnect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AIOAladdinConnect-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Python module that allows interacting with Genie Aladdin Connect devices via AIOHttp

  Note that shared doors are not currently supported, only doors that are owned by your account can be controlled

  As of 1/24/2024 this libarary will be obsolete as Genie/Overhead door is moving to a new api.  While most of the interface will
  work with the new api, the websocket method will be changing to a new pre provided endpoint AND they will be moving to OAUTH
  authentication.  Once things settle, we will attempt to address the changes.


  ```
  from AIOAladdinConnect import AladdinConnectClient


  client_id = 1000
  client_session = aiohttp.ClientSession(timeout = aiohttp.ClientTimeout(total=30))
  client = AladdinConnectClient(email, password, client_session, client_id)
  await client.login()


  doors = await client.get_doors()
  my_door = doors[0]


  await client.close_door(my_door['device_id'], my_door['door_number'])
  await client.open_door(my_door['device_id'], my_door['door_number'])



  await client.async_get_door_status(my_door['device_id'], my_dooregister_callbackr['door_number'])
  client.get_door_status(my_door['device_id'], my_door['door_number'])


  await client.async_get_door_link_status(my_door['device_id'], my_door['door_number'])
  client.get_door_link_status(my_door['device_id'], my_door['door_number'])


  client.get_battery_status(my_door['device_id'], my_door['door_number'])
  client.get_rssi_status(my_door['device_id'], my_door['door_number'])
  client.get_ble_strength(my_door['device_id'], my_door['door_number'])

  ble_strength and battery_status are utilized with the retrofit devices (ALKT1-RB) where the door
  position sensor has a BLE connection and battery level reported.  Other devices (actual door openers)
  tend to report 0 for these values.


  Async versions by appending async (example):
  await client.async_get_battery_status(my_door['device_id'], my_door['door_number'])
  await client.async_get_rssi_status(my_door['device_id'], my_door['door_number'])
  await client.aycn_get_ble_strength(my_door['device_id'], my_door['door_number'])



  client.register_callback(your_callback_function)


  client.close()


  token = client.auth_token()


  client.set_auth_token(token)

  ```


pkgId: 03242d33ce0770bd6bdbc8551aed6d450ce7e8fa0c0a9ac8795ca1cd9cfb90e8
name: python-AISExplorer
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Wrapper to fetch data from marinetraffic
url: https://github.com/reyemb/AISExplorer
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AISExplorer-0.2.2-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/AISExplorer)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/AISExplorer)

  AISExplorer is a tool for locating vessels or scraping vessel data in a specific area. However, due to recent updates, the use of free proxies, previously scraped from sources like [sslproxies](https://www.sslproxies.org/), has been discontinued due to errors such as 403 Forbidden responses.



  - Explore additional sources for proxy lists.
  - Implement a method to customize the number of retries.
  - Introduce functionality to reset filters.





    - Due to Captcha implementation, login functionality is broken.
    - Sending requests through proxies now leads to a 403 error; proxy support has been removed.



  - Integrated login functions for additional features.



  - Implemented fallback if a proxy fails.
  - Introduced the ability to retrieve data directly via URL.
  - Added checks for Cloudflare's filtering mechanisms.



  - Early stages of filter implementation.
  - Retry options were added for resilience.
  - New exceptions were introduced for better error handling.



  - Proxy support was added (discontinued as of 2023-11-10).



  ``` cmd
  pip install aisexplorer
  ```




  Retrieve the current location of a vessel using its MMSI identifier.

  ```python
  from aisexplorer.AIS import AIS

  AIS().get_location(211281610)
  ```


  Retrieve data for up to 500 vessels within a designated area.

  **maximum 500 vessels**

  ```python
  from aisexplorer.AIS import AIS

  AIS(return_df= True).get_area_data("EMED")
  ```

  The output is limited to 500 rows. Area codes can be referenced from the MarineTraffic help section.
  [Areas](https://help.marinetraffic.com/hc/en-us/articles/214556408-Areas-of-the-World-How-does-MarineTraffic-segment-them-) can be found here


  Directly access table data using a MarineTraffic URL.

  ```python
  from aisexplorer.AIS import AIS

  AIS(return_df = True).get_data_by_url("https://www.marinetraffic.com/en/data/?asset_type=vessels&columns=time_of_latest_position:desc,flag,shipname,photo,recognized_next_port,reported_eta,reported_destination,current_port,imo,ship_type,show_on_live_map,area,lat_of_latest_position,lon_of_latest_position,speed,length,width&area_in|in|West%20Mediterranean,East%20Mediterranean|area_in=WMED,EMED&time_of_latest_position_between|gte|time_of_latest_position_between=60,NaN")
  ```



  Previously, AISExplorer allowed fetching data using proxies for anonymization. This feature is no longer supported due to compatibility issues with the data source.



  No longer available as it required user login, which is now deprecated due to captcha implementation.


pkgId: 11b93ee21a5de519781f91c68661f1ba476b87c67420dbdc0c8d11a7662a52ef
name: python-AIStructDynSolve
arch: src
version: 1.0
epoch: 0
release: 1
url: https://pypi.org/project/AIStructDynSolve/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AIStructDynSolve-1.0-1.src.rpm
checksum_type: sha256
summary:
  A framework focused on solving structural dynamics problems using artificial intelligence (AI) methods

description:
  A framework focused on solving structural dynamics problems using artificial intelligence (AI) methods
  solve the following ODE of MDOF
  M*U_dotdot+C*U_dot+K*U=Pt
  initial condition: U(t=0)=InitialU, and U_dot(t=0)=InitialU_dot
  Author: Ke Du(鏉滆讲) duke@iem.ac.cn
  Date: 2023/12/26


pkgId: 296dcad664cc66aa62cde26be53688b6cf68cdbccab442c85d88b75164742313
name: python-AJGM
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: .
url: https://pypi.org/project/AJGM/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AJGM-1.0.9-1.src.rpm
checksum_type: sha256
description:
  - The package needs these Python modules to be installed beforehand.
    1. pywt, install using: "conda install pywavelets"
    2. prox_tv, install using: "pip install prox_tv"
    3. Other commonly used Python packages: numpy, pandas, scipy, scikit-learn

  We recommend using Python version ≥ 3.7.
  The package can only be used on Mac or Linux, not on Windows, because the "prox_tv" module is not available for Windows.





  In the following example, we consider generating samples from three subtypes. The method of sample generation is consistent with the simulation study described in paper. Each subtype has the same number of
  genes and the same number of samples($p=200$, ${n_k} = 300$).

  In AJGM, the input data should be a matrix where each row represents the gene expression values of different samples. In this example, the input matrix has 900 rows and 200 columns.



  - `X`: In the AJGM code, we use X to represent the samples $x$.
  - `Y`: In the AJGM code, we use Y to represent the representative samples ${x^{'}}$.
  - `L`: Number of subtypes.
  - `lambda1`, `lambda2`, `lambda3`: Penalty parameters $\lambda_1, \lambda_2, \lambda_3$.
  - `miu`, `tre`: Parameters for adaptive weights $\gamma$, $tre$ (all default: 0.1).
  - `impute_x`: Boolean, whether to perform imputation for samples X (default: False).
  - `impute_y`: String, specifies imputation method for representative samples Y：
    'x': Imputation method if we set representative samples Y as X.
    'sample': Imputation method if we generate representative samples Y by sampling.
    'none': Do not perform imputation for Y (default).
  - `EMthreshold`: EM algorithm convergence threshold (default: 0.1).
  - `MAX_iter`: Maximum number of iterations for the EM algorithm (default: 100).



  We first use method setting ${x_l}$ as $x_l^{'}$ to obtain representative sample Y. Since the generated data follows a mixture of multivariate normal distributions, data imputation is not necessary.

  ```python
  res1=AJGM(X=A, Y=A, L=3, lambda1=0.01, lambda2=0.01, lambda3=0.1,miu=0.1,tre=0.1,impute_x=False,
  impute_y='none', EMthreshold=0.1, MAX_iter=100)
  ```

  We then use sampling to generation representative sample Y. The function ‘sample_multivariate_normal‘ can obtain Y through sampling. The parameter n represents the number of samples obtained through sampling.

  ```python
  B=sample_multivariate_normal(A, n=100)
  res1=AJGM(X=A, Y=B, L=3, lambda1=0.01, lambda2=0.01, lambda3=0.1,miu=0.1,tre=0.1,impute_x=False,
  impute_y='none', EMthreshold=0.1, MAX_iter=100)
  ```



  The AJGM function returns a dictionary with the following components:

  - pie: Estimated parameters $\pi$.
  - mu: Estimated parameters $\mu$.
  - covinv: Estimated parameters $\Omega$ (The precision matrices for $K$ subtypes and an overall precision matrix). The matrix covinv is of size $p$ rows by $p*(K+1)$ columns. Columns $1$ to $p$ represent the precision matrices for subgroup 1, columns $p+1$ to $2*p$ represent subgroup 2, and so on. Columns $p*K+1$ to $p*(K+1)$ represent the precision matrix for the overall network.
  - membership: Cell classification results.



  1. Souvik Seal, Qunhua Li, Elle Butler Basner, Laura M Saba, and Katerina Kechris. Rcfgl: Rapid condition adaptive fused graphical lasso and applica-tion to modeling brain region co-expression networks. PLoS computational biology, 19(1):e1010758, 2023.
  2. Tan. Research on gene network inference method and application based on probabilistic graph modeling. PhD thesis, Central China Normal University, 2022.


pkgId: a0a0073270271eab3fa765fb524b310dbc67ed165307dc91b99a50e4aa6824da
name: python-AKRUP
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Ancestral Karyotype Reconstruction Universal Pipeline
url: https://github.com/Genome-structure-evolution-analysis/AKRUP
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AKRUP-1.0.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/AKRUP)](https://pypi.org/project/AKRUP/)

  AKRUP: Ancestral Karyotype Reconstruction Universal Pipeline

  |         |                                                 |
  | ------- | ----------------------------------------------- |
  | Author  | wangjiaqi                                        |
  | Email   | <wangjiaqiky@163.com>                           |
  | License | [BSD](http://creativecommons.org/licenses/BSD/) |



  Include "bottom-up" inferences of ancestral karyotypes and "top-down" inferences of ancient chromosome evolutionary trajectories





  + **Pypi**

    ~~~
    pip install AKRUP
    ~~~



  **The AKRUP requires the following dependencies :**

  - Python (>3.7) with matplotlib, *biopython*, *click*,  *numpy*，*pandas*, and *scipy* libraries.
    **Note that the current version no longer supports python 2.**

  - R with the ggridges and *ggplot2* packages.

  - perl with the *[BioPerl](https://metacpan.org/pod/BioPerl)*  packages.



  **Dependent third party software that has been integrated：**

  |         |                                                 |
  | ------- | ----------------------------------------------- |
  |  **clustalw2**  | **[Larkin et al., 2007](https://academic.oup.com/bioinformatics/article/23/21/2947/371686)**  |
  | **ColinearScan** | **[Wang et al., 2006](https://bmcbioinformatics.biomedcentral.com/articles/10.1186/1471-2105-7-447)** |
  |    **blast+**    | **[Camacho et al., 2009](https://bmcbioinformatics.biomedcentral.com/articles/10.1186/1471-2105-10-421)** |





  + Default parameters, configuration files and usage instructions for all subroutines of the AKRUP software are provided. Please consult the documentation at the [Wiki](https://github.com/Genome-structure-evolution-analysis/AKRUP/wiki).

  + Detailed user tutorials and test data are provided. Please consult the documentation on [AKRUP-example](https://github.com/Genome-structure-evolution-analysis/AKRUP-example).

  + Provides ancestral karyotypes for multiple phylogenetic nodes of monocots. Please consult the documentation on [monocots-karyotype-evolution](https://github.com/Genome-structure-evolution-analysis/monocots-karyotype-evolution).





  If you use AKRUP for  your work, please cite:


pkgId: a19a52adc26217e0e0cc0c35396dd90093a85b4948657b460245f76c46f4e0e9
name: python-AL-Khatma-lib
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: A library Specialized About Islamic
url: https://github.com/oaokm/AL-Khatma
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AL-Khatma-lib-2.0.3-1.src.rpm
checksum_type: sha256
description:
  `ID`  |  مُعرف الخاص للأية الكريمة
  `Name`|  أسم السورة الكريمة
  `Transliteration`|  السورة الكريمة بلغات أخرى
  `translation`| حرفي/تهجأ أسم اللسورة الكريمة لغير العرب
  `type`|  نوع السورة الكريمة، إمّا مّكيِّة أو مدنيّة
  `total_verses`|  إجمالي عدد أيات في السورة الكريمة
  `verses_no`|  يوضج لك ترتيب السورة بين السور، بناءًا على نسخة القرآن الكريم لمجمع الملك فهد لطباعة المصحف الشريف
  `jozz`|  يوضح لك مكان الأية الكريمة بالنسبة للجزء
  `page`|  يوضح لك مكان الأية الكريمة بالنسبة للصفحة
  `verses_number`|  يوضح لك موقع الأية الكريمة في السورة
  `line_start`| يوضح لك موقع الأية بالنسبة لمكان ظهوره في بداية السطر(بناءًا على نسخة القرآن الكريم لمجمع الملك فهد لطباعة المصحف الشريف)
  `line_end`| يوضح لك موقع الأية الكريمة بالنسبة لمكان ظهوره في نهاية السطر (بناءًا على نسخة القرآن الكريم لمجمع الملك فهد لطباعة المصحف الشريف)
  `verses_text`| نص الأية الكريمة مع التشكيل
  `verses_text_without_diacritical`| نص الأية الكريمة بدون التشكيل
  `verses_text_english`| نص الأية الكريمة باللغات آخرى
  `verses_text_transliteration`| حرفي/تهجأ الأية الكريمة لغير العرب

  هناك عدّة طرق لكتابة أمر `show_block_aya`:
  ```py
  >>> from AL_Khatma.quran import Quran # تقوم هنا بأستدعاء المكتبة
  >>> quran = Quran() # أستدعاء للكائن
  >>> sura  = quran.show_block_aya(1, []) # أمر أستدعاء السورة بناءًا على ترتيبها في الفهرس مع كافة أياتها ومعلوماتها
  >>> sura
  ([{'ID': 1, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 1, 'line_start': 2, 'line_end': 2, 'verses_text': 'بِسۡمِ ٱللَّهِ ٱلرَّحۡمَٰنِ ٱلرَّحِيمِ', 'verses_text_without_diacritical': 'بسم الله الرحمن الرحيم', 'verses_text_english': 'In the name of Allah, the Entirely Merciful, the Especially Merciful', 'verses_text_transliteration': 'Bismi Allahi alrrahmani alrraheemi'}, {'ID': 2, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 2, 'line_start': 3, 'line_end': 3, 'verses_text': 'ٱلۡحَمۡدُ لِلَّهِ رَبِّ ٱلۡعَٰلَمِينَ', 'verses_text_without_diacritical': 'الحمد لله رب العالمين', 'verses_text_english': '[All] praise is [due] to Allah, Lord of the worlds', 'verses_text_transliteration': 'Alhamdu lillahi rabbi alAAalameena'}, {'ID': 3, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 3, 'line_start': 4, 'line_end': 4, 'verses_text': 'ٱلرَّحۡمَٰنِ ٱلرَّحِيمِ', 'verses_text_without_diacritical': 'الرحمن الرحيم', 'verses_text_english': 'The Entirely Merciful, the Especially Merciful', 'verses_text_transliteration': 'Alrrahmani alrraheemi'}, {'ID': 4, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 4, 'line_start': 4, 'line_end': 4, 'verses_text': 'مَٰلِكِ يَوۡمِ ٱلدِّينِ', 'verses_text_without_diacritical': 'مالك يوم الدين', 'verses_text_english': 'Sovereign of the Day of Recompense', 'verses_text_transliteration': 'Maliki yawmi alddeeni'}, {'ID': 5, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 5, 'line_start': 5, 'line_end': 5, 'verses_text': 'إِيَّاكَ نَعۡبُدُ وَإِيَّاكَ نَسۡتَعِينُ', 'verses_text_without_diacritical': 'إياك نعبد وإياك نستعين', 'verses_text_english': 'It is You we worship and You we ask for help', 'verses_text_transliteration': 'Iyyaka naAAbudu waiyyaka nastaAAeenu'}, {'ID': 6, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 6, 'line_start': 5, 'line_end': 6, 'verses_text': 'ٱهۡدِنَا ٱلصِّرَٰطَ ٱلۡمُسۡتَقِيمَ', 'verses_text_without_diacritical': 'اهدنا الصراط المستقيم', 'verses_text_english': 'Guide us to the straight path', 'verses_text_transliteration': 'Ihdina alssirata almustaqeema'}, {'ID': 7, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 7, 'line_start': 6, 'line_end': 8, 'verses_text': 'صِرَٰطَ ٱلَّذِينَ أَنۡعَمۡتَ عَلَيۡهِمۡ غَيۡرِ ٱلۡمَغۡضُوبِ عَلَيۡهِمۡ وَلَا ٱلضَّآلِّينَ', 'verses_text_without_diacritical': 'صراط الذين أنعمت عليهم غير المغضوب عليهم ولا الضالين', 'verses_text_english': 'The path of those upon whom You have bestowed favor, not of those who have evoked [Your] anger or of those who are astray', 'verses_text_transliteration': 'Sirata allatheena anAAamta AAalayhim ghayri almaghdoobi AAalayhim wala alddalleena'}], [])
  ```
  لتحديد أية بعينها تقوم بالتالي:
  ```py
  >>> len(sura) # عدد العناصر المرجعة من أمر `quran.show_block_aya`
  2
  >>> sura[0][0] # طباعة معلومات الأية المحددة
  {'ID': 1, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 1, 'line_start': 2, 'line_end': 2, 'verses_text': 'بِسۡمِ ٱللَّهِ ٱلرَّحۡمَٰنِ ٱلرَّحِيمِ', 'verses_text_without_diacritical': 'بسم الله الرحمن الرحيم', 'verses_text_english': 'In the name of Allah, the Entirely Merciful, the Especially Merciful', 'verses_text_transliteration': 'Bismi Allahi alrrahmani alrraheemi'}
  >>> sura[0][0]['verses_text_without_diacritical'] # طباعة شيء محدد من القاموس
  'بسم الله الرحمن الرحيم'
  ```

  > **الملاحظة الأولى**: يمكنك وضع أكثر من أية، بشرط ألا تتعدى مجموع عدد الأيات في السورة؛ لأن البرنامج سيقوم بإرجاع لا شيء لقيمتك التي وضعتها.
  > **الملاحظة الثانية**: يمكنك إهمال ترتيب الأيات(في متغير القائمة) ، ولكن حبذا أن يكون مرتبًا.
  ```py
  >>> from AL_Khatma.quran import Quran # تقوم هنا بأستدعاء المكتبة
  >>> quran = Quran() # أستدعاء للكائن
  >>> sura  = quran.show_block_aya(1, [6, 7]) # نقوم هنا بأستدعاء السورة مع تحديد أيات التي نريدها
  >>> sura[1] # قم بتحديد العنصر المخصص للأيات المخصصة
  [{'ID': 6, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 6, 'line_start': 5, 'line_end': 6, 'verses_text': 'ٱهۡدِنَا ٱلصِّرَٰطَ ٱلۡمُسۡتَقِيمَ', 'verses_text_without_diacritical': 'اهدنا الصراط المستقيم', 'verses_text_english': 'Guide us to the straight path', 'verses_text_transliteration': 'Ihdina alssirata almustaqeema'}, {'ID': 7, 'Name': 'الفَاتِحة', 'Transliteration': 'Al-Fātiḥah', 'translation': 'The Opener', 'type': 'meccan', 'total_verses': 7, 'verses_no': 1, 'jozz': 1, 'page': 1, 'verses_number': 7, 'line_start': 6, 'line_end': 8, 'verses_text': 'صِرَٰطَ ٱلَّذِينَ أَنۡعَمۡتَ عَلَيۡهِمۡ غَيۡرِ ٱلۡمَغۡضُوبِ عَلَيۡهِمۡ وَلَا ٱلضَّآلِّينَ', 'verses_text_without_diacritical': 'صراط الذين أنعمت عليهم غير المغضوب عليهم ولا الضالين', 'verses_text_english': 'The path of those upon whom You have bestowed favor, not of those who have evoked [Your] anger or of those who are astray', 'verses_text_transliteration': 'Sirata allatheena anAAamta AAalayhim ghayri almaghdoobi AAalayhim wala alddalleena'}]
  >>> len(sura[1]) # معرفة عدد الأيات التي طلبنا تحديدها
  2
  ```

  توفر لك مكتبة الختمة عدد جيد من اللغات الأجنبية. ولمعرفة اللغات المتوفرة في المكتبة يمكنك كتابة الأمر التالي:
  > **ملاحظة**: عند إستدعاء الكائن "Quran" فهو تلقائيًا يختار ملف الذي يحتوي على اللغتين العربية والإنجليزية. فلا داعي أن تحدد إذا أردت هذان اللغتين.
  ```py
  >>> from AL_Khatma.quran import Quran
  >>> quran = Quran(lang='?')
  The Available Languages Of The Quran
  [0] fr
  [1] es
  [2] tr
  [3] ru
  [4] bn
  [5] zh
  [6] id
  [7] ar, en (main)
  [8] sv
  [9] ur
  ```


pkgId: d32f636b0db7d4acd3d10af54bf085ac38a5af58589ac3402dcbe8e5375ab4ad
name: python-ALASutils
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: ALAS utils for daily tasks.
url: https://github.com/JPCalderon/ALASutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ALASutils-0.0.13-1.src.rpm
checksum_type: sha256
description:
  Command to install the package

  ```pip install ALASutils```

  Better

  ```pip install ALASutils --upgrade```

  Much better

  ```pip install --no-cache-dir ALASutils```


pkgId: 10303fed14916afb8f563e70bb228512ba1d55b58d520bf3663060d417893e99
name: python-ALLCools
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Toolkit for single-cell DNA methylome and multiomic data analysis.
url: https://pypi.org/project/ALLCools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ALLCools-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://img.shields.io/github/workflow/status/lhqing/allcools/Test/main)](https://github.com/lhqing/allcools/actions/workflows/test.yml)
  [![Jupyter Book Badge](https://jupyterbook.org/badge.svg)](https://lhqing.github.io/ALLCools/intro.html)

  Please see [documentation](https://lhqing.github.io/ALLCools/intro.html).


pkgId: ed3b7480c19ff72f260a25086e50b44c70002751651267a9f6b1a3b0312338c9
name: python-ALR32XX
arch: src
version: 1.3
epoch: 0
release: 1
summary: Ce module permet de commander via liaison série les alimentations programmables ALR32XX de ELC
url: https://github.com/elc-construction-electronique/Librairie-Python-ALR32XX
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ALR32XX-1.3-1.src.rpm
checksum_type: sha256
description:
  <h3> <a href="#EN"> English version bellow</a> </h3>

  <br/>
  Documentation complète de la librairie : https://elc-construction-electronique.gitbook.io/librairie-python-alr32xx/ <br/>
  Complete documentation of the library : https://elc-construction-electronique.gitbook.io/alr32xx-python-library-documentation-en/ <br/>
  <br/>
  <p id="FR">
  Librairie <a href="https://www.python.org/downloads/" target="_blank" title="Lien d téléchargement Python" > Python</a> pour piloter les alimentations programmables <strong>ALR3220, ALR3203, ALR3206D/T</strong> par une liaison série (USB, RS232, RS485).
  </p>



  <h2>Installation du module</h2>

  Le module ALR32XX necessite d'avoir installé Python et la librairie PySerial : <a href="https://pythonhosted.org/pyserial/pyserial.html" target="_blank">pip install pyserial</a>. La procédure d'installation est detaillée dans le gitbook à la page <a href="https://elc-construction-electronique.gitbook.io/librairie-python-alr32xx/utilisation-de-la-librairie-python/installation-de-la-librairie" target="_blank">Installation de la librairie</a>.

  L'installation de la librairie ALR32XX se fait alors de deux façons :
  <ul>
  	<li>Utilisation du code dans un projet :
  		Telechargez le .zip via le <a href="https://github.com/elc-construction-electronique/Librairie-Python-ALR32XX">repository github</a>. Dans ce dossier vous trouverez le code source ALR32XX.py, un dossier avec des exemples d'utilisation et un dossier avec les documentations de la librairie et des alimentations.
  	<li>Téléchargement de la librairie via Pip :
  		Notre librairie ALR32XX est accessible via <a href="https://pypi.org/project/ALR32XX/">PyPI</a>, la rendant téléchargeable par la commande "pip install ALR32XX". </br>Vous pouvez trouver des renseignements et la version de la librairie par la commande "pip show ALR32XX" et, si besoin, la mettre à jour par "pip install ALR32XX --upgrade".</br>
  		<img src="Documentation/Images/install_cmd.PNG" alt="Installation de la librairie par ligne de commande">
  </ul>

  <h2>Utilisation du module</h2>
  <p>
  Une fois l'installation terminée vous pouvez acceder à la bibliothèque par "from ALR32XX import *" (si vous installez par pip, "from ALR32XX.ALR32XX import *"). </br>
  Reliez l'alimentation à l'ordinateur par USB, RS232 ou RS485. Vous pouvez verifier la connexion dans le gestionnaire de périphérique et sur l'ecran de l'alimentation :</br>
  <img src=Documentation/Images/gest_periph.PNG alt="Vérification de la conexion de l'alimentation">
  </br>
  Le programme fonctionne sous la forme d'une classe, il faut declarer un objet qui correspondra à l'alimentation. Par exemple pour une ALR3203, la declaration se fera par "nom=ALR32XX('ALR3203')". Le programme tente alors d'établir automatiquement une communication avec l'alimentation et renvoie Port=COM3; Nom=ALR3203; Connexion=OK. </br>
  Si la tentative échoue, il vous sera demandé de connecter l'alimentation manuellement par la fonction Choix_port(). Cette fonction va lister vos ports actifs et vous demandera d'entrer le numéro de celui qu'il faut connecter :</br>
  <img src=Documentation/Images/connect_manuel.PNG alt="Connexion manuelle à l'alimentation">
  </br>
  Une fois la connexion réussie, vous pouvez utiliser la librairie. Par exemple X.Mesure_tension() pour mesurer la tension de votre ALR3203. Une liste des fonctions disponibles est donnée dans la <a href="https://github.com/elc-construction-electronique/Librairie-Python-ALR32XX/tree/main/Documentation">documentation</a> et sur le  <a href="https://elc-construction-electronique.gitbook.io/librairie-python-alr32xx/utilisation-de-la-librairie-python/installation-de-la-librairie">Gitbook</a>
  </p>


  <h2>Contact</h2>
  En cas de problème lors de l'utilisation de la librairie, veuillez nous contacter à <a href="mailto: commercial@elc.fr">commercial@elc.fr</a> ou au +33 4 50 57 30 46.
  </br>
  </br>

  <img src="Documentation/Images/ALR32XX.png" alt="Gamme d'alimentations programmables">



  </br>
  </br></br>
  </br></br>
  </br></br>
  </br></br>
  </br></br>
  </br></br>
  </br>











  <h1 id="EN">English version</h1>
  </br>
  Complete documentation of the library : https://elc-construction-electronique.gitbook.io/alr32xx-python-library-documentation-en/<br/><br/>
  <p>
  	<a href="https://www.python.org/downloads/" target="_blank" title="Python download link" > Python</a> library to drive the <strong>ALR3220, ALR3203, ALR3206D/T</strong> programmable power supplies via a serial link (USB, RS232, RS485).


  <h2>Module installation</h2>

  The ALR32XX module requires Python and the PySerial library to be installed: <a href="https://pythonhosted.org/pyserial/pyserial.html" target="_blank">pip install pyserial</a>. The installation procedure is detailed in the gitbook at <a href="https://elc-construction-electronique.gitbook.io/alr32xx-python-library-documentation-en/utilisation-de-la-librairie-python/installation-de-la-librairie" target="_blank">Installing the library</a>.


  The installation of the ALR32XX library is done in two ways:
  <ul>
  	<li>Using the code in a project:
  		Download the .zip via the <a href="https://github.com/elc-construction-electronique/Librairie-Python-ALR32XX">github repository</a>. In this folder you will find the ALR32XX.py source code, a folder with usage examples and a folder with the library and power supplies documentations.
  	<li>Downloading the library via Pip:
  		Our ALR32XX library can be accessed via <a href="https://pypi.org/project/ALR32XX/">PyPI</a>, making it downloadable via the command "pip install ALR32XX". </br>You can find information and the version of the library via the command "pip show ALR32XX" and, if needed, update it via "pip install ALR32XX --upgrade".</br>
  		<img src="Documentation/Images/install_cmd.PNG" alt="Installing the library by command line">

  </ul>

  <h2>Using the module</h2>
  <p>
  Once the installation is finished you can access the library by "from ALR32XX import *". (if you install by pip, "from ALR32XX.ALR32XX import *"). </br>
  Connect the power supply to the computer via USB, RS232 or RS485. You can check the connection in the device manager and on the power supply screen:</br>.
  <img src=Documentation/Images/gest_periph.PNG alt="Checking the power connection">
  </br>
  The program works in the form of a class, it is necessary to declare an object which will correspond to the power supply. For example for an ALR3203, the declaration would be "name=ALR32XX('ALR3203')". The program will then try to automatically establish a communication with the power supply and return Port=COM3; Name=ALR3203; Connection=OK. </br>
  If the attempt fails, you will be asked to connect the power supply manually via the Choix_port() function. This function will list your active ports and ask you to enter the number of the one to connect:</br>
  <img src=Documentation/Images/connect_manuel.PNG alt="Manually connect to power">
  </br>
  Once the connection is successful, you can use the library. For example X.Mesure_tension() to measure the voltage of your ALR3203. A list of available functions is given in the <a href="https://github.com/elc-construction-electronique/Librairie-Python-ALR32XX/tree/main/Documentation">documentation</a> and on the <a href="https://elc-construction-electronique.gitbook.io/alr32xx-python-library-documentation-en/utilisation-de-la-librairie-python/installation-de-la-librairie">Gitbook</a>
  </p>


  <h2>Contact</h2>
  If you have any problems using the library, please contact us at <a href="mailto: commercial@elc.fr">commercial@elc.fr</a> or +33 4 50 57 30 46.  </br>
  </br>

  <img src="Documentation/Images/ALR32XX.png" alt="Programmable power supply range">


pkgId: 87d712256156e41f77e6a09fb08c9ea84982d0a1f780151a9089c42a2b85d3fc
name: python-ALifeStdDev
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Python development tools for working with standardized ALife data.
url: https://github.com/alife-data-standards/alife-std-dev-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ALifeStdDev-0.3.3-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/alife-data-standards/alife-std-dev-python/actions/workflows/CI.yaml/badge.svg)](https://github.com/alife-data-standards/alife-std-dev-python/actions/workflows/CI.yaml)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/0305e8a814e04d4395c25a70b2908651)](https://www.codacy.com/gh/alife-data-standards/alife-std-dev-python/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=alife-data-standards/alife-std-dev-python&amp;utm_campaign=Badge_Grade)
  [![codecov](https://codecov.io/gh/alife-data-standards/alife-std-dev-python/branch/master/graph/badge.svg?token=FGMQICJ2SK)](https://codecov.io/gh/alife-data-standards/alife-std-dev-python)
  ![PyPI](https://img.shields.io/pypi/v/ALifeStdDev?color=blue)

  This is the repository for the ALifeStdDev Python package, which contains Python
  development utilities for working with [standardized](https://github.com/alife-data-standards/alife-data-standards)
  ALife data.



  ALifeStdDev can be installed using pip:

  ```
  pip install ALifeStdDev
  ```



  To load a single submodule,

  ```python3
  from ALifeStdDev import phylogeny as asd_phylo
  asd_phylo.load_phylogeny_to_pandas_df("myfile.csv")
  ```

  To load the library as a flat namespace,

  ```python3
  from ALifeStdDev import ALifeStdDev as asd
  asd.load_phylogeny_to_pandas_df("myfile.csv")
  ```


pkgId: 09a0c59466e963c842f9e96c4d5857351aa56208531e389c358e8f9c8fb46b53
name: python-AMAS-sb
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: AMAS (Automatic Model Annotation System)
url: https://github.com/sys-bio/AMAS
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AMAS-sb-1.0.1-1.src.rpm
checksum_type: sha256
description:
  ``AMAS`` (Automatic Model Annotation System) predicts and recommends annotations for systems biology models. It uses information of species and reactions in the SBML models and provides recommendations. The algorithm uses ChEBI for species annotations, and Rhea for reaction annotations. ``AMAS`` was developed and tested using [BioModels](https://www.ebi.ac.uk/biomodels/) and [BiGG](http://bigg.ucsd.edu/).

  For more information, please check our
  [Read the Docs](https://amas.readthedocs.io/en/latest/
  ) page.


pkgId: 36cadfc6266d51614e3c078d00b40ff478096ad1872b363a44febb154b4cc4de
name: python-AMAT
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Aerocapture Mission Analysis Tool
url: https://github.com/athulpg007/AMAT
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AMAT-2.3.0-1.src.rpm
checksum_type: sha256
description:
  Aerocapture Mission Analysis Tool (AMAT) is designed to provide rapid mission
  analysis capability for aerocapture and atmospheric Entry, Descent, and Landing (EDL)
  mission concepts to the planetary science community. AMAT was developed at the
  [Advanced Astrodynamics Concepts (AAC)](https://engineering.purdue.edu/AAC/)
  research group at Purdue University.

  See [AMAT documentation](https://amat.readthedocs.io) for more details.

  [![Documentation Status](https://readthedocs.org/projects/amat/badge/?version=master)](https://amat.readthedocs.io/en/master/?badge=master) [![DOI](https://joss.theoj.org/papers/10.21105/joss.03710/status.svg)](https://doi.org/10.21105/joss.03710) [![PyPI version](https://badge.fury.io/py/AMAT.svg)](https://badge.fury.io/py/AMAT)

  If you find AMAT useful in your work, please consider citing us:
  Girija et al., (2021). AMAT: A Python package for rapid conceptual design of
  aerocapture and atmospheric Entry, Descent, and Landing (EDL) missions in a
  Jupyter environment. *Journal of Open Source Software*, 6(67), 3710,
  [DOI: 10.21105/joss.03710](https://doi.org/10.21105/joss.03710)




  AMAT allows the user to simulate atmospheric entry trajectories, compute deceleration
  and heating loads, compute aerocapture entry corridors and simulate aerocapture
  trajectories. AMAT supports analysis for all atmosphere-bearing destinations
  in the Solar System: Venus, Earth, Mars, Jupiter, Saturn, Titan, Uranus, and Neptune.
  AMAT allows the calculation of launch performance for a set of launch vehicles.
  AMAT allows the calculation of V-inf vector from a Lambert arc for an interplanetary
  transfer. AMAT allows calculation of planetary approach trajectories for orbiters and entry
  systems from a given V_inf vector, B-plane targeting, and deflection maneuvers.
  AMAT allows the calculation of visibility of landers to Earth and relay orbiters
  and compute telecom link budgets.


  ![Venus Aerocapture Trajectory and Heating](https://raw.githubusercontent.com/athulpg007/AMAT/master/plots/craig-lyne-altitude-higher-res-lower-size.png)
  ![Venus Aerocapture Trajectory and Heating](https://raw.githubusercontent.com/athulpg007/AMAT/master/plots/craig-lyne-heating-higher-res-lower-size.png)

  ![Neptune Aerocapture Feasibility](https://raw.githubusercontent.com/athulpg007/AMAT/master/plots/girijaSaikia2019b-higher-res-lower-size.png)

  ![Monte Carlo Simulations](https://raw.githubusercontent.com/athulpg007/AMAT/master/plots/girijaSaikia2020b-fig-13-N5000.png)
  ![Monte Carlo Simulations](https://raw.githubusercontent.com/athulpg007/AMAT/master/plots/girijaSaikia2020b-apo-histogram-N5000.png)




  AMAT comes with a number of example
  [Jupyter notebooks](https://amat.readthedocs.io/en/master/jupyter_link.html) to help users get started. The examples inculde:

  1. Venus aerocapture assesssment study
  2. Titan aerocapture assessment study
  3. Neptune aerocapture using blunt-body aeroshells
  4. Drag modulation aerocapture asssessment
  5. Planetary probe entry at various Solar System destinations



  * Easy installation,
  * Many examples and recreation of results from published literature
  * Extensive documented source code
  * Can be used for probe and lander Entry, Descent, Landing (EDL) calculations
  * Comes with a standard set of nominal atmospheric models



  Note: AMAT is currently supported on Python ``3.8``, ``3.9``, and ``3.10``.

  There are two ways to install AMAT.



  This is the recommended method if you do not plan or need to make changes
  to the source code.

  Note: Python Package Index limits the amount of additional data that can be
  packaged in the distribution, hence all data cannot be included in the built version.
  You will need to clone the GitHub repository to get the required
  data files, examples, and start using AMAT.

  Create a virtual environment and activate it. It is strongly recommended you install
  AMAT inside a virtual environment to prevent it from affecting your global python
  packages.

  Change directory to where you want the virtual environment to be created.
    * ```$ cd home/path```


    * ```$ python3 -m venv env1```
    * ```$ source env1/bin/activate```


    * ```$ conda create --name env1```
    * ```$ conda activate env1```
    * ```$ conda install pip```


    * ```$ git clone https://github.com/athulpg007/AMAT.git```
    * ```$ pip install AMAT```


  Once AMAT is installed, run an example Jupyter notebook to check everything works correctly.
    * ```$ cd AMAT/examples```
    * ```$ jupyter-notebook```

  Note that you will need jupyterlab and pandas (for some examples) to run
  the example notebooks. Use ```pip install jupyterlab pandas``` to
  install Jupyter and pandas if it is not already installed on your system.
  This will display the full list of example Jupyter notebooks included with AMAT.
  Open and run the ```example-01-hello-world``` notebook to get started with AMAT.



  This is the recommended method if you need to make changes to the source code.

  Create a virtual environment and activate it
  following the steps at the beginning of Option 1.

  Clone the GitHub repository and install AMAT using setup.py. The -e editable
  flag allows changes you make to take effect when using AMAT.
    * ```$ git clone https://github.com/athulpg007/AMAT.git```
    * ```$ cd AMAT```
    * ```$ python setup.py install -e```
    * ```$ cd examples```
    * ```$ jupyter-notebook```


  Note that you will need jupyterlab and pandas (for some examples)
  to run the example notebooks. Use ```pip install jupyterlab pandas```
  to install Jupyter and pandas if it is not already installed on your system.


  If you want to create a new distribution package:
    * ```$ python3 setup.py sdist bdist_wheel```

  To build docs locally if you made changes to the source code
  (you must have the dependencies in ```docs/requirements.txt``` installed):
    * ```$ cd AMAT/docs```
    * ```$ make html```



  AMAT is an open source project licensed under the GNU General
  Public License Version 3.



  Parts of the AMAT source code were originally developed in support of contracts between AAC and the Jet Propulsion Laboratory for various aerocapture mission studies between 2016 and 2020. Samples of atmospheric data from Global Reference Atmospheric Model (GRAM) software is used for illustration purpose only, and was developed by NASA Marshall Space Flight Center. The use of these GRAM models does not imply endorsement by NASA in any way whatsoever. A minimal working set of atmospheric profiles is included with AMAT to run the example notebooks. A minimal working interplanetary trajctory dataset is included with AMAT. The dataset was generated at Purdue University using the STOUR software package by Alec Mudek, and is also derived from trajectories published in the NASA Ice Giants Pre-Decadal Mission Study. The author plans to augment the interplanetary dataset with more publicly available information as it becomes available.



  If you wish to contribute or report an issue, feel free to [contact me](mailto:athulpg007@gmail.com) or to use the [issue tracker](https://github.com/athulpg007/AMAT/issues) and [pull requests](https://github.com/athulpg007/AMAT/pulls) from the [code repository](https://github.com/athulpg007/AMAT).

  If you wish to make a contribution, you can do as follows:

   * fork the GitHub repository
   * create a feature branch from *master*
   * add your feature and document it
   * add tests to verify your feature is implemented correctly
   * run all the tests to verify your change does not break something else
   * open a pull request



  The AMAT repository includes representative atmospheric profiles for
  Solar System bodies, an Excel sheet with a comprehensive literature review of
  aerocapture, sample feasibility charts for aerocapture at all destinations,
  reference journal articles (by the author).



  Results from these articles are used as benchmark examples.

  1. Craig, Scott, and James Evans Lyne. "Parametric Study of Aerocapture for Missions to Venus." Journal of Spacecraft and Rockets Vol. 42, No. 6, pp. 1035-1038. [DOI: 10.2514/1.2589](https://arc.aiaa.org/doi/10.2514/1.2589)

  2. Putnam and Braun, "Drag-Modulation Flight-Control System Options for Planetary Aerocapture", Journal of Spacecraft and Rockets, Vol. 51, No. 1, 2014. [DOI:10.2514/1.A32589](https://arc.aiaa.org/doi/10.2514/1.A32589)

  3. Lu, Ye, and Sarag J. Saikia. "Feasibility Assessment of Aerocapture for Future Titan Orbiter Missions." Journal of Spacecraft and Rockets Vol. 55, No. 5, pp. 1125-1135. [DOI: 10.2514/1.A34121](https://arc.aiaa.org/doi/10.2514/1.A34121)

  4. Girija, A. P., Lu, Y., & Saikia, S. J. "Feasibility and Mass-Benefit Analysis of Aerocapture for Missions to Venus". Journal of Spacecraft and Rockets, Vol. 57, No. 1, pp. 58-73. [DOI: 10.2514/1.A34529](https://arc.aiaa.org/doi/10.2514/1.A34529)

  5. Girija, A. P. et al. "Feasibility and Performance Analysis of Neptune
  Aerocapture Using Heritage Blunt-Body Aeroshells", Journal of Spacecraft and Rockets, Vol. 57, No. 6, pp. 1186-1203. [DOI: 10.2514/1.A34719](https://arc.aiaa.org/doi/full/10.2514/1.A34719)

  6. Girija A. P. et al. "Quantitative Assessment of Aerocapture and Applications to Future Missions", Journal of Spacecraft and Rockets, 2022.
  [DOI: 10.2514/1.A35214](https://arc.aiaa.org/doi/full/10.2514/1.A35214)


pkgId: 40ac50276a8bb906810f99314177f2018b3be666e4366225eb47589eab3dd25a
name: python-AMDirT
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: AMDirT: AncientMetagenomeDir Toolkit
url: https://github.com/SPAAM-community/AMDirT
rpm_license: GNU-GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AMDirT-1.6.2-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4003825.svg)](https://doi.org/10.5281/zenodo.4003825) [![PyPI version](https://badge.fury.io/py/AMDirT.svg)](https://pypi.org/project/AMDirT) [![Documentation Status](https://readthedocs.org/projects/amdirt/badge/?version=dev)](https://amdirt.readthedocs.io/en/dev/?badge=dev) [![AMDirT-CI](https://github.com/SPAAM-community/AMDirT/actions/workflows/ci_test.yml/badge.svg)](https://github.com/SPAAM-community/AMDirT/actions/workflows/ci_test.yml)

    <picture>
      <img alt="AMDirT Logo" src="https://raw.githubusercontent.com/SPAAM-community/AMDirT/master/assets/logo_rectangular_transparent.png">
    </picture>

  **AMDirT**: [**A**ncient**M**etagenome**Dir**](https://github.com/SPAAM-community/ancientmetagenomedir) **T**oolkit

  AMDirT is a toolkit for interacting with the AncientMetagenomeDir metadata repository of ancient metagenomic samples and ancient microbial genomes.

  This tool provides ways to explore and download sequencing data for ancient microbial and environmental (meta)genomes, automatically prepare input samplesheets for a range of bioinformatic processing pipelines, and to validate AncientMetagenomeDir submissions.

  For documentation on using the tool, please see [How Tos](https://amdirt.readthedocs.io/en/latest/how_to/index.html), [Tutorials](https://amdirt.readthedocs.io/en/latest/tutorials/index.html) and/or [Quick Reference](https://amdirt.readthedocs.io/en/latest/reference.html).



  AMDirT has been tested on different Unix systems (macOS and Ubuntu) using Intel and AMD chips. If you suspect that AMDirT isn't working properly because you use a different hardware/OS, please open an [issue on GitHub](https://github.com/SPAAM-community/AMDirT/issues).



  ```bash
  pip install amdirt
  ```



  Installing AMDirT in a dedicated [conda](https://docs.conda.io/projects/miniconda/en/latest/index.html) environment

  ```bash
  conda create -n amdirt -c bioconda amdirt #install amdirt in a dedicated conda environment
  conda activate amdirt # activate the conda environment

  conda deactivate amdirt # deactivate the conda environment
  ```



  ```bash
  pip install --upgrade --force-reinstall git+https://github.com/SPAAM-community/AMDirT.git@dev
  ```



  - Fork AMDirT on GitHub
  - Clone your fork `git clone [your-AMDirT-fork]`
  - Checkout the `dev` branch `git switch dev`
  - Create the conda environment `conda env create -f environment.yml`
  - Activate the environment `conda activate amdirt`
  - Install amdirt in development mode `pip install -e .`
    - In some cases you may need to force update streamlit with `pip install --upgrade steamlit`

  To locally render documentation:

  - `conda activate amdirt`
  - Install additional requirements `cd docs && pip install -r requirements.txt`
  - Build the HTML `make html`
  - Open the `build/html/README.html` file in your browser



  For more information, please see the AMDirT Documentation

  - Stable: [amdirt.readthedocs.io/en/latest/](https://amdirt.readthedocs.io/en/latest/)
  - Development version: [amdirt.readthedocs.io/en/dev/](https://amdirt.readthedocs.io/en/dev/)


pkgId: b245b390cee3de563db5f7c53fc3b21c4ced22b793a835403f1cec1e29ae6336
name: python-AMFM-decompy
arch: src
version: 1.0.11
epoch: 0
release: 1
url: https://github.com/bjbschmitt/AMFM_decompy/
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AMFM-decompy-1.0.11-1.src.rpm
checksum_type: sha256
summary:
  Package containing the tools necessary for decomposing a speech signal into its modulated components, aka AM-FM decomposition.

description:
  version 1.0.11
  This python package provides the tools necessary for decomposing the voiced part of a speech signal into its modulated components, aka AM-FM decomposition. This designation is used due the fact that, in this method, the signal is modeled as a sum of amplitude- and frequency-modulated components.
  The goal is to overcome the drawbacks from Fourier-alike techniques, e.g. SFFT, wavelets, etc, which are limited in the time-frequency analysis by the so-called Heisenberg-Gabor inequality.
  The algorithms here implemented are the QHM (Quasi-Harmonic Model), and its upgrades, aQHM (adaptive Quasi-Harmonic Model) and eaQHM (extended adaptive Quasi-Harmonic Model). Their formulation can be found at references [2-4].
  Since that the tools mentioned above require a fundamental frequency reference, the package also includes the pitch tracker YAAPT (Yet Another Algorithm for Pitch Tracking) [1], which is extremely robust for both high quality and telephone speech.
  The study of AM-FM decomposition algorithms was the theme from my Master Thesis. The original YAAPT program in MATLAB is provided for free by its authors, while the QHM algorithms I implemented by myself also in MATLAB. I'm porting them now to python because:
  * the python language is easier to share, read and understand, making it a  better way to distribute the codes;
  * is more resourceful than MATLAB (has different data structures, scripting  options, etc), which will be useful for me in future studies;
  * the computational performance from its numeric and scientific packages (numpy  and scipy) is equivalent to MATLAB;
  * python is free-to-use, while MATLAB is a proprietary software;


pkgId: 0afc343f67511969736de0ecb2b85898290276e121b9c442b0f6a11a57c669c7
name: python-AMFTools
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: AMF Tools is a python package to control Advanced Microfluics SA devices
url: https://amf.ch
rpm_license: proprietary license (Advanced Microfluidics SA)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AMFTools-0.1.7-1.src.rpm
checksum_type: sha256
description:
  AMF TOOLS Python Library is a python library to control AMF products (RVMFS, RVMLP, SPM and LSPOne) with a serial connection protocol.





  - Python 3.8 or higher
  - pyserial 3.4 or higher
  - ftd2xx 1.1.2 or higher

  currently only tested on Windows 11 with Python 3.11 an update will be made for alternative OS



  ```bash
  pip install AMFTools
  ```



  ```bash
  git clone
  cd AMFTools
  python setup.py install
  ```


  This Library is proprietary software of **Advanced Microfluidics S.A**. It is distributed under a proprietary license [[1](#license-text "the licence")].

  This Library is free to use for Advanced Microfluidics SA customers. It is not free to use for non-customers of Advanced Microfluidics SA.

  If you have any questions about the license, please contact Advanced Microfluidics SA:
  - Chem. de la Dent d'Oche 1A, 1024 Ecublens (Switzerland)
  - +41 21 552 14 30
  - info@amf.ch



  *This version of the data sheet is for the version 0.1.7 of the AMFTools library.*



  ```python
  import amfTools
  ```




  ```python
  AMF(product : Object, autoconect : bool = True, portnumber : int = None, syringeVolume : int = None, productAddress : int = 1, type : str = None, serialBaudrate : int = None)

  ```
  Initialize the AMF object. Either serialPort, serialNumber or a Device type object must be specified as product.



  ```python
  connect(serialBaudrate : int = defaultSerialBaudrate, serialTimeout : float = defaultSerialTimeout) -> bool
  ```
  Connect to the product. If the connection is successful, return True, otherwise return False.

  ```python
  disconnect()
  ```
  Disconnect from the product

  ```python
  send(command : str, integer : bool = False, force_aws : bool = False)
  ```
  Send a command to the product. If the command is successful, return the response of the product. If integer is True, the response will be converted to an integer. If force_aws is True, the product will be temporarily set to wait for an answer even if it is set to not wait for an answer.

  ```python
  receive(integer = False, full : bool = False, isfloat : bool = False) -> str
  ```
  Receive a line of response from the product. If integer is True, the response will be converted to an integer. If full is True, the response will be returned as is, without removing the first and last character. If float is True, the response will be converted to a float.

  ```python
  prepareCommand(command : str, parameter : int = None) -> str
  ```
  Prepare a command to be sent to the product. If the command needs a parameter, it must be specified. The parameter must be an integer.

  ```python
  pullAndWait(homming_mode : bool = False)
  ```
  Wait until the valve and the pump are not busy.




  ```python
  setAddress(address : int)
  ```
  Set the Address of the product. The Address must be between 1 and 9. (1 by default)

  ```python
  setSyringeSize(size : int)
  ```
  Set the syringe size of the product. The size must be between 0 and 5000 ( $\mu l$ ).

  ```python
  setAnswerMode(mode : int)
  ```
  Set the answer mode of the product. The mode must be between 0 and 2. 0: synchronous, 1:  Asynchronous, 2: same as asynchronous but add number of subcommand processed in its last answer

  ```python
  setPortNumber(portnumber : int = portnumber)
  ```
  Set the port number of the product's valves.

  ```python
  setSpeedVolume(speed : float, syringeVolume : int = syringeSize) -> int
  ```
  Set the speed of the product. The speed must be positive. The syringe volume must be between 0 and 5000  ( $\mu l$ ).

  ```python
  setSpeed(speed : int)
  ```
  Set the speed of the product. The speed must be between 0 and 6000 (pulse/sec).

  ```python
  setSpeedCode(speed : int)
  ```
  Set the speed of the product with a code. The speed must be between 0 and 50.

  ```python
  setAccelerationRate(rate : int)
  ```
  Set the acceleration rate of the product. The rate must be between 1 and 59590.

  ```python
  setDecelerationRate(rate : int)
  ```
  Set the deceleration rate of the product. The rate must be between 1 and 59590.

  ```python
  setMicrostepResolution(argument : int)
  ```
  Set the microstep resolution of the product. ( 0: 0.01mm resolution/step, 1: 0.00125mm resolution/step )

  ```python
  setSlowMode()
  ```
  Set the slow mode of the product.

  ```python
  setFastMode()
  ```
  Set the fast mode of the product.

  ```python
  setPumpStrengthAndHome(strength : int, block : bool = True)
  ```
  Set the pump strength and home the pump. The strength must be between 0 and 3. If block is True, the function will wait until the pump is not busy.

  ```python
  setPlungerForce(force : int)
  ```
  Set the plunger force of the product. The force must be between 0 and 3.

  ```python
  setNoAwser()
  ```
  Set the product to not wait for an answer. (If the product is set to not wait for an answer, it will not send any answer even if you force it with force_aws parameters)




  ```python
  getSerialPort(serialNumber : str = serialNumber) -> str
  ```
  Find the serial port of the product with the specified serial number

  ```python
  getSerialNumber(serialPort = serialPort) -> str
  ```
  Get the serial number of the product

  ```python
  getType()
  ```
  Autoset the type of the product (SPM, RVMFS or RVMLP)

  ```python
  getPortNumber() -> int
  ```
  Get the number of port of the product's valve

  ```python
  getCurrentStatus() -> str
  ```
  Get the current status of the product

  ```python
  getValvePosition() -> int
  ```
  Get the valve position of the product

  ```python
  getRealPlungerPosition() -> int :
  ```
  Get the real plunger position of the product

  ```python
  getPlungerPosition() -> int
  ```
  Get the plunger position of the product

  ```python
  getNumberValveMovements() -> int
  ```
  Get the number of valve movements of the product

  ```python
  getNumberValveMovementsSinceLastReport() -> int
  ```
  Get the number of valve movements since last report of the product

  ```python
  getSpeedMode() -> str
  ```
  Get the speed mode of the product

  ```python
  getFirmwareChecksum() -> str
  ```
  Get the firmware checksum of the product

  ```python
  getFirmwareVersion() -> str
  ```
  Get the firmware version of the product

  ```python
  getValveAddress() -> int
  ```
  Get the valve address of the product

  ```python
  getValveConfiguration() -> int
  ```
  Get the valve configuration of the product

  ```python
  getMicrostepResolution() -> int
  ```
  Get the microstep resolution of the product

  ```python
  getPlungerCurrent() -> int
  ```
  Get the plunger current of the product

  ```python
  getAnswerMode() -> str
  ```
  Get the answer mode of the product

  ```python
  getAcceleration() -> int
  ```
  Get the acceleration of the product

  ```python
  getDeceleration() -> int
  ```
  Get the deceleration of the product

  ```python
  getSupplyVoltage() -> float
  ```
  Get the supply voltage of the product

  ```python
  getUniqueID() -> str
  ```
  Get the unique ID of the product

  ```python
  getValveStatus() -> int
  ```
  Get the valve status of the product

  ```python
  getPumpStatus() -> int
  ```
  Get the pump status of the product

  ```python
  getHomeStatus() -> bool
  ```
  Get the homing status of the product (False: not homed, True: homed)

  ```python
  getDeviceInformation() -> object
  ```
  Get all the information of the product



  ```python
  checkValveStatus()
  ```
  Check the valve status of the product

  ```python
  checkPumpStatus()
  ```
  Check the pump status of the product

  ```python
  sendBrute(command : str, blocked : bool = True, force_aws : bool = False)
  ```
  Send a command to the product. If blocked is True, the function will wait until the product is not busy. If force_aws is True, the function will ask for an answer even if the product is set to not wait for an answer.

  ```python
  internalReset()
  ```
  Reset the product

  ```python
  executeLastCommand()
  ```
  Execute the last command of the product

  ```python
  delay(delay : int)
  ```
  Delay the product. The delay must be positive.

  ```python
  home(block = True)
  ```
  Home the product. If block is True, the function will wait until the product is not busy.

  ```python
  valveShortestPath(target : int, enforced : bool = False, block : bool = True)
  ```
  Move the valve to the target port with the shortest path. The target must be between 1 and the number of ports of the product. If enforced is True, the valve will Move to the target port with the shortest path even if it is not the shortest path. If block is True, the function will wait until the product is not busy.

  ```python
  valveIncrementalMove(target : int, enforced : bool = False, block : bool = True)
  ```
  Move the valve to the target port with an incremental Move. The target must be between 1 and the number of ports of the product. If enforced is True, the valve will Move even if they are already on the target point (1 complete rotation). If block is True, the function will wait until the product is not busy.

  ```python
  valveClockwiseMove(target : int, enforced : bool = False, block : bool = True)
  ```
  Move the valve to the target port with an incremental Move. The target must be between 1 and the number of ports of the product. If enforced is True, the valve will Move even if they are already on the target point (1 complete rotation). If block is True, the function will wait until the product is not busy.

  ```python
  valveDecrementalMove(target : int, enforced : bool = False, block : bool = True)
  ```
  Move the valve to the target port with a decremental Move. The target must be between 1 and the number of ports of the product. If enforced is True, the valve will Move even if they are already on the target point (1 complete rotation). If block is True, the function will wait until the product is not busy.

  ```python
  valveCounterClockwiseMove(target : int, enforced : bool = False, block : bool = True)
  ```
  Move the valve to the target port with a decremental Move. The target must be between 1 and the number of ports of the product. If enforced is True, the valve will Move even if they are already on the target point (1 complete rotation). If block is True, the function will wait until the product is not busy.

  ```python
  valveMove(target : int, mode : int = 0, enforced = False, block : bool = True)
  ```
  Move the valve to the target port. The target must be between 1 and the number of ports of the product. The mode must be between 0 and 2. 0: ShortestPath, 1: IncrementalMove, 2: DecrementalMove. If enforced is True, the valve will Move even if they are already on the target point (1 complete rotation). If block is True, the function will wait until the product is not busy.

  ```python
  hardStop()
  ```
  Stop the product (immediate stop of the valve and the pump)

  ```python
  powerOff()
  ```
  Power off the product



  ```python
  pumpAbsolutePosition(position : int, block : bool = True)
  ```
  Move the pump to the specified position. The position must be between 0 and 3000 (or 24000). If block is True, the function will wait until the product is not busy.

  ```python
  pump(position : int, block : bool = True)
  ```
  Move the pump to the specified position. The position must be between 0 and 3000 (or 24000). If block is True, the function will wait until the product is not busy.

  ```python
  pumpVolume(volume : int, syringeVolume : int = syringeSize, block : bool = True)
  ```
  Move the pump to the specified volume. The volume must be between 0 and 5000 ( $\mu l$ ). If syringeVolume is specified, it will be used as the syringe volume. If block is True, the function will wait until the product is not busy.

  ```python
  pumpRelativePickup(position : int, block : bool = True)
  ```
  Move the pump to the specified relative position. The position must be between 0 and 3000 (or 24000). If block is True, the function will wait until the product is not busy.

  ```python
  pumpPickup(position : int, block : bool = True)
  ```
  Move the pump to the specified relative position. The position must be between 0 and 3000 (or 24000). If block is True, the function will wait until the product is not busy.

  ```python
  pumpPickupVolume(volume : int, syringeVolume : int = syringeSize, block : bool = True)
  ```
  Move the pump to the specified relative volume. The volume must be between 0 and 5000 ( $\mu l$ ). If syringeVolume is specified, it will be used as the syringe volume. If block is True, the function will wait until the product is not busy.

  ```python
  pumpRelativeDispense(position : int, block : bool = True)
  ```
  Move the pump to the specified relative position. The position must be between 0 and 3000 (or 24000). If block is True, the function will wait until the product is not busy.

  ```python
  pumpDispense(position : int, block : bool = True)
  ```
  Move the pump to the specified relative position. The position must be between 0 and 3000 (or 24000). If block is True, the function will wait until the product is not busy.

  ```python
  pumpDispenseVolume(volume : int, syringeVolume : int = syringeSize, block : bool = True)
  ```
  Move the pump to the specified relative volume. The volume must be between 0 and 5000 ( $\mu l$ ). If syringeVolume is specified, it will be used as the syringe volume. If block is True, the function will wait until the product is not busy.




  ```python
  SerialNumber : str = None
  ComPort : str = None
  DeviceType : str = None
  ```

  str method return example:
  "Device RVMFS on port com3 with serial number P201-O0000xxxx"


  ```python
  getProductList(specified_type = None) -> list :
  ```
  Return a list of Device object. If specified_type is specified, only the Device object with the specified type will be returned (exemple of specifie type : "SPM", "RVMFS" or "RVMLP").






  ``` richtext
  AMF Tools Python Package by Advanced Microfluidics SA

  Copyright (C) 2024 Advanced Microfluidics SA

  This Python Package is distributed to all AMF customers and partners for the sole purpose of using it with AMF products.

  The right to use this Python Package is included in the price of all AMF OEM products.

  REDISTRIBUTION AND USE in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
  - (i) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
  - (ii) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
  - (iii) Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
  - (iv) The use of this Python Package is restricted to AMF products.

  WARRANTY OF EVICTION. Advanced Microfluidics SA represents and warrants:
  - (i) that it holds all the Intellectual Property Rights required to enter into the Agreement;
  - (ii) that the Advanced Microfluidics SA Service, as well as the elements necessary for their operation provided in performance of the Agreement, do not infringe the rights of third parties and do not constitute an infringement of any pre-existing work or even infringement of any other software or other intellectual creation belonging to a third party;

  RESPONSIBILITY LIMITATION: This package is provided by the copyright holder and contributors "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the copyright holder or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage.

  Advanced Microfluidics SA reserves the right to modify this Agreement at any time by publishing a new version on https://amf.ch . The applicable terms and conditions are those in force on the date of the order.

  NUMBER OF COPIES: The Customer may make as many copies of the package as necessary for the use of the Package in accordance with the terms of this Agreement. The Customer may make a copy of the Package for backup purposes. The Customer may not make copies of the Package for any other purpose.

  DURATION: This Agreement is effective from the date of delivery of the AMF Product to the Customer and shall remain in force until terminated by either party.

  TERMINATION: This Agreement shall terminate automatically if the Customer fails to comply with any of the terms and conditions of this Agreement. In such event, the Customer must destroy all copies of the package.

  GEOGRAPHICAL RESTRICTIONS: The Customer may not export or re-export the Package or any copy or adaptation thereof in violation of any applicable locals laws or regulations.

  GOVERNING LAW: This Agreement shall be governed by and construed in accordance with the laws of Switzerland. The parties agree that the United Nations Convention on Contracts for the International Sale of Goods is specifically excluded from application to this Agreement.

  JURISDICTION: Any dispute arising out of or in connection with this Agreement shall be submitted to the exclusive jurisdiction of the courts of the Canton of Vaud, Switzerland.
  ```


pkgId: f5d0e28251fc15426e57124804fa94bb263a4610143448f0b51e37e202c99db1
name: python-AMPcombi
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A parsing tool for AMP tools.
url: http://pypi.python.org/pypi/AMPcombi/
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AMPcombi-2.0.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/Darcy220606/AMPcombi/main/docs/amp-combi-logo.png" width="300" height="250" />

  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Install with Bioconda](https://anaconda.org/bioconda/ampcombi/badges/downloads.svg)](https://anaconda.org/bioconda/ampcombi) [![Install with Bioconda](https://anaconda.org/bioconda/ampcombi/badges/version.svg)](https://anaconda.org/bioconda/ampcombi)


  **AMPcombi and its submodules provide a command-line interface to:**

  - parse the results of multiple antimicrobial peptide (AMP) prediction tools into a single table
  - align the AMP hits against a reference AMP database for functional and structural classifications
  - filter the AMP hits according to their physio-chemical properties
  - cluster the filtered AMP hits into AMP families
  - predict signaling peptides if present along the prepropeptide sequence

  📕 The full documentation for AMPcombi can be accessed [here](https://ampcombi.readthedocs.io/en/dev/main).

  📎 If you plan to use AMPcombi please don't forget to **cite** us 💚


pkgId: adf60d8e54c1ece2875799c6bd05133e0ebba4626a05ca6bb68e182249d0fc32
name: python-AMPcombi
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A parsing tool for AMP tools.
url: http://pypi.python.org/pypi/AMPcombi/
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AMPcombi-2.0.1-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/Darcy220606/AMPcombi/main/docs/amp-combi-logo.png" width="300" height="250" />

  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Install with Bioconda](https://anaconda.org/bioconda/ampcombi/badges/downloads.svg)](https://anaconda.org/bioconda/ampcombi) [![Install with Bioconda](https://anaconda.org/bioconda/ampcombi/badges/version.svg)](https://anaconda.org/bioconda/ampcombi)


  **AMPcombi and its submodules provide a command-line interface to:**

  - parse the results of multiple antimicrobial peptide (AMP) prediction tools into a single table
  - align the AMP hits against a reference AMP database for functional and structural classifications
  - filter the AMP hits according to their physio-chemical properties
  - cluster the filtered AMP hits into AMP families
  - predict signaling peptides if present along the prepropeptide sequence

  📕 The full documentation for AMPcombi can be accessed [here](https://ampcombi.readthedocs.io/en/v.2.0.1/).

  📎 If you plan to use AMPcombi please don't forget to **cite** us 💚


pkgId: 0d495f73c87dcf70f32b796e0023b29489351de8d602df721d355f2396cec7b7
name: python-AMR
arch: src
version: 2.1.1.9106
epoch: 0
release: 1
summary: A Python wrapper for the AMR R package
url: https://github.com/msberends/AMR
rpm_license: GPL 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AMR-2.1.1.9106-1.src.rpm
checksum_type: sha256
description:
  The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python Package Index](https://pypi.org/project/AMR/).

  This Python package is a wrapper round the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code.



  1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run:

      ```bash
      pip install AMR
      ```

  2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically.

      For Linux:

      ```bash
      
      sudo apt install r-base
      
      sudo dnf install R
      
      sudo yum install R
      ```

      For macOS (using [Homebrew](https://brew.sh)):

      ```bash
      brew install r
      ```

      For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R.





  Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package:

  ```python
  import pandas as pd
  import AMR


  data = {
      "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'],
      "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin']
  }
  df = pd.DataFrame(data)


  df['MO_clean'] = AMR.mo_name(df['MOs'])
  df['Drug_clean'] = AMR.ab_name(df['Drug'])


  print(df)
  ```

  | MOs         | Drug      | MO_clean           | Drug_clean    |
  |-------------|-----------|--------------------|---------------|
  | E. coli     | Cipro     | Escherichia coli   | Ciprofloxacin |
  | ESCCOL      | CIP       | Escherichia coli   | Ciprofloxacin |
  | esco        | J01MA02   | Escherichia coli   | Ciprofloxacin |
  | Esche coli  | Ciproxin  | Escherichia coli   | Ciprofloxacin |



  * **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli".

  * **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin".




  As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antibiotics`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames:

  ```python
  AMR.microorganisms
  ```

  | mo           | fullname                           | status   | kingdom  | gbif      | gbif_parent | gbif_renamed_to | prevalence |
  |--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------|
  | B_GRAMN      | (unknown Gram-negatives)           | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | B_GRAMP      | (unknown Gram-positives)           | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | B_ANAER-NEG  | (unknown anaerobic Gram-negatives) | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | B_ANAER-POS  | (unknown anaerobic Gram-positives) | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | B_ANAER      | (unknown anaerobic bacteria)       | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | ...          | ...                                | ...      | ...      | ...       | ...         | ...             | ...        |
  | B_ZYMMN_POMC | Zymomonas pomaceae                 | accepted | Bacteria | 10744418  | 3221412     | None            | 2.0        |
  | B_ZYMPH      | Zymophilus                         | synonym  | Bacteria | None      | 9475166     | None            | 2.0        |
  | B_ZYMPH_PCVR | Zymophilus paucivorans             | synonym  | Bacteria | None      | None        | None            | 2.0        |
  | B_ZYMPH_RFFN | Zymophilus raffinosivorans         | synonym  | Bacteria | None      | None        | None            | 2.0        |
  | F_ZYZYG      | Zyzygomyces                        | unknown  | Fungi    | None      | 7581        | None            | 2.0        |

  ```python
  AMR.antibiotics
  ```

  | ab  | cid         | name                 | group                      | oral_ddd | oral_units | iv_ddd | iv_units |
  |-----|-------------|----------------------|----------------------------|----------|------------|--------|----------|
  | AMA | 4649.0      | 4-aminosalicylic acid| Antimycobacterials         | 12.00    | g          | NaN    | None     |
  | ACM | 6450012.0   | Acetylmidecamycin    | Macrolides/lincosamides    | NaN      | None       | NaN    | None     |
  | ASP | 49787020.0  | Acetylspiramycin     | Macrolides/lincosamides    | NaN      | None       | NaN    | None     |
  | ALS | 8954.0      | Aldesulfone sodium   | Other antibacterials       | 0.33     | g          | NaN    | None     |
  | AMK | 37768.0     | Amikacin             | Aminoglycosides            | NaN      | None       | 1.0    | g        |
  | ... | ...         | ...                  | ...                        | ...      | ...        | ...    | ...      |
  | VIR | 11979535.0  | Virginiamycine       | Other antibacterials       | NaN      | None       | NaN    | None     |
  | VOR | 71616.0     | Voriconazole         | Antifungals/antimycotics   | 0.40     | g          | 0.4    | g        |
  | XBR | 72144.0     | Xibornol             | Other antibacterials       | NaN      | None       | NaN    | None     |
  | ZID | 77846445.0  | Zidebactam           | Other antibacterials       | NaN      | None       | NaN    | None     |
  | ZFD | NaN         | Zoliflodacin         | None                       | NaN      | None       | NaN    | None     |




  ```python
  import AMR
  import pandas as pd

  df = AMR.example_isolates
  result = AMR.resistance(df["AMX"])
  print(result)
  ```

  ```
  [0.59555556]
  ```



  One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python:

  ```python
  result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]])
  print(result2a)
  ```

  | Pathogen        | Amoxicillin     | Ciprofloxacin   | Piperacillin/tazobactam  |
  |-----------------|-----------------|-----------------|--------------------------|
  | CoNS            | 7% (10/142)     | 73% (183/252)   | 30% (10/33)              |
  | E. coli         | 50% (196/392)   | 88% (399/456)   | 94% (393/416)            |
  | K. pneumoniae   | 0% (0/58)       | 96% (53/55)     | 89% (47/53)              |
  | P. aeruginosa   | 0% (0/30)       | 100% (30/30)    | None                     |
  | P. mirabilis    | None            | 94% (34/36)     | None                     |
  | S. aureus       | 6% (8/131)      | 90% (171/191)   | None                     |
  | S. epidermidis  | 1% (1/91)       | 64% (87/136)    | None                     |
  | S. hominis      | None            | 80% (56/70)     | None                     |
  | S. pneumoniae   | 100% (112/112)  | None            | 100% (112/112)           |


  ```python
  result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain")
  print(result2b)
  ```

  | Pathogen       | Amoxicillin     | Ciprofloxacin    | Piperacillin/tazobactam  |
  |----------------|-----------------|------------------|--------------------------|
  | Gram-negative  | 36% (226/631)   | 91% (621/684)    | 88% (565/641)            |
  | Gram-positive  | 43% (305/703)   | 77% (560/724)    | 86% (296/345)            |


  In this example, we generate an antibiogram by selecting various antibiotics.



  With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance.

  By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows.

  Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python.


pkgId: 83a99d3f9f7ddc9c03efe890d2e226e6d13f38b53745d120826689f136bc45d8
name: python-AN-DiscordBot
arch: src
version: 3.9.4
epoch: 0
release: 1
summary: A highly customisable Discord bot
url: https://github.com/aditya-nugraha-bot
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AN-DiscordBot-3.9.4-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <br>
    <a href="https://github.com/aditya-nugraha-bot/AN-DiscordBot"><img src="https://imgur.com/pY1WUFX.png" alt="AN - Discord Bot"></a>
    <br>
    AN Discord Bot
    <br>
  </h1>

  <h4 align="center">Music, Moderation, Trivia, Stream Alerts and Fully Modular.</h4>

  <p align="center">
    <a href="https://discord.gg/WEMJKXY">
      <img src="https://discordapp.com/api/guilds/133049272517001216/widget.png?style=shield" alt="Discord Server">
    </a>
    <a href="https://www.patreon.com/Red_Devs">
      <img src="https://img.shields.io/badge/Support-Red!-yellow.svg" alt="Support Red on Patreon!">
    </a>
    <a href="https://www.python.org/downloads/">
      <img src="https://img.shields.io/badge/Made%20With-Python%203.7-blue.svg?style=for-the-badge" alt="Made with Python 3.7">
    </a>
    <a href="https://crowdin.com/project/red-discordbot">
      <img src="https://d322cqt584bo4o.cloudfront.net/red-discordbot/localized.svg" alt="Localized with Crowdin">
    </a>
  </p>
  <p align="center">
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code Style: Black">
    </a>
    <a href="http://makeapullrequest.com">
      <img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg">
    </a>
  </p>

  <p align="center">
    <a href="#overview">Overview</a>
    •
    <a href="#installation">Installation</a>
    •
    <a href="http://red-discordbot.readthedocs.io/en/v3-develop/index.html">Documentation</a>
    •
    <a href="#plugins">Plugins</a>
    •
    <a href="#join-the-community">Community</a>
    •
    <a href="#license">License</a>
  </p>



  AN is a fully modular bot – meaning all features and commands can be enabled/disabled to your
  liking, making it completely customizable. This is also a *self-hosted bot* – meaning you will need
  to host and maintain your own instance. You can turn AN into an admin bot, music bot, trivia bot,
  new best friend or all of these together!

  [Installation](#installation) is easy, and you do **NOT** need to know anything about coding! Aside
  from installation and updating, every part of the bot can be controlled from within Discord.

  **The default set of modules includes and is not limited to:**

  - Customisable command permissions

  **Additionally, other [plugins](#plugins) (cogs) can be easily found and added from our growing
  community of cog repositories.**



  **The following platforms are officially supported:**

  - Later



  AN is fully modular, allowing you to load and unload plugins of your choice, and install 3rd party
  plugins directly from Discord! A few examples are:

  - Cleverbot integration (talk to Red and she talks back)
  - Ban sync
  - Welcome messages
  - Casino
  - Reaction roles
  - Slow Mode
  - Anilist
  - And much, much more!

  Feel free to take a [peek](https://cogboard.red/t/approved-repositories/210) at a list of
  available 3rd party cogs!



  **AN** is in continuous development, and it’s supported by an active community which produces new
  content (cogs/plugins) for everyone to enjoy. New features are constantly added.

  Join us on our [Official Discord Server](https://discord.gg/WEMJKXY)!



  Released under the [GNU GPL v3](https://www.gnu.org/licenses/gpl-3.0.en.html) license.

  Red is named after the main character of "Transistor", a video game by
  [Super Giant Games](https://www.supergiantgames.com/games/transistor/).

  Artwork created by [Sinlaire](https://sinlaire.deviantart.com/) on Deviant Art for the Red Discord
  Bot Project.


pkgId: e8b523537bceb10bb650eca6c27cfaf1a83883087399a2cbf12018acfa566e5e
name: python-ANIAnimator
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: ANIAnimator makes the GIF file from a given chemical ANI file
url: https://github.com/eftalgezer/ANIAnimator
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ANIAnimator-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ANIAnimator.svg)](https://badge.fury.io/py/ANIAnimator)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/ANIAnimator.svg)](https://pypi.python.org/pypi/ANIAnimator/)
  [![Python package](https://github.com/eftalgezer/ANIAnimator/actions/workflows/python-package.yml/badge.svg)](https://github.com/eftalgezer/ANIAnimator/actions/workflows/python-package.yml)
  [![codecov](https://codecov.io/gh/eftalgezer/ANIAnimator/branch/main/graph/badge.svg?token=Q9TJFIN1U1)](https://codecov.io/gh/eftalgezer/ANIAnimator)
  [![Codacy Badge](https://app.codacy.com/project/badge/Coverage/b0a14b0216c4451a8743ebb9712eac64)](https://www.codacy.com/gh/eftalgezer/ANIAnimator/dashboard?utm_source=github.com&utm_medium=referral&utm_content=eftalgezer/ANIAnimator&utm_campaign=Badge_Coverage)
  [![PyPI download month](https://img.shields.io/pypi/dm/ANIAnimator.svg)](https://pypi.python.org/pypi/ANIAnimator/)
  [![PyPI download week](https://img.shields.io/pypi/dw/ANIAnimator.svg)](https://pypi.python.org/pypi/ANIAnimator/)
  [![PyPI download day](https://img.shields.io/pypi/dd/ANIAnimator.svg)](https://pypi.python.org/pypi/ANIAnimator/)
  ![GitHub all releases](https://img.shields.io/github/downloads/eftalgezer/ANIAnimator/total?style=flat)
  [![GitHub contributors](https://img.shields.io/github/contributors/eftalgezer/ANIAnimator.svg)](https://github.com/eftalgezer/ANIAnimator/graphs/contributors/)
  [![CodeFactor](https://www.codefactor.io/repository/github/eftalgezer/ANIAnimator/badge)](https://www.codefactor.io/repository/github/eftalgezer/ANIAnimator)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/b0a14b0216c4451a8743ebb9712eac64)](https://www.codacy.com/gh/eftalgezer/ANIAnimator/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=eftalgezer/ANIAnimator&amp;utm_campaign=Badge_Grade)
  [![PyPI license](https://img.shields.io/pypi/l/ANIAnimator.svg)](https://pypi.python.org/pypi/ANIAnimator/)
  [![DOI](https://zenodo.org/badge/541231117.svg)](https://zenodo.org/badge/latestdoi/541231117)

  ANIAnimator makes the GIF file from a given chemical ANI file.



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

  ```bash
  $ pip install ANIAnimator


  $ pip install -U ANIAnimator


  $ pip install -U git+https://github.com/eftalgezer/ANIAnimator.git
  ```



  - [ANIAnimator v0.0.1 tutorial](https://beyondthearistotelian.blogspot.com/2022/09/anianimator-v001-tutorial.html)
  - [What is new in ANIAnimator v0.1.0?](https://beyondthearistotelian.blogspot.com/2022/10/what-is-new-in-anianimator-v010.html)







  ```python
  ANIAnimator.animate(anifile="graphene.ANI")

  ```



  ```python
  ANIAnimator.animate(anifile="graphene.ANI", width=1920, height=1080) # defaults are 1920 × 1080, respectively

  ANIAnimator.animate(anifile="graphene.ANI", loop=1) # default is 0; 0 means loop, 1 means no loop

  ANIAnimator.animate(anifile="graphene.ANI", bonds_param=1.3) # default is 1.3, sets the bonds between atoms

  ANIAnimator.animate(anifile="graphene.ANI", camera=((40, 0, 0),
                                                      (0, 0, 0),
                                                      (0, 1, 0))) # if you need to set the camera
  ```




  ```sh
  $ python -m ANIAnimator graphene.ANI
  ```



  ```sh
  $ python -m ANIAnimator <ANI file> <width> <height> <loop> <bonds_param> camera=<param>

  $ python -m ANIAnimator graphene.ANI 1920 1080 1 1.3

  $ python -m ANIAnimator graphene.ANI 1920 1080 1 1.3 camera=40,0,0,0,0,0,0,1,0 # if you need to set the camera

  ```


  ANIAnimator uses [mogli](https://github.com/sciapp/mogli) to create PNG images of the steps in ANI files. The default of mogli package is `1.0`. ANIAnimator default is `1.3` since the experience shows that `1.3` is better. For details, see the [README.md of mogli package](https://github.com/sciapp/mogli/blob/master/README.md).


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

  Please make sure to update tests as appropriate.


  If you are using ANIAnimator, please citate relevant version. You can find the relevant citation [here](https://doi.org/10.5281/zenodo.7112024).

  ```bibtex
  @software{eftal_gezer_2023_7182193,
    author       = {Eftal Gezer},
    title        = {eftalgezer/ANIAnimator: v0.2.2},
    month        = jan,
    year         = 2023,
    publisher    = {Zenodo},
    version      = {v0.2.2},
    doi          = {10.5281/zenodo.7577421},
    url          = {https://doi.org/10.5281/zenodo.7577421}
  }
  ```


  [GNU General Public License v3.0](https://github.com/eftalgezer/ANIAnimator/blob/master/LICENSE)


pkgId: bdeb3f2fd58f9af9d6402aad824e32ef42380be85ccbbdd1e24aa52fdf268436
name: python-ANTConnect
arch: src
version: 2023.15.1
epoch: 0
release: 1
summary: Python SDK for ANT Common Data Engineering
url: https://antcde.io
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ANTConnect-2023.15.1-1.src.rpm
checksum_type: sha256
description:
  Provides access to an ANT CDE
  For more details, visit [docs.antcde.io](https://docs.antcde.io/)




  - Updates Tasks API Calls and includes download files


  - Adds Tasks API calls to the SDK


  - Adds multiple options in column create and column update


  - Complements update of API on ANTCDE


  - Added more consistancy


  - Bugfix


  - Bugfix Column Create


  - Initial version


pkgId: 9d2da56d108e68291e5a9cc18376f925e860b27b18e075b51a4c7614a4c116d2
name: python-AOMUSE
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: AO Muse package
url: https://github.com/AxlKings/AOMUSE
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AOMUSE-0.0.10-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">AO Muse</h1>

  <p align="center">
      <em>
          AO Muse package
      </em>
  </p>

  > Axel Iván Reyes Orellana

  This package allows the connection with a database of exposures to easy retrieval and processing.


  - [Installation](https://github.com/AxlKings/AOMUSE#installation)
  - [Requirements](https://github.com/AxlKings/AOMUSE#requirements)
  - [Before use](https://github.com/AxlKings/AOMUSE#before-execute)
  - [Data Structure](https://github.com/AxlKings/AOMUSE#data-structure)
  - [How to use](https://github.com/AxlKings/AOMUSE#how-to-use)
    - [Imports](https://github.com/AxlKings/AOMUSE#imports)
    - [Methods](https://github.com/AxlKings/AOMUSE#methods)



  Install using `pip`!

  ```sh
  $ pip install aomuse
  ```


  To use the package you need a database where your exposure data is stored, for example MariaDB:
  - [MariaDB](https://mariadb.org/)

  AO Muse library uses the following packages:
  - [PonyORM](https://ponyorm.org/)
  - [PyMySQL](https://pymysql.readthedocs.io/en/latest/)
  - [NumPy](https://numpy.org/)
  - [Pandas](https://pandas.pydata.org)
  - [AstroPy](https://www.astropy.org/)
  - [Json](https://docs.python.org/3/library/json.html)


  *For better understanding, the terms that are enclosed in curly brackets must be replaced with their corresponding values.*


  Before use its necessary a database where your exposure data is stored. If you have one already, you can skip this section.

  For this tutorial, we will use a MariaDB database.

  You will need the name of the DB, username and password for the connection.

  To create the database you have to login first (you can do it as root):
  ```
  mysql -u {user_name} -p
  ```
  Then you have to create an empty database:
  ```sql
  CREATE DATABASE {database_name};
  ```
  Create an user of the database:
  ```sql
  CREATE USER '{username}'@'localhost' IDENTIFIED BY '{password}';
  ```
  And finally grant privileges to the database user:
  ```sql
  GRANT ALL PRIVILEGES ON {database_name}.* TO '{username}'@'localhost';
  ```

  To use this library its very recommendable to use the following AO Muse script to retrieve the data from Muse files.

  [AO Muse Script](https://github.com/AxlKings/AOMUSE-2022-project)



  The following code cells define the structure of the database entities (Targets, Exposures and Processed Exposures) and how Pony map the classes with the tables. This structure is mandatory to use the AO Muse Package.
  ```python
  from pony.orm import *
  ```
  ```python

  db = Database()


  class Target(db.Entity):
      

      target_name = Required(str, unique=True)  # Required: Cannot be None

      

      exposures = Set('Exposure')  # One target contains a set of exposures
      processed_exposure = Optional('Processed_Exposure')


  class Exposure(db.Entity):
      

      observation_time = Required(datetime, unique=True)
      obs_id = Required(int, size=32, unsigned=True)
      insMode = Required(str)
      datacube_header = Optional(Json)
      raw_exposure_header = Optional(Json)
      raw_exposure_data = Optional(Json)
      raw_exposure_filename = Optional(str, unique=True)
      prm_filename = Optional(str, unique=True)
      pampelmuse_params = Optional(Json)
      sources = Optional(Json)
      pampelmuse_catalog = Optional(Json)
      raman_image_header = Optional(Json)
      maoppy_data = Optional(Json)

      
      sky_condition_start_time = Optional(float)
      sky_condition_start = Optional(LongStr)
      sky_comment_start = Optional(LongStr)
      sky_condition_end_time = Optional(float)
      sky_condition_end = Optional(LongStr)
      sky_comment_end = Optional(LongStr)

      

      target = Required('Target')  # One exposure belongs to a target
      processed_exposure = Optional('Processed_Exposure')

  class Processed_Exposure(db.Entity):
      observation_time = Required(datetime, unique=True)
      obs_id = Required(int, size=32, unsigned=True)
      insMode = Required(str)
      raw_filename = Optional(str, unique=True)
      ngs_flux = Optional(float)
      ttfree = Optional(bool)
      degraded = Optional(bool)
      glf = Optional(float)
      seeing = Optional(float)
      seeing_los = Optional(float)
      airMass = Optional(float)
      tau0 = Optional(float)
      
      num_sources = Optional(int, unsigned=True)
      sgs_data = Optional(Json) # sgs_data extension
      ag_data = Optional(Json) # ag_data extension
      sparta_cn2 = Optional(Json) # sparta_cn2 extension
      sparta_atm =Optional(Json) # sparta_atm extension
      psf_params = Optional(Json)
      sparta_iq_data = Optional(Json)
      sparta_iq_los_500nm = Optional(float)
      sparta_iq_los_500nm_nogain = Optional(float)

      

      target = Required('Target')  # One exposure belongs to a target
      exposure = Required('Exposure')
  ```





  In order to use the package, you have to import the database object.

  ```python
  from AOMUSE.db.Database import database
  ```

  Then, define the following parameters to stablish the connection with the database.

  ```python
  db_data = {
      "provider":{provider},
      "host":{ip},
      "user":{db_admin_username},
      "passwd":{db_admin_password},
      "db":{db_name}
  }
  ```

  If you are using MariaDB and localhost, then provider has to be "mysql" and host "127.0.0.1".

  Now, you can stablish the connection creating an instance of muse_db class provided by the AO Muse Package, which receive the database imported earlier and the previous database parameters.

  ```python
  from AOMUSE.ao.muse_db import muse_db
  aomuse_db = muse_db(database, **db_data)
  ```



  The package also offers the following methods which process exposures data or returns a Pandas DataFrame with their corresponding data.



  Process and store all the exposures stored in the database. If processed data existed previosly, it is deleted first.
  The processed data will be obtained by the Exposure table of the current database and will be stored in a new table (Processed_Exposure).

  'psf_params' and 'sparta_iq_data' fields are dictionaries (or Json) with several keys. The wavelength range has been sliced into 10 windows, where the windows that were in the laser range were skipped. For each exposure the key has an array of values, each value corresponds to the mean of the corresponding measure, indicated by the key, along the corresponding wavelenght window. Also, both fields has a key called "wavelength" that indicates the mean of the wavelength of each window not skipped.

  ```python
  aomuse_db.process()
  ```



  Return a DataFrame containing the metadata of the exposures and their corresponding exposure and processed exposure objects.

  ```python
  exposures = aomuse_db.get_exposures()
  exposures
  ```
  <img src=https://media.discordapp.net/attachments/957192747620659250/957192761491193866/unknown.png>
  <br><br/>



  Return a DataFrame containing the metadata of the processed exposures and their corresponding exposure and processed exposure objects.

  ```python
  processed_exposures = aomuse_db.get_processed_exposures()
  processed_exposures
  ```
  <img src=https://media.discordapp.net/attachments/957192747620659250/957193210072019034/unknown.png>
  <br><br/>



  Return a DataFrame containing some metadata and the processed data of exposures that are not tables or Jsons.

  ```python
  processed_data = aomuse_db.get_processed_data()
  processed_data
  ```
  <img src=https://media.discordapp.net/attachments/957192747620659250/957193388975869992/unknown.png>
  <br><br/>



  Return a DataFrame containing some metadata and the processed data of exposures that are tables or Jsons.

  ```python
  processed_tables = aomuse_db.get_processed_tables()
  processed_tables
  ```
  <img src=https://media.discordapp.net/attachments/957192747620659250/957193565811920916/unknown.png>
  <br><br/>

  If there is an error with the library or with the README, like a misspelling or something, do not be afraid to send me an email to axel.reyes@sansano.usm.cl and I will try to fix it as soon as posible. Thank you in advance.


pkgId: 04056d75f354c1fb454c798cb3e493589622e7aa5dfe7568654715026af14d37
name: python-APC-Temp-fetch
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: APC/Schneider UPS current temperature fetchers
url: https://pypi.org/project/APC-Temp-fetch/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-APC-Temp-fetch-0.0.9-1.src.rpm
checksum_type: sha256
description:
  This python package provides an unified interface to several UPS
  network adapters with different firmware versions. It does not
  support guessing which interface to use; that wasn't necessary yet.

  It supports the following interfaces:
  | `kind` | `description` |
  |--------|---------------|
  | `old`  | Simple interface using HTTP basic auth, information gets extracted from `upsstat.htm`, by finding the line mentioning `Internal Temperature` |
  | `frmnc` | Requires 2 HTTP requests, main characteristics are that the login form is named `frmLogin` in HTML, and the data is presented in a `<div>`-table, but parsable line-by-line |
  | `frmnc666` | Similar to `frmnc`; with 3 HTTP requests, but the status page is named `upstat.htm` (which makes the additional HTTP request necessary) |
  | `gden-nt07` | Similar to `frmnc`; with 3 HTTP requests, but the login form is named `HashForm1` instead, and the data representation is more complex, so a more full-blown HTML-parser is used; data structured via `<span>` items |
  | `cs121` | Unauthenticated HTTP API (simply pass `- -` as `<user> <password>`), information gets extracted from `main.shtml`, by parsing `_dw` and `&nbsp;` from an HTML table, line-by-line |
  | `cs141` | Simple JSON API (and the imo best interface of these); with 3 HTTP requests, characteristic is the the data is located at `/api/devices/ups/report` |

  The description provides some guidance which `kind` an interface is.
  You may also just try out each `kind` and check if any returns useful results,
  but (although unlikely) it may "brick" the network adapter until it is reset;
  usually seen when (thru some bug) the script isn't able to properly logout
  after a successful login, because many of these network adapters limit the
  number of concurrent logins, often to even just 1 user at a time.

  This package has 2 entry points:
  * `APC_Tempf [--verbose] [--proxy <proxy_url>] <kind> <host> <user> <password> [--timeout <timeout>]`
    `kind` is the one of these mentioned above.
    `host`, `user` and `password` should be self-explanatory.
    `timeout` is an optional per-request timeout.
    This is the primary, "simple" interface.

  * `APC_Tempstfe [--verbose] [--proxy <proxy_url>] <apclist>`
    allows querying multiple UPS devices sequentially, and is used to
    amortize the python script startup time.
    The file should contain lines of the format `<kind> <host> <user> <password>[ <timeout>]`
    (all without the `<>` brackets).
    After the timeout, a comment may be given, or a comment can be alternatively placed
    at the begging of a line, prefixed with a `# `; empty lines are ignored.

  Results are formatted as `<host>\t<temperature>` (`<>` brackets aren't part of the output,
  `\t` is replaced with an ASCII TAB character).



  If required, `--proxy <proxy_url>` can be added to the entry point command line
  to contact all API endpoints through the specified proxy.
  Note that this might require `pip3 install 'requests[socks]'` or
  on Gentoo `USE="socks5" emerge -v dev-python/requests` to work with SOCKS proxies.

  When using the python API, proxies can be specified in the `ApcKind.__init__(_, rqa)`
  `rqa` parameter (see Requests documentation, or the source code in `cli.py`)


pkgId: 4b5e5be19e67c119607de34cfb2eb6c04b9ef60848b9b8eafac99ec2373a41bc
name: python-APIException
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A customizable exception handling library for FastAPI
url: https://pypi.org/project/APIException/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-APIException-0.1.1-1.src.rpm
checksum_type: sha256
description:
  **APIException** is a customizable exception-handling library designed for Python and FastAPI applications, offering standardized error codes, messages, and HTTP status responses to improve error management and consistency across APIs.
  [**View on PyPI**](https://pypi.org/project/APIException/0.1.0/)



  To install APIException, run:

  ```bash
  pip install APIException
  ```


  - **Standardized Error Handling**: APIException allows you to define a consistent format for error responses, making your API more predictable and easier to work with.

  - **Customizable Error Codes and Messages**: Define custom error codes with specific messages and descriptions, making it easy to differentiate between various errors in your application.

  - **HTTP Status Integration**: Set HTTP status codes alongside error messages, ensuring that API clients receive appropriate responses for different types of errors (e.g., 400 for client errors, 500 for server errors).

  - **Automatic Logging**: Each exception raised includes automatic logging of details, such as the filename and line number, to help developers quickly locate issues.

  - **Extensible Error Codes**: Extend the `ExceptionCode` class to add custom error codes unique to your application’s needs.

  - **Compatibility with FastAPI**: APIException integrates seamlessly with FastAPI, allowing you to standardize error responses across your endpoints.

  - **Descriptive Responses**: Provides detailed descriptions for errors, making it easier for developers and users to understand the context of an error.

  - **Response Model Integration**: APIException includes a Pydantic `ResponseModel` for structuring successful responses, maintaining consistency across both success and error responses.





  Install the package via pip:

  ```bash
  pip install APIException
  ```

  The following example demonstrates how to use APIException in a FastAPI endpoint.

  ```python
  from fastapi import FastAPI, HTTPException
  from api_exception.exception import APIException
  from custom_enum.enums import ExceptionCode, ExceptionStatus
  from schemas.response_model import ResponseModel

  app = FastAPI()

  @app.get("/login")
  async def login(username: str, password: str):
      
      if username != "admin" or password != "admin":
          
          raise APIException(
              error_code=ExceptionCode.AUTH_LOGIN_FAILED,
              http_status_code=401
          )
      
      return ResponseModel(data={"username": username})
  ```

  You can customize the exception message, HTTP status code, and other details when raising an APIException.
  ```python
  @app.get("/custom-error")
  async def custom_error():
      
      raise APIException(
          error_code=ExceptionCode.AUTH_LOGIN_FAILED,
          message="Custom error message.",
          description="Detailed description of the custom error.",
          http_status_code=403,
          status=ExceptionStatus.WARNING
      )
  ```



  To define custom error codes for specific needs in your application, extend the ExceptionCode class:
  ```python
  from custom_enum.enums import BaseExceptionCode

  class CustomExceptionCode(BaseExceptionCode):
      USER_NOT_FOUND = ("USR-404", "User not found.", "The specified user does not exist in the system.")
      INVALID_API_KEY = ("API-401", "Invalid API key provided.", "Please provide a valid API key.")



  @app.get("/user/{user_id}")
  async def get_user(user_id: int):
      
      if user_id != 1:  # Assume only user with ID 1 exists
          raise APIException(
              error_code=CustomExceptionCode.USER_NOT_FOUND,
              http_status_code=404
          )
      return ResponseModel(data={"user_id": user_id, "name": "John Doe"})
  ```

  You can use ResponseModel for consistent structure in successful responses.
  ```python
  @app.get("/success")
  async def success():
      return ResponseModel(
          data={"message": "Operation was successful"},
          status=ExceptionStatus.SUCCESS,
          message="Success message",
      )
  ```



  Each APIException raised automatically logs the exception details, including the location where the exception was raised. This is useful for debugging and monitoring your application.


  To handle exceptions globally in FastAPI, you can use exception handlers.
  ```python
  from fastapi.responses import JSONResponse
  from fastapi import Request

  @app.exception_handler(APIException)
  async def api_exception_handler(request: Request, exc: APIException):
      return JSONResponse(
          status_code=exc.http_status_code,
          content=exc.to_response()
      )
  ```
  Now, any APIException raised in your application will be handled by this global exception handler, providing a consistent error format for all endpoints.


  You can test the library by writing unit tests. Here’s an example of how you might structure tests for the APIException library.
  ```python
  import unittest
  from api_exception.exception import APIException
  from custom_enum.enums import ExceptionCode, ExceptionStatus
  from schemas.response_model import ResponseModel

  class TestAPIException(unittest.TestCase):

      def test_api_exception(self):
          exception = APIException(error_code=ExceptionCode.AUTH_LOGIN_FAILED)
          self.assertEqual(exception.error_code, "AUTH-1000")
          self.assertEqual(exception.message, "Incorrect username and password.")
          self.assertEqual(exception.description, "Failed authentication attempt.")
          self.assertEqual(exception.status, ExceptionStatus.FAIL)
          self.assertEqual(exception.http_status_code, 400)

          
          response = exception.to_response()
          expected_response = {
              "error_code": "AUTH-1000",
              "status": "FAIL",
              "message": "Incorrect username and password.",
              "description": "Failed authentication attempt"
          }
          self.assertEqual(response, expected_response)

      def test_response_model(self):
          response = ResponseModel(data={"key": "value"})
          self.assertEqual(response.status, ExceptionStatus.SUCCESS)
          self.assertEqual(response.message, "Operation completed successfully.")
          self.assertIsNone(response.error_code)
          self.assertIsNone(response.description)
          self.assertEqual(response.data, {"key": "value"})

  if __name__ == "__main__":
      unittest.main()
  ```
  This test case verifies that the APIException class behaves as expected, including proper response formatting and attribute assignments.


  Contributions are welcome! Please feel free to submit a pull request or open an issue to improve this library. Follow the guidelines below:

  	1.	Fork the repository.
  	2.	Create a new branch.
  	3.	Make your changes and ensure all tests pass.
  	4.	Submit a pull request with a detailed description of the changes.



  If you’re looking for a way to manage exception handling in a structured manner, especially if you want the backend to control the error messages displayed to end-users, then APIException is a great library for you. It provides an organized and extensible approach to managing error codes, messages, and descriptions directly from the backend, enhancing the overall API response consistency and user experience.


  This project is licensed under the MIT License. See the [LICENSE](./LICENSE) file for more details.
  If you like this library and find it useful, don’t forget to give it a ⭐ on GitHub!


  If you have any questions or suggestions, please feel free to reach out at [ahmetkutayural.dev](https://ahmetkutayural.dev/#contact)


pkgId: 1138b4c5f9a1f3486a4823bbebaa5fe518196db21e385868007124ef12d69b45
name: python-APIFlask
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: A lightweight web API framework based on Flask and marshmallow-code projects.
url: https://pypi.org/project/APIFlask/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-APIFlask-2.2.1-1.src.rpm
checksum_type: sha256
description:
  ![](https://apiflask.com/_assets/apiflask-logo.png)



  [![Build status](https://github.com/apiflask/apiflask/actions/workflows/tests.yml/badge.svg)](https://github.com/apiflask/apiflask/actions) [![codecov](https://codecov.io/gh/apiflask/apiflask/branch/main/graph/badge.svg?token=2CFPCZ1DMY)](https://codecov.io/gh/apiflask/apiflask)

  APIFlask is a lightweight Python web API framework based on [Flask](https://github.com/pallets/flask) and [marshmallow-code](https://github.com/marshmallow-code) projects. It's easy to use, highly customizable, ORM/ODM-agnostic, and 100% compatible with the Flask ecosystem.

  With APIFlask, you will have:

  - More sugars for view function (`@app.input()`, `@app.output()`, `@app.get()`, `@app.post()` and more)
  - Automatic request validation and deserialization
  - Automatic response formatting and serialization
  - Automatic [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification) (OAS, formerly Swagger Specification) document generation
  - Automatic interactive API documentation
  - API authentication support (with [Flask-HTTPAuth](https://github.com/miguelgrinberg/flask-httpauth))
  - Automatic JSON response for HTTP errors




  - Python 3.8+
  - Flask 2.0+




  For Linux and macOS:

  ```bash
  $ pip3 install apiflask
  ```

  For Windows:

  ```bash
  > pip install apiflask
  ```




  - Website: <https://apiflask.com>
  - Documentation: <https://apiflask.com/docs>
  - PyPI Releases: <https://pypi.python.org/pypi/APIFlask>
  - Change Log: <https://apiflask.com/changelog>
  - Source Code: <https://github.com/apiflask/apiflask>
  - Issue Tracker: <https://github.com/apiflask/apiflask/issues>
  - Discussion: <https://github.com/apiflask/apiflask/discussions>
  - Twitter: <https://twitter.com/apiflask>
  - Open Collective: <https://opencollective.com/apiflask>




  If you find APIFlask useful, please consider [donating](https://opencollective.com/apiflask) today. Your donation keeps APIFlask maintained and evolving.

  Thank you to all our backers and sponsors!



  [![](https://opencollective.com/apiflask/backers.svg?width=890)](https://opencollective.com/apiflask)



  [![](https://opencollective.com/apiflask/sponsors.svg?width=890)](https://opencollective.com/apiflask)



  ```python
  from apiflask import APIFlask, Schema, abort
  from apiflask.fields import Integer, String
  from apiflask.validators import Length, OneOf

  app = APIFlask(__name__)

  pets = [
      {'id': 0, 'name': 'Kitty', 'category': 'cat'},
      {'id': 1, 'name': 'Coco', 'category': 'dog'}
  ]


  class PetIn(Schema):
      name = String(required=True, validate=Length(0, 10))
      category = String(required=True, validate=OneOf(['dog', 'cat']))


  class PetOut(Schema):
      id = Integer()
      name = String()
      category = String()


  @app.get('/')
  def say_hello():
      
      return {'message': 'Hello!'}


  @app.get('/pets/<int:pet_id>')
  @app.output(PetOut)
  def get_pet(pet_id):
      if pet_id > len(pets) - 1:
          abort(404)
      
      
      return pets[pet_id]


  @app.patch('/pets/<int:pet_id>')
  @app.input(PetIn(partial=True))  # -> json_data
  @app.output(PetOut)
  def update_pet(pet_id, json_data):
      
      
      if pet_id > len(pets) - 1:
          abort(404)
      for attr, value in json_data.items():
          pets[pet_id][attr] = value
      return pets[pet_id]
  ```

  <details>
  <summary>You can also use class-based views based on <code>MethodView</code></summary>

  ```python
  from apiflask import APIFlask, Schema, abort
  from apiflask.fields import Integer, String
  from apiflask.validators import Length, OneOf
  from flask.views import MethodView

  app = APIFlask(__name__)

  pets = [
      {'id': 0, 'name': 'Kitty', 'category': 'cat'},
      {'id': 1, 'name': 'Coco', 'category': 'dog'}
  ]


  class PetIn(Schema):
      name = String(required=True, validate=Length(0, 10))
      category = String(required=True, validate=OneOf(['dog', 'cat']))


  class PetOut(Schema):
      id = Integer()
      name = String()
      category = String()


  class Hello(MethodView):

      
      def get(self):
          return {'message': 'Hello!'}


  class Pet(MethodView):

      @app.output(PetOut)
      def get(self, pet_id):
          """Get a pet"""
          if pet_id > len(pets) - 1:
              abort(404)
          return pets[pet_id]

      @app.input(PetIn(partial=True))
      @app.output(PetOut)
      def patch(self, pet_id, json_data):
          """Update a pet"""
          if pet_id > len(pets) - 1:
              abort(404)
          for attr, value in json_data.items():
              pets[pet_id][attr] = value
          return pets[pet_id]


  app.add_url_rule('/', view_func=Hello.as_view('hello'))
  app.add_url_rule('/pets/<int:pet_id>', view_func=Pet.as_view('pet'))
  ```
  </details>

  <details>
  <summary>Or use <code>async def</code></summary>

  ```bash
  $ pip install -U "apiflask[async]"
  ```

  ```python
  import asyncio

  from apiflask import APIFlask

  app = APIFlask(__name__)


  @app.get('/')
  async def say_hello():
      await asyncio.sleep(1)
      return {'message': 'Hello!'}
  ```

  See <em><a href="https://flask.palletsprojects.com/async-await">Using async and await</a></em> for the details of the async support in Flask 2.0.

  </details>

  Save this as `app.py`, then run it with:

  ```bash
  $ flask run --reload
  ```

  Or run in debug mode:

  ```bash
  $ flask run --debug
  ```

  Now visit the interactive API documentation (Swagger UI) at <http://localhost:5000/docs>:

  ![](https://apiflask.com/_assets/swagger-ui.png)

  Or you can change the API documentation UI when creating the APIFlask instance with the `docs_ui` parameter:

  ```py
  app = APIFlask(__name__, docs_ui='redoc')
  ```

  Now <http://localhost:5000/docs> will render the API documentation with Redoc.

  Supported `docs_ui` values (UI libraries) include:

  - `swagger-ui` (default value): [Swagger UI](https://github.com/swagger-api/swagger-ui)
  - `redoc`: [Redoc](https://github.com/Redocly/redoc)
  - `elements`: [Elements](https://github.com/stoplightio/elements)
  - `rapidoc`: [RapiDoc](https://github.com/rapi-doc/RapiDoc)
  - `rapipdf`: [RapiPDF](https://github.com/mrin9/RapiPdf)

  The auto-generated OpenAPI spec file is available at <http://localhost:5000/openapi.json>. You can also get the spec with [the `flask spec` command](https://apiflask.com/openapi/#the-flask-spec-command):

  ```bash
  $ flask spec
  ```

  For some complete examples, see [/examples](https://github.com/apiflask/apiflask/tree/main/examples).




  APIFlask is a thin wrapper on top of Flask. You only need to remember the following differences (see *[Migrating from Flask](https://apiflask.com/migrations/flask/)* for more details):

  - When creating an application instance, use `APIFlask` instead of `Flask`.
  - When creating a blueprint instance, use `APIBlueprint` instead of `Blueprint`.
  - The `abort()` function from APIFlask (`apiflask.abort`) returns JSON error response.

  For a minimal Flask application:

  ```python
  from flask import Flask, request
  from markupsafe import escape

  app = Flask(__name__)

  @app.route('/')
  def hello():
      name = request.args.get('name', 'Human')
      return f'Hello, {escape(name)}'
  ```

  Now change to APIFlask:

  ```python
  from apiflask import APIFlask  # step one
  from flask import request
  from markupsafe import escape

  app = APIFlask(__name__)  # step two

  @app.route('/')
  def hello():
      name = request.args.get('name', 'Human')
      return f'Hello, {escape(name)}'
  ```

  In a word, to make Web API development in Flask more easily, APIFlask provides `APIFlask` and `APIBlueprint` to extend Flask's `Flask` and `Blueprint` objects and it also ships with some helpful utilities. Other than that, you are actually using Flask.




  APIFlask accepts marshmallow schema as data schema, uses webargs to validate the request data against the schema, and uses apispec to generate the OpenAPI representation from the schema.

  You can build marshmallow schemas just like before, but APIFlask also exposes some marshmallow APIs for convenience:

  - `apiflask.Schema`: The base marshmallow schema class.
  - `apiflask.fields`: The marshmallow fields, contain the fields from both marshmallow and Flask-Marshmallow. Beware that the aliases (`Url`, `Str`, `Int`, `Bool`, etc.) were removed.
  - `apiflask.validators`: The marshmallow validators.

  ```python
  from apiflask import Schema
  from apiflask.fields import Integer, String
  from apiflask.validators import Length, OneOf
  from marshmallow import pre_load, post_dump, ValidationError
  ```



  APIFlask starts as a fork of [APIFairy](https://github.com/miguelgrinberg/APIFairy) and is inspired by [flask-smorest](https://github.com/marshmallow-code/flask-smorest) and [FastAPI](https://github.com/tiangolo/fastapi) (see *[Comparison and Motivations](https://apiflask.com/comparison)* for the comparison between these projects).


pkgId: 57df1dfda16a72422dd42fb15a604ede883f11ea4fda2dcc280a6f017953f321
name: python-APIManager-DM-2024
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/movsdav/APIManager_DM_2024
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-APIManager-DM-2024-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Main class is *APIManager* which have two methods:

  - request_get(**endpoint** *[, headers]*)
  - request_post(**endpoint** *[, data, headers]*)


  ```python
  from api_manager import APIManager

  manager = APIManager("EXAMPLE_URL")

  response = manager.request_get("ENDPOINT") # returns request.Response object

  response_post = manager.request_post("ENDPOINT",
      data={"number":20},
      headers={
          "Content-Type" : "text/json"
  }) # returns request.Response object
  ```


pkgId: 760e8223721e8fd7111b06783d342d54a8ca3b41cfabf9453c230df60311e3b3
name: python-APISpec-fromfile
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: APISpec plugin to import OpenAPI specifications from a file instead of putting YAML into docstrings
url: https://github.com/ovh/python-apispec-fromfile
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-APISpec-fromfile-1.0.3-1.src.rpm
checksum_type: sha256
description:
  get:
    summary: Hello
    operationId: hello
    responses:
      200:
        content:
          application/json:
            schema:
              type: string
  ```
  Then, use APISpec in your Python code:
  ```python
  from apispec import APISpec
  from apispec_fromfile import FromFilePlugin
  from apispec_fromfile import from_file

  spec = APISpec(
      title="Swagger Petstore",
      version="1.0.0",
      openapi_version="3.0.3",
      plugins=[
          FromFilePlugin("resource"),
      ],
  )

  @from_file("my/spec/file.yml")
  def hello():
      return {"hello"}

  spec.path("/hello", resource=hello)
  ```

  * Contribute: https://github.com/ovh/python-apispec-fromfile/blob/master/CONTRIBUTING.md
  * Report bugs: https://github.com/ovh/python-apispec-fromfile/issues
  * Get latest version: https://pypi.org/project/apispec-fromfile

  Copyright 2020 OVH SAS
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
      http://www.apache.org/licenses/LICENSE-2.0
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.


pkgId: 2ed8e7ff72d0b90e9374c932c67d6c6dcb7ebecc6fb5d22d85f5110a36003c62
name: python-APLpy
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: The Astronomical Plotting Library in Python
url: http://aplpy.github.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-APLpy-2.2.0-1.src.rpm
checksum_type: sha256
description:
  APLpy (the Astronomical Plotting Library in Python) is a Python module
  aimed at producing publication-quality plots of astronomical imaging
  data in FITS format.
  PyPI: https://pypi.python.org/pypi/APLpy
  Website: http://aplpy.github.io
  Documentation: http://aplpy.readthedocs.io
  APLpy is released under an MIT open-source license.


pkgId: 44d1070127abb6eff147e254ef4b09e6c67bde1b0b1e12fbfed9ee4435a58106
name: python-APacheDEX
arch: src
version: 2.1
epoch: 0
release: 1
summary: Compute APDEX from Apache-style logs.
url: https://lab.nexedi.com/nexedi/apachedex.git
rpm_license: GPL 2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-APacheDEX-2.1-1.src.rpm
checksum_type: sha256
description:
  Parses Apache-style logs and generates several statistics intended for a
  website developer audience:
  - APDEX (Application Performance inDEX, see http://www.apdex.org) ratio
    (plotted)
    Because you want to know how satisfied your users are.
  - hit count (plotted)
    Because achieving 100% APDEX is easy when there is nobody around.
  - HTTP status codes, with optional detailed output of the most frequent URLs
    per error status code, along with their most frequent referers
    Because your forgot to update a link to that conditionally-used browser
    compatibility javascript you renamed.
  - Hottest pages (pages which use rendering time the most)
    Because you want to know where to invest time to get highest user experience
    improvement.
  - ERP5 sites: per-module statistics, with module and document views separated
    Because module and document types are not born equal in usage patterns.
  Some parsing performance figures:
  On a 2.3Ghz Corei5, apachedex achieves 97000 lines/s (
  pypy-c-jit-62994-bd32583a3f11-linux64) and 43000 lines/s (CPython 2.7).
  Those were measures on a 3000000-hits logfile, with 3 --skip-base, 1
  --erp5-base, 3 --base and --default set. --\*base values were similar in
  simplicity to the ones provided in examples below.


pkgId: 8d18b6c0fe7b6680a22cab496a2e49f592bd618c7945e53d3126ab10a3f24c20
name: python-ARCtrl
arch: src
version: 2.2.3
epoch: 0
release: 1
url: https://github.com/nfdi4plants/ARCtrl
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ARCtrl-2.2.3-1.src.rpm
checksum_type: sha256
summary:
  Library for management of Annotated Research Contexts (ARCs) using an in-memory representation and runtimer agnostic contract systems.

description:
  > **ARCtrl** the easy way to read, manipulate and write ARCs in __.NET__, __JavaScript__ and __Python__! ❤️

  | Version | Downloads |
  | :--------|-----------:|
  |<a href="https://www.nuget.org/packages/ARCtrl/"><img alt="Nuget" src="https://img.shields.io/nuget/v/ARCtrl?logo=nuget&color=%234fb3d9"></a>|<a href="https://www.nuget.org/packages/ARCtrl/"><img alt="Nuget" src="https://img.shields.io/nuget/dt/ARCtrl?color=%234FB3D9"></a>|
  |<a href="https://www.npmjs.com/package/@nfdi4plants/arctrl"><img alt="NPM" src="https://img.shields.io/npm/v/%40nfdi4plants/arctrl?logo=npm&color=%234fb3d9"></a>|<a href="https://www.npmjs.com/package/@nfdi4plants/arctrl"><img alt="NPM" src="https://img.shields.io/npm/dt/%40nfdi4plants%2Farctrl?color=%234fb3d9"></a>|
  |<a href="https://pypi.org/project/ARCtrl/"><img alt="PyPI" src="https://img.shields.io/pypi/v/arctrl?logo=pypi&color=%234fb3d9"></a>|<a href="https://pypi.org/project/ARCtrl/"><img alt="PyPI" src="https://img.shields.io/pepy/dt/arctrl?color=%234fb3d9"></a>|





  ```fsharp

  ```

  ```bash
  <PackageReference Include="ARCtrl" Version="1.1.0" />
  ```



  ```bash
  npm i @nfdi4plants/arctrl
  ```



  ```bash
  pip install arctrl
  ```



  Currently we provide some documentation in form of markdown files in the `/docs` folder of this repository!

  [Check it out!](/docs)





  - [nodejs and npm](https://nodejs.org/en/download)
      - verify with `node --version` (Tested with v18.16.1)
      - verify with `npm --version` (Tested with v9.2.0)
  - [.NET SDK](https://dotnet.microsoft.com/en-us/download)
      - verify with `dotnet --version` (Tested with 7.0.306)
  - [Python](https://www.python.org/downloads/)
      - verify with `py --version` (Tested with 3.12.2, known to work only for >=3.11)



  On windows you can use the `setup.cmd` to run the following steps automatically!

  1. Setup dotnet tools

     `dotnet tool restore`


  2. Install NPM dependencies

      `npm install`

  3. Setup python environment

      `py -m venv .venv`

  4. Install [Poetry](https://python-poetry.org/) and dependencies

     1. `.\.venv\Scripts\python.exe -m pip install -U pip setuptools`
     2. `.\.venv\Scripts\python.exe -m pip install poetry`
     3. `.\.venv\Scripts\python.exe -m poetry install --no-root`

  Verify correct setup with `./build.cmd runtests` ✨



  Measured on 13th Gen Intel(R) Core(TM) i7-13800H

  | Name | Description | FSharp Time (ms) | JavaScript Time (ms) | Python Time (ms) |
  | --- | --- | --- | --- | --- |
  | Table_GetHashCode | From a table with 1 column and 10000 rows, retrieve the Hash Code |  5 | 21 | 226 |
  | Table_AddRows | Add 10000 rows to a table with 4 columns. |  15 | 22 | 289 |
  | Table_fillMissingCells | For a table 6 columns and 20000 rows, where each row has one missing value, fill those values with default values. | 49 | 108 | 4813 |
  | Table_ToJson | Serialize a table with 5 columns and 10000 rows to json. |  1099 | 481 | 6833 |
  | Table_ToCompressedJson | Serialize a table with 5 columns and 10000 rows to compressed json. |  261 |  2266 | 717334 |
  | Assay_toJson | Parse an assay with one table with 10000 rows and 6 columns to json |  915 | 2459 | 28799 |
  | Study_FromWorkbook | Parse a workbook with one study with 10000 rows and 6 columns to an ArcStudy |  97 | 87 | 1249 |
  | Investigation_ToWorkbook_ManyStudies | Parse an investigation with 1500 studies to a workbook |  621 | 379 | 9974 |


pkgId: 42527e6cad9c9e71d910de132bbbaad0684634897257b7c21aa8eb27740b66cb
name: python-ARPOC
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: An Authentication Reverse Proxy using OpenID Connect
url: https://pypi.org/project/ARPOC/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ARPOC-0.3.1-1.src.rpm
checksum_type: sha256
description:
  A simple reverse proxy that adds OpenID Connect Authentication and lets you
  write access rules for services you want to protect.



  You will need:

  * A domain name `<domain>`
  * A tls keypair (`<fullchain>`, `<privkey>`)
  * A server with python (3.7 or newer) `<python3>`



  * Download the repository and run `<python3> setup.py install`, or install via pip: `pip install arpoc`
  * If successful you should now have the `arpoc` command.
  * Make yourself familiar with the basic interface with `arpoc --help`.
  * Create a configuration file `arpoc --print-sample-config`
  * Save the configuration file (preferable under /etc/arpoc/config.yml)
  * Create a default access control hierarchy using `arpoc --print-sample-config`
  * Save the access control hierarchy in a json file (defaultdir: /etc/arpoc/acl/)



  Fill in the right values for `<keyfile>`, `<certfile>`, `<domainname>`, `<redirect>`
  urls (path the openid connect providers will redirect the user to, with a leading
  slash) and the contacts field (at least on valid mail adress).




  You need the configuration url (should end with .well-known/openid/configuration, cut this part of, it is added automatically).
  You also need either:

  * A configuration token
  * A registration url and a registration token
  * Client ID and Client Secret




  Choose a key which arpoc uses internally for the provider.

  Add both parameters to the config.yml under
  `openid_providers -> <key> -> configuration_url`
  `openid_providers -> <key> -> configuration_token`



  If you already registered your client and have a registration token add
  the configuration url, the registration url and the registration token
  under to the config.yml file under
  `openid_providers -> <key>` using the `configuration_url`, `registration_url`
  and `registration_token`.



  Add the configuration url to the config.yml.
  Call `arpoc --add-provider <key> --client-id <client_id> --client-secret <client-secret>`




  You need the origin url, the proxy url and the key of an access control policy
  set (the key of an ac entity in the json file with type policy set).

  Choose a key which arpoc will internally use for the service.
  Add the origin url and the proxy url (the path under which the service will be
  available with a leading slash) using the `origin_URL` and `proxy_url` keys
  under `services -> <service key> -> ` to the config.yml

  *Now you should be able to access the service.*




  * [pyjwkest](https://github.com/IdentityPython/pyjwkest/) -- a python library for web tokens
  * [lark-parser](https://github.com/lark-parser/lark) -- a parser for the access control language
  * [pyoidc](https://github.com/OpenIDC/pyoidc) -- a python library for Open ID Connect
  * ...


pkgId: a342498f611671507c45e0e334661862637fc7a27bb6924d2c566c41619adfe6
name: python-ARTOF
arch: src
version: 0.0.1
epoch: 0
release: 1
url: https://codebase.helmholtz.cloud/carl.meier/artof
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ARTOF-0.0.1-1.src.rpm
checksum_type: sha256
summary:
  The ARTOF is a tool to read, process and analyze data collected from angle resolved time of flight (ARToF) sensors of the PS-ISRR.

description:
  The ARToFLoader is a tool to read, process and analyze data collected from angle resolved time of flight (ARToF) sensors of the PS-ISRR.


pkgId: 60a765cf08f4b9e0f420d60baf6331bab398c4e3896d0b30a58ae1ee35eff7fb
name: python-AS-Object-models
arch: src
version: 2.3.9
epoch: 0
release: 1
url: https://gitlab.com/AnalyticsSupply/as-object-models
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AS-Object-models-2.3.9-1.src.rpm
checksum_type: sha256
summary:
  A Project that captures all of the data manipulation used in apps developed by Analytics Supply LLC.

description:
  Creating this project as a way to make the firestore client code pip installable in other projects


pkgId: 6d078f2b80766507d9855c1bc3c26231de3db7b4d2ba3e7e44f2014b8feba19b
name: python-ASBPredictor
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A Python package for predicting ASB risk from clinical data.
url: https://github.com/yangfangs/ASBPredictor
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ASBPredictor-0.1.0-1.src.rpm
checksum_type: sha256
description:
  - **Fast Prediction**: Supports batch input data and generates ASB risk predictions.
  - **Easy to Use**: Command-line interface for straightforward operation.
  - **Flexible Input**: Supports multi-row CSV input files, with results saved to a new file with predicted probabilities.


pkgId: 059d1458eee74cb0200d74ec51f880eef1b8cabf9de5e40d91f0f29c5f7a6fb0
name: python-ASCIIcli
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A command-line tool that converts images to ASCII art.
url: https://github.com/mrq-andras/asciicli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ASCIIcli-0.1.1-1.src.rpm
checksum_type: sha256
description:
     35005550    22           666     666             165         
    002          77    003    555     555             350         
   056                155677  555     555             3554 337    
   053   89889   00   4559    55555555555  006   400  3557   008  
   059     300   00    051    555     555  059   700  350    850  
   3007    700   00    053    555     555  059   400  350    950  


pkgId: f848090d8efd5e8d9ad7552d827b1cb96e5a93053b091f9d76e24742da8666a2
name: python-ASMRManager
arch: src
version: 2.2.9
epoch: 0
release: 1
summary: download, manage and play the voices on asmr.one
url: https://pypi.org/project/ASMRManager/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ASMRManager-2.2.9-1.src.rpm
checksum_type: sha256
description:
  之后再运行 `asmr` 命令，会生成示例的配置文件和 sql 文件，此处以 windows 举例：
  ```
  2023-10-22 14:36:21 - INFO - First time to run, copy default sqls to C:\Users\slqy\AppData\Local\asmrmanager\asmrmanager\sqls
  2023-10-22 14:36:21 - INFO - An example config file has been copied to C:\Users\slqy\AppData\Local\asmrmanager\asmrmanager\config.toml, please modify it and run this command again
  ```
  之后按照说明修改 `config.toml` 文件，如果使用 sql 的话，也可以对 sql 文件夹进行修改。
  若有不明白的地方可使用 sqlite 数据库工具查看目录下的 data.db 文件。
  完成后使用 `asmr -h` 查看各命令的使用说明，对于子命令不清楚的同样可以查看帮助，例如 `asmr dl -h`。
  常用的命令有：
  - `dl search` 搜索并下载。
  - `info` 搜索某个 RJID 的具体信息
  - `file check` 检查下载目录下的文件是否按照规则被正确下载
  - `file store` 将下载文件转移到存储目录(STORAGE_PATH)，并执行相应文件格式转换(详情见config.toml的before_store字段)
  - `view` 将选择文件并移动到 VIEW_PATH
  - `pl add` 将某个音声添加到用户的云端播放列表(配合 `pl create` 使用)
  - `review` 为某个作品评分并评论(本地)
  更多使用示例可参考[这一小节](#使用示例)。
  > 使用命令时，如果不输入 RJID ，将会自动使用上一次命令的RJID。
  另外本工具提供基于 `trogon` 的可视化命令行界面，在安装`tui`依赖后使用 `asmr tui` 即可打开。

  仅适用于Linux，详情可参考[官方文档](https://click.palletsprojects.com/en/8.1.x/shell-completion)。
  ```shell

  _ASMR_COMPLETE=fish_source asmr > ~/.config/fish/completions/asmr.fish

  _ASMR_COMPLETE=bash_source asmr > ~/.asmr-complete.bash
  echo '. ~/.asmr-complete.bash' >> ~/.bashrc

  _ASMR_COMPLETE=zsh_source asmr > ~/.asmr-complete.zsh
  echo '. ~/.asmr-complete.zsh' >> ~/.zshrc
  ```

  搜索最近更新的40个(一页)作品并下载：
  ```shell
  asmr dl search -o release --desc  # 选择并下载
  asmr dl search -o release --desc --all  # 下载全部
  ```
  下载`治愈`标签下销量大于等于5000的全部的作品：
  ```shell
  asmr dl search --tags 治愈 --sell 5000: --page 0 --all  # --page 0 会遍历下载所有页，否则默认只会下载第一页
  ```
  下载某个社团下的全年龄并包含中文字幕的作品：
  ```shell
  asmr dl search --circle Yostar --age general --subtitle
  ```
  根据RJ/VJ/BJ号下载（下述输入格式适用于一切需要输入单个或多个ID的场合）：
  ```shell
  asmr dl get RJ299717
  asmr dl get 299717  # RJ可以省略；对于8位RJ号，第一位的0也可以省略
  asmr dl get VJ015443
  asmr dl get 100000029  # 对于BJ与VJ，网站为了兼容RJ所使用的特殊ID
  asmr dl get 300015443  # 本项目存储VJ与BJ所使用的ID（"3" + 8位VJ号，BJ则为"4" + 8位BJ号）
  ```
  检查下载目录下文件是否下载完全（只验证文件存在，不保证文件完整性）
  ```shell
  asmr file check
  asmr file check --list | xargs asmr dl get --force   # 重新下载所有不完整的文件，以linux shell为例
  ```
  将下载的文件转移到存储目录(STORAGE_PATH)，并执行相应文件格式转换(详情见config.toml的before_store字段)
  ```shell
  asmr file store --all
  ```
  比较本地文件与服务器文件的差异：
  ![diff](./assets/diff.png)
  简单的关键词搜索（本地数据库）：
  ```shell
  asmr query 治愈 --limit 3  # 搜索字段有：标题，社团名和标签名
  asmr query 治愈 --limit 3 --raw | jq .[].id | xargs -n1 asmr info # 输出为json格式，获取详细信息
  ```

  命令执行过程中会进行如下的检查与过滤操作：
  1. 开始下载前：检查RJ号是否应该下载，如果本地文件不存在或者数据库无记录都会执行下载操作。可以通过 `--force` 强制执行下载。
  1. 获取音声信息后：检查音声的tags，如果包含tag_filters里指定的tag，则跳过下载。可以通过 `--ignore-tag` 来强制下载。
  1. 获取下载文件后：检查文件的名称和路径，如果不符合filename_filters里指定的规则，则跳过下载。可以通过`--ignore-name`来强制下载。
  1. 添加下载任务时：如果检测到本地有同名文件，则跳过该文件的下载。可以通过`--replace`来强制覆盖存在的文件。

  感谢 <https://asmr.one>丰富了我的夜生活。
  另外网站运营不易，请合理使用本工具。


pkgId: 92000bce70ae75af55c12b5d592726569af5a31c5eaa7687a5a93e824e586c48
name: python-ASTAligner
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://github.com/csci-435-fall-2024/csci-435-24_p4_ast
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ASTAligner-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  ASTAligner is designed to align tokens from source code snippets to Abstract Syntax Tree (AST) nodes using Tree-sitter for AST generation and various HuggingFace tokenizers for language tokenization. The library supports a wide range of programming languages and Fast tokenizers, enabling precise mapping between source code elements and their AST representations.

description:
  Aligns the tokens from a code snippet to their corresponding nodes in an AST representation.



  A Large Language Model (LLM) is a type of AI model designed to understand
  and generate human-like text based on vast amounts of data. Trained on diverse source code datasets, LLMs can automate Software Engineering tasks across various contexts, such as code translation, code summarization, test-case generation, and code completion. A critical component of LLMs is the tokenizer, which breaks down text into smaller units, typically words or subwords, that the model can process. The tokenizer's role is essential because it converts source code into a format the model can understand, ensuring efficient and accurate code processing and generation. In the context of Interpretability for AI, post-hoc techniques such as ASTScore, rely on alienation functions (phi) to match the tokens generated by an LLMâ€™s tokenizer with their corresponding nodes in the AST representation of a snippet.



  This project has two goals:

  (1) Create a library for aligning the tokens from a code snippet to their corresponding nodes in the AST representation

  (2) Create a tool to visualize the alignment of the tokens with their matching AST.



  For more information regarding this project's background and dependencies, please refer to these readings:

  (1) [Evaluating and Explaining Large Language Models for Code Using
  Syntactic Structures](https://arxiv.org/abs/2308.03873)

  (2) [Tree-Sitter Programming Language Parser](https://github.com/tree-sitter/tree-sitter)

  (3) [Hugging Face Tokenizer](https://huggingface.co/learn/nlp-course/en/chapter2/4)



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install all backend dependencies needed for the AST-Alignment Tool. All required packages for the backend can be downloaded using requirements.txt, which can found in the base repository.

  ```bash
  pip install -r /path/to/requirements.txt
  ```



  * 11 supported languages
      * Python
      * C
      * C++
      * C#
      * Java
      * JavaScript
      * Ruby
      * HTML
      * GO
      * Kotlin
      * Rust
  * 6 Tokenizers
      * [Bert-Base-Uncased](https://huggingface.co/google-bert/bert-base-uncased)
      * [CodeLlama](https://huggingface.co/docs/transformers/main/en/model_doc/code_llama)
      * [GPT2](https://huggingface.co/docs/transformers/en/model_doc/gpt2)
      * [DialoGPT](https://huggingface.co/microsoft/DialoGPT-small)
      * [Roberta-Base](https://huggingface.co/FacebookAI/roberta-base)
      * [Qwen](https://huggingface.co/Qwen/Qwen2-7B-Instruct)




  Using the ASTalign method asks that the user provide:
  * A snippet of `code` as a string, or a filepath to a text file containing code.
  * The `language` of the code snippet as one of the following strings:
      * python
      * c
      * cpp
      * csharp
      * java
      * javascript
      * ruby
      * html
      * go
      * kotlin
      * rust
      * haskell
  * A `tokenizer` specification as one of the following strings:
      * codellama
      * gpt2
      * bert-base-uncased
      * roberta-base
      * dialogpt
      * qwen
  * (Optional) `include_whitespace_and_special_tokens` flag. Set to False by default, this flag allows the user to specify whether or not to show whitespaces and special characters in the tokens.

  The method returns a dictionary of TSTree nodes to a list of tokens from the code snippet that overlap with those nodes. Example usage:

  `alignments[node]` yields `[tok1, tok2, ... , tokn]`






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


pkgId: 6cfccd4a17b04eaf00a4520ad7efeab62c4f8c9bdc5e829c7ba7be97e0339d7e
name: python-ASUllmAPI
arch: src
version: 2.0.7
epoch: 0
release: 1
summary: A simple python package to facilitate connection to ASU LLM API
url: https://github.com/ASU/aiml-ssmdv-student-support-ml-data-visualization
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ASUllmAPI-2.0.7-1.src.rpm
checksum_type: sha256
description:
  This package allows individuals at Arizona State University to access ASU GPT through API. You will need API access token, API endpoints in order to use this package.


  Install via pip in a virtual environment or Conda.
  ```markdown
  pip install ASUllmAPI
  ```

  Note: Depending on your Python distribution, you may need to pip or conda
  install `requests` and `tqdm` if it is not available in your local environment.
  ```markdown
  pip install requests
  pip install tqdm
  ```

  See README.md documentation at this [link](https://github.com/ASU/aiml-ssmdv-student-support-ml-data-visualization/blob/main/base-ASUllm-documentation/README.md).


pkgId: 7bf739b9894905523249244c3e4fdf2efbe1c1f73fce75b2b6c9c95729b80994
name: python-ATACFragQC
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: Fragment Quality Control for ATAC-seq
url: https://github.com/0CBH0/ATACFragQC
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ATACFragQC-0.4.7-1.src.rpm
checksum_type: sha256
description:
  The Python toolkits designed to control the fragment quality of Bulk/SingCell ATAC-seq.


  ~~~
  python3 -m pip install --upgrade ATACFragQC
  ~~~


  ~~~

  ATACFragQC [options] -i <input.bam> -r <reference.gtf>


  ATACFragQC -h
  ~~~


  * The distrubution of fragments in chromosomes
  * The distrubution of fragment lengths
  * The distrubution of fragments around transcription start sites (TSSs)
  * Other feature would be supported in the future ...


  ![Overview of ATACFragQC](https://raw.githubusercontent.com/0CBH0/ATACFragQC/main/Images/MCBULK_qc.png)


pkgId: 6ac043181b2e9a27430b551199278e9dd7b17eca1f5b17b23fa93b1a7e17df21
name: python-ATCForm
arch: src
version: 0.1.9.1
epoch: 0
release: 1
summary: ATCFrom - Automatically fill in the collection form 自动化表单填写工具
url: https://github.com/YKONGCO/ATCForm
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ATCForm-0.1.9.1-1.src.rpm
checksum_type: sha256
description:
  ATCForm is a tool that automatically fills in the collection form.
  supported: jin data ,tx data

  ![](https://img.shields.io/github/release/YKONGCO/ATCForm)

  ```
  {
          "学号姓名":"",
          "学号":"",
          "姓名":"",
          "手机号":"",
          "手机":"",
          "电话":"",
          "QQ":"",
          "邮箱":"",
          "微信":"",
          "专业":"",
          "班级":"",
          "年级":"",
          "学院":"",
          "name":"value"
  }

  ```




  * class
  ```
  AuTotask_xxx : Autotask任务类
          inint() : 初始化
          run() : 运行
          start() : 开始 init()+run()



  ATThreadPool : 线程池
          run() : 运行
  ```

  * function
  ```
  download_driver
  ```



  jsj
  ```
  选项A #直接输选项名
  select_LIST=["选项A","选项B"]
  ```

  tx
  ```
  选项A 选项B #多选 请严格按照题目顺序填写
  选项C #单选
  select_LIST=[["选项A","选项B"],["选项C"]]
  ```



  对于 腾 收集表表单进行了进一步优化,修复了简介造成的bug


  对于 腾 收集表表单优化了多线程 任务,优化




  优化了多线程任务，提供了方便的使用方法，优化源代码结构


pkgId: 5bf5af2c8cb093fa515bedd0bc516f23c2e67d204c511d9df12671093a0515ee
name: python-ATEM
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Adaptive Task Execution Manager for robotics, integrating AI and pathfinding.
url: https://github.com/yourusername/ATEM
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ATEM-1.0.1-1.src.rpm
checksum_type: sha256
description:
  **ATEM** (Adaptive Task Execution Model) is a machine learning-based project designed to determine the optimal sequence of tasks to maximize points in the autonomous phase of FTC robotics competitions. The project utilizes TensorFlow and TensorFlow Lite for efficient model deployment.

  - **Model Training**:
    - Train a TensorFlow model to optimize task sequences for maximum points.
    - Tasks and their respective points are dynamically loaded from a JSON file.
    - Outputs a TensorFlow Lite model for lightweight deployment.
  - **Model Interpretation**:
    - Given a list of tasks, predicts the optimal sequence and total points.


pkgId: 50500f6a584cfec1ec017e8f04ac17d25e6f16337c6ff83d585165264331f3de
name: python-ATL-Tools
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: AI-Tianlong的Tools打包，开箱即用, 包含ATL_path和ATL_gdal,可用于文件夹创建、文件搜索、遥感图像处理
url: https://pypi.org/project/ATL-Tools/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ATL-Tools-1.2.5-1.src.rpm
checksum_type: sha256
description:
  最新版本 v1.2.5

  ATL_Tools 是一个由 [AI-Tianlong【GitHub】](https://github.com/AI-Tianlong)开发的工具集合，包含一些便利的小工具。
  如果您有新的模块添加，或者对现有模块有改进意见，欢迎提交 PR 至  [ATL_Tools_pypi 【GitHub Repo】](https://github.com/AI-Tianlong/ATL_Tools_pypi).

  加载方式:

  ```python
  from ATL_Tools import mkdir_or_exist, find_data_list
  ```


  加载方式:
  ```python
  from ATL_Tools.ATL_gdal import (
      read_img_to_array_with_info, # ✔读取影像为数组并返回信息
      read_img_to_array,  # ✔读取影像为数组
      save_ds_to_tif,     # ✔将GDAL dataset数据格式写入tif保存
      save_array_to_tif,  # 将数组格式写入tif保存
      read_img_get_geo,   # ✔计算影像角点的地理坐标或投影坐标
      ds_get_img_geo,     # 读取dataset格式，计算影像角点的地理坐标或投影坐标
      pix_to_geo,         # 计算影像某一像素点的地理坐标或投影坐标
      geo_to_pix,         # 根据GDAL的仿射变换参数模型将给定的投影或地理坐标转为影像图上坐标（行列号）
      Mosaic_all_imgs,    # ✔将指定路径文件夹下的tif影像全部镶嵌到一张影像上
      Mosaic_2img_to_one, # 将两幅影像镶嵌至同一幅影像
      raster_overlap,     # 两个栅格数据集取重叠区或求交集（仅测试方形影像）
      crop_tif_with_json_zero, # ✔将带有坐标的图像按照json矢量进行裁切,无数据区域为0
      crop_tif_with_json_nan,  # ✔将带有坐标的图像按照json矢量进行裁切,无数据区域为nan
      Merge_multi_json,   # ✔将多个小的json合并为一个大的json,
      resample_image,     # ✔使用GDAL对图像进行重采样
      shp_to_geojson,     # ✔将shp文件转为geojson文件
      clip_big_image,     # 将大图裁切为小图，支持重叠
                          )
  ```




  使用程序示例:
  1. 创建文件夹
      ```python
      from ATL_Tools import mkdir_or_exist, find_data_list
      
      mkdir_or_exist('新文件夹名称')
      
      ```
  2. 获取文件夹内所有后缀为 `.jpg` 的文件绝对路径
      ```python
      img_lists = find_data_list(img_root_path='数据集文件夹路径', suffix ='.jpg')
      ```

  使用程序示例：
  1. 根据矢量批量裁切影像
      ```python
      from ATL_Tools import mkdir_or_exist, find_data_list
      from ATL_Tools.ATL_gdal import crop_tif_with_json_nan
      from tqdm import tqdm
      import os

      img_path_all = '../推理出的结果_24类_RGB/'
      output_path_all = '../推理出的结果_24类_RGB_crop'
      json_path_all = '../要推理的json/'
      mkdir_or_exist(output_path_all)
      img_list = find_data_list(img_path_all, suffix='.tif')


      for img_path in tqdm(img_list, colour='Green'):

          img_output_path = os.path.join(output_path_all, os.path.basename(img_path))
          json_path = os.path.join(json_path_all, os.path.basename(img_path).split('_')[-1].replace('.tif', '.json'))
          print(f'正在裁切: {img_output_path},json: {json_path}')
          crop_tif_with_json_nan(img_path, img_output_path, json_path)
      ```


  - 2023-12-06  v1.0.2  修复 README 中显示问题。
  - 2023-12-06  v1.0.3  修改项目名称为 ATL_Tools。
  - 2024-04-03  v1.0.6  增加 `ATL_gdal` 模块，用于处理遥感影像。
  - 2024-04-09  v1.0.7  修复 `ATL_gdal` 模块中对于 `ATL_path` 的引用，`__init__.py` 注释掉`from ATL_gdal import *`, 可不安装 gdal 使用 ATL_Tools
  - 2024-04-16  v1.0.8  修复 `ValueError: cannot convert float NaN to integer` in ATL_gdal Line 371
  - 2024-04-16  v1.0.9  修复 `Mosaic_all_images()`对于 mosaic RGB uint8 标签的支持，优化`find_data_list()`函数显示，优化`_init_.py`, 优化`Readme.md`显示
  - 2024-04-16  v1.1.0  pypi 页面增加`ATL_Tools` Github 贡献地址。
  - 2024-04-16  v1.1.1  `crop_tif_with_json_nan()`增加可选参数`add_alpha_chan: bool`控制是否为 RGB 标签增加 alpha 通道
  - 2024-04-16  v1.1.2  修复 ATL_gdal Line 397 变量使用错误
  - 2024-04-18  v1.1.3  修复 ATL_gdal Mosaic 中对 float32 图像背景设置为 nan 的支持
  - 2024-04-24  v1.1.4  修复 ATL_gdal Mosaic 中指定 img_list 功能的支持，可以指定 Mosaic 的图像，增加`shp`转换为`Geojson`的功能函数`shp_to_geojson()`
  - 2024-05-06  v1.1.5  修复 ATL_gdal 中 `Mosaic_all_imgs()`函数在某些情况下，可能导致计算出的合并后的大图尺寸要比嵌入的小图位置要小几个像素，在 line 340 代码中，给图像的高宽各 +50 像素，暂时避免了这个问题。
  - 2024-05-20  v1.1.6  ATL_gdal 中 增加 `cut_image_with_overlap()`支持将大图裁切成指定尺寸的小图，并带有坐标。
  - 2024-05-28  v1.1.7  ATL_gdal 中 修改 v1.1.6 中新增函数 为`clip_big_image()`。ATL_gdal 中`crop_tif_with_json_zero()`和`crop_tif_with_json_nan()`支持传入参数 `img_path(str)` 或 `img_path(gdal.Dataset)`。
  - 2024-06-17  v1.1.9  ATL_gdal 中修复 `crop_tif_with_json_zero()`和`crop_tif_with_json_nan()` 对于传入`img_path(gdal.Dataset)`而导致错误的路径打印。
  - 2024-06-26  v1.2.0  ATL_gdal 中 `resample_image()`增加`new_rows`和`new_cols`可选参数，可以scater_factor缩放因子或指定高宽进行重采样。增加`resampleAlg`可选参数，支持通过`gdal`的重采样算法进行重采样。
  - 2024-06-26  v1.2.1  ATL_gdal 中修复`resample_image()`功能中，`new_rows`,`new_cols`,`scale_facotr`为`None`
  - 2024-07-24  v1.2.2  ATL_gdal 中`crop_tif_with_json_zero()`增加`nodata_value`参数，支持指定输出中无效数据的值，可在标签包含0时，指定无数据值为255。
  - 2024-08-07  v1.2.3  ATL_path 中增加`setup_logger()`函数，用于设置日志输出格式。
  - 2024-08-07  v1.2.4  ATL_path 中`setup_logger()`函数，添加`show_file_path (bool)` 用于控制是否在 log 中打印 输出log信息的文件位置，Defaults to False。
  - 2024-08-27  v1.2.5  ATL_gdal 中`save_array_to_tif`函数，增加判断，以支持对单通道灰度图的支持。


  ```bash
  python -m build
  ```
  ```bash
  twine upload dist/*
  ```


pkgId: 7071dd15718c756e92720565a82def7082332fc82436562f20ae96a1bff2b13f
name: python-ATPLibrary
arch: src
version: 0.2.0rc8
epoch: 0
release: 1
summary: Robotframework ATP Library
url: https://sqsglobal.visualstudio.com/ATP/_git/ATP.RobotFramework
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ATPLibrary-0.2.0rc8-1.src.rpm
checksum_type: sha256
description:
  Version: 0.2.0-rc.8

  Expleo ATP (Automation Test Proxy) Robot Framework library used to execute remote test commands (click, keyword) on low level agents, that are running the ATP server component.

  ATPLibrary supports standard and relay mode, to utilize either a Sikuli instance on the agent, or in cases where Sikuli cannot be installed, then relay click by image to a relay instance of Sikuli.

  [Git Project repo can be found here](https://sqsglobal.visualstudio.com/ATP/_git/ATP.RobotFramework)


pkgId: 896909de3123928aba3e151c9b11df2d4b6a5e8f2f97fc6dd61a39d29fb83c01
name: python-AWSScout2
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: Scout2, TODO
url: https://github.com/nccgroup/Scout2
rpm_license: GNU General Public License v2 (GPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AWSScout2-3.2.1-1.src.rpm
checksum_type: sha256
description:
  Scout2 is a multi-threaded tool that fetches and stores your AWS account's configuration settings in memory during
  runtime. It is expected that the tool will run with no issues on any modern laptop or equivalent VM.
  **Running Scout2 in a VM with limited computing resources such as a t2.micro instance is not intended and will likely
  result in the process being killed.**


pkgId: 0ce57cfcc90ec43df5bbd93d8f151f902508e1e28e14a3233ea0996621bf8bbf
name: python-AYABInterface
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: A Python library with the interface to the AYAB shield.
url: https://github.com/fossasia/AYABInterface
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AYABInterface-0.0.9-1.src.rpm
checksum_type: sha256
description:
  A Python library with the interface to the AYAB shield.
  For installation instructions and more, `see the documentation
  <http://AYABInterface.readthedocs.io/>`__.


pkgId: ffac400bc012962894f3dc4db76c9620109d0ea0654585817c8413477fd031b0
name: python-AaioAsync
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Fully async python wrapper for Aaio.io API
url: https://github.com/Belyashik2K/AaioAsync
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AaioAsync-0.1.10-1.src.rpm
checksum_type: sha256
description:
  > Fully async python wrapper for Aaio.io API


      pip install AaioAsync

  ```python
  import asyncio

  from AaioAsync import AaioAsync

  aaio = AaioAsync("API Key", "Shop ID", "Secretkey №1")

  async def main():

      balance = await aaio.getbalance()

      print('Доступно >>> ', balance.balance)
      print('В холде >>> ', balance.hold)
      print('Реферальный >>> ', balance.referral)

      info = await aaio.getorderinfo('HelloAaio')

      print('ID >>> ', info.order_id)
      print('Сумма >>> ', info.amount)
      print('Дата >>> ', info.date)
      print('Валюта >>>', info.currency)

  asyncio.run(main())
  ```

  ```Python

  Доступно >>>  122783.43
  В холде >>>  10267.3
  Реферальный >>>  3245.92

  ID >>>  HelloAaio
  Сумма >>>  7510.0
  Дата >>>  2023-07-29 23:21:20
  Валюта >>> RUB

  ```


  > Go to https://wiki.aaio.io/ for more information about working with acquiring


pkgId: 093eedac37473f927d9202a74a8aea5657433b0dfd5268566be05e42da767210
name: python-AaronTools
arch: src
version: 1.0
epoch: 0
release: 1
summary: Tools for measuring and manipulating molecular structures
url: https://github.com/QChASM/AaronTools.py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AaronTools-1.0-1.src.rpm
checksum_type: sha256
description:
  <a href="https://badge.fury.io/py/AaronTools"><img src="https://badge.fury.io/py/AaronTools.svg" alt="PyPI version"></a>
  <a href='https://aarontools.readthedocs.io/en/latest/?badge=latest'>
      <img src='https://readthedocs.org/projects/aarontools/badge/?version=latest' alt='Documentation Status' />
  </a>
  <a href="https://pypi.org/project/AaronTools/1.0b19/"><img src="https://img.shields.io/pypi/dm/aarontools.svg"></a>
  <a href="https://doi.org/10.1002/wcms.1510"><img src="https://img.shields.io/badge/DOI-10.1002/wcms.1510-blue"></a>


  AaronTools provides a collection of tools for automating routine tasks encountered when running quantum chemistry computations.

  These tools can be used either directly within a Python script using AaronTools objects, or via a series of command-line scripts.


  AaronTools documenation, including tutorials on the Python API, can be found on our <a href="https://aarontools.readthedocs.io/en/latest/">Read-the-Docs Page</a>.


  * with pypi: <code>pip install AaronTools</code>

  See the <a href="https://aarontools.readthedocs.io/en/latest/tutorials/install.html">installation guide</a> for more details, including how to manually install from this GitHub repository.


  If you use AaronTools, please cite:

  V. M. Ingman, A. J. Schaefer, L. R. Andreola, and S. E. Wheeler "QChASM: Quantum Chemistry Automation and Structure Manipulation" <a href="http://dx.doi.org/10.1002/wcms.1510" target="_blank"><i>WIREs Comp. Mol. Sci.</i> <b>11</b>, e1510 (2021)</a>


  AaronTools has a wide variety of features that can be accessed through the Python API as well as command line scripts (CLSs). These features include, but are not limited to:

  * Calculating steric parameters
    * Sterimol Parameters, including Sterimol2Vec (<a href="https://aarontools.readthedocs.io/en/latest/cls/substituentSterimol.html">substituent CLS</a>, <a href="https://aarontools.readthedocs.io/en/latest/cls/ligandSterimol.html">ligand CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/substituent.py#L504">substituent API</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/component.py#L219">ligand API</a>)
    * Buried Volume (<a href="https://aarontools.readthedocs.io/en/latest/cls/percentVolumeBuried.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/geometry.py#L2408">API</a>)
    * Steric Maps (<a href="https://aarontools.readthedocs.io/en/latest/cls/stericMap.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/geometry.py#L2739">API</a>)
    * Ligand Solid Angle (<a href="https://aarontools.readthedocs.io/en/latest/cls/solidAngle.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/component.py#L901">API</a>)
    * Ligand Cone Angle - Tolman for asymmetric mono- and bidentate ligands, as well as exact cone angles (<a href="https://aarontools.readthedocs.io/en/latest/cls/coneAngle.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/component.py#L456">API</a>)
  * Molecular Structure Editing
    * add or modify substituents (<a href="https://aarontools.readthedocs.io/en/latest/cls/substitute.html">single CLS</a>, <a href="https://aarontools.readthedocs.io/en/latest/cls/multiSubstitute.html">batch CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/geometry.py#L3979">single API</a>)
    * swap ligands (<a href="https://aarontools.readthedocs.io/en/latest/cls/mapLigand.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/geometry.py#L4907">API</a>)
  * Generating Molecular Structures
    * coordination complexes (<a href="https://aarontools.readthedocs.io/en/latest/cls/getCoordinationComplexes.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/geometry.py#L271">API</a>)
    * organic molecules from SMILES or IUPAC (<a href="https://aarontools.readthedocs.io/en/latest/cls/fetchMolecule.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/geometry.py#L154">API</a>)
  * Quantum Computation Setup and Processing
    * making input files for Gaussian, ORCA, Psi4, Q-Chem, xTB, and SQM (<a href="https://aarontools.readthedocs.io/en/latest/cls/makeInput.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/fileIO.py#L190">API</a>)
    * parsing data from output files (<a href="https://aarontools.readthedocs.io/en/latest/cls/printInfo.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/fileIO.py#L1077">API</a>)
    * thermochemistry based on Boltzmann-populated vibrational modes (<a href="https://aarontools.readthedocs.io/en/latest/cls/grabThermo.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/comp_output.py#L36">API</a>)
    * normal vibrational modes (<a href="https://aarontools.readthedocs.io/en/latest/cls/follow.html">displace along mode CLS</a>, <a href="https://aarontools.readthedocs.io/en/latest/cls/printFreq.html">print data CLS</a>, <a href="https://aarontools.readthedocs.io/en/latest/cls/plotIR.html">IR or VCD spectrum CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/spectra.py#L691">API</a>)
    * valence excitations (<a href="https://aarontools.readthedocs.io/en/latest/cls/plotUVVis.html">UV/vis or ECD spectrum CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/ff461166927faff684d6d16e4deb1e4a45375eae/spectra.py#L1327">API</a>)
    * orbitals, electron density, and Fukui functions (<a href="https://aarontools.readthedocs.io/en/latest/cls/printCube.html">CLS</a>, <a href="https://github.com/QChASM/AaronTools.py/blob/e5f218341e47c74e41df3340ab6a31d3cadcaf6a/orbitals.py#L14">API</a>)
  * Parse data from output files of several popular quantum chemistry programs (<a href="https://aarontools.readthedocs.io/en/latest/tutorials/coding_with_filereaders.html">Read-the-Docs Tutorial</a>)
    * Gaussian
    * ORCA
    * Psi4
    * Q-Chem
    * NBO
    * xTB

  Features are explained in more detail in the <a href="https://aarontools.readthedocs.io/en/latest/">documentation and in docstrings of the Python API.





  The majority of these features are also available with a graphical interface in the <a href="https://cxtoolshed.rbvi.ucsf.edu/apps/seqcrow">SEQCROW plugin</a> for <a href="https://www.cgl.ucsf.edu/chimerax/">ChimeraX</a>.


  A Perl implementation of AaronTools is also <a href="https://github.com/QChASM/AaronTools">available here.</a>
  However, users are <em>strongly urged</em> to use the Python version since it has far more powerful features and, unlike the Perl version, will continue to be developed and supported.



  If you have any questions or would like to discuss bugs or additional needed features, feel free to contact us at qchasm@uga.edu


pkgId: 52114d4729a108311ccd765570a9452354af83f2e211007a43d8e80e5e3bd632
name: python-AbdomenAtlas
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A package for 3D medical image segmentation using deep learning techniques.
url: https://pypi.org/project/AbdomenAtlas/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AbdomenAtlas-0.1.1-1.src.rpm
checksum_type: sha256
description:
  We are proud to introduce AbdomenAtlas-8K, a substantial multi-organ dataset with the spleen, liver, kidneys, stomach, gallbladder, pancreas, aorta, and IVC annotated in **8,448** CT volumes, totaling **3.2 million** CT slices.

  An endeavor of such magnitude would demand a staggering **1,600 weeks** or roughly **30.8 years** of an experienced annotator's time.

  In contrast, our annotation method has accomplished this task in **three weeks** (premised on an 8-hour workday, five days a week) while maintaining a similar or even better annotation quality.

  <p align="center"><img width="100%" src="document/fig_dataset_overview.jpg" /></p>
  <p align="center"><img width="100%" src="document/fig_dataset.gif" /></p>
  <p align="center"><img width="60%" src="document/fig_legend.png" /></p>



  <table>
    <tr>
      <th></th>
      <th>Option</th>
      <th>Image & Mask</th>
      <th>Image-Only</th>
      <th>Mask-Only</th>
    </tr>
    <tr>
      <td rowspan="3">Huggingface</td>
      <td>All-in-one</td>
      <td></td>
      <td></td>
      <td>Download (3.3GB)<details><div>A single compressed file containing all labels.</div></details></td>
    </tr>
    <tr>
      <td>Zips</td>
      <td><a href="https://huggingface.co/datasets/AbdomenAtlas/_AbdomenAtlas1.0Mini">Download (328GB)</a><details><div>11 compressed files in TAR.GZ format.</div></details></td>
      <td>Download<details><div>11 compressed files in TAR.GZ format.</div></details></td>
      <td></td>
    </tr>
    <tr>
      <td>Folders</td>
      <td><a href="https://huggingface.co/datasets/AbdomenAtlas/AbdomenAtlas1.0Mini">Download (340GB)</a><details><div>5,195 folders, each containing CT, combined labels, and a segmentations folder of nine masks in NII.GZ format.</div></details></td>
      <td>Download (325GB)<details><div>5,195 folders, each containing CT in NII.GZ format.</div></details></td>
      <td>Download (15GB)<details><div>5,195 folders, each containing combined labels, and a segmentations folder of nine masks in NII.GZ format.</div></details></td>
    </tr>
    <tr>
      <td rowspan="2">Dropbox</td>
      <td>All-in-one</td>
      <td><a href="https://www.dropbox.com/scl/fi/bqk780hn794gep6upfrge/AbdomenAtlas1.0Mini.tar.gz?rlkey=gjiiz731us18p9u7iouhin3gw&dl=0">Download (306GB)</a><details><div>A single compressed file containing all images and labels.</div></details></td>
      <td><a href="https://www.dropbox.com/scl/fi/v6esel9mun1k32mpmo690/AbdomenAtlas1.0Mini.tar.gz?rlkey=b1mxdmvasr9znpp31cup9eqhk&dl=0">Download (303GB)</a><details><div>A single compressed file containing all images.</div></details></td>
      <td><a href="https://www.dropbox.com/scl/fi/v6esel9mun1k32mpmo690/AbdomenAtlas1.0Mini.tar.gz?rlkey=b1mxdmvasr9znpp31cup9eqhk&dl=0">Download (3.3GB)</a><details><div>A single compressed file containing all labels.</div></details></td>
    </tr>
    <tr>
      <td>Zips</td>
      <td><a href="https://www.dropbox.com/scl/fo/jy4sf9mk3zzlty9qfhgx6/AAAJKO1bYvjL5J3CrU-w2rs?rlkey=j54u9eu968rw3ntd7bc4e5wd4&dl=0">Download (328GB)</a><details><div>11 compressed files in TAR.GZ format.</div></details></td>
      <td>Download<details><div>11 compressed files in TAR.GZ format.</div></details></td>
      <td></td>
    </tr>
    <tr>
      <td rowspan="2">Baidu Wangpan</td>
      <td>All-in-one</td>
      <td><a href="https://pan.baidu.com/s/1MtVfCVu3bk0Vd5GcR1qXhQ?pwd=0317">Download (306GB)</a><details><div>A single compressed file containing all images and labels.</div></details></td>
      <td><a href="https://pan.baidu.com/s/1-HQO-bYmeC0xFusqe-DwcA?pwd=0317">Download (303GB)</a><details><div>A single compressed file containing all images.</div></details></td>
      <td><a href="https://pan.baidu.com/s/1r3f4AhSffgIGauI0wRGEtw?pwd=0317">Download (3.3GB)</a><details><div>A single compressed file containing all labels.</div></details></td>
    </tr>
    <tr>
      <td>Zips</td>
      <td><a href="https://pan.baidu.com/s/1AdJmhFXPDua63wQ_zAEEiQ?pwd=0317">Download (328GB)</a><details><div>11 compressed files in TAR.GZ format.</div></details></td>
      <td>Download<details><div>11 compressed files in TAR.GZ format.</div></details></td>
      <td></td>
    </tr>
  </table>




  <b>AbdomenAtlas: A Large-Scale, Detailed-Annotated, & Multi-Center Dataset for Efficient Transfer Learning and Open Algorithmic Benchmarking</b> <br/>
  [Wenxuan Li](https://scholar.google.com/citations?hl=en&user=tpNZM2YAAAAJ), [Chongyu Qu](https://github.com/Chongyu1117), Xiaoxi Chen, Pedro R. A. S. Bassi, Yijia Shi, Yuxiang Lai, Qian Yu, Huimin Xue, Yixiong Chen, Xiaorui Lin, Yutong Tang, Yining Cao, Haoqi Han, Zheyuan Zhang, Jiawei Liu, Tiezheng Zhang, Yujiu Ma, Jincheng Wang, Guang Zhang, [Alan Yuille](https://www.cs.jhu.edu/~ayuille/), [Zongwei Zhou](https://www.zongweiz.com/)* <br/>
  Johns Hopkins University <br/>
  Medical Image Analysis, 2024 <br/>
  <a href='https://www.zongweiz.com/dataset'><img src='https://img.shields.io/badge/Project-Page-Green'></a> <a href='https://www.cs.jhu.edu/~alanlab/Pubs24/li2024abdomenatlas.pdf'><img src='https://img.shields.io/badge/Paper-PDF-purple'></a>

  <b>AbdomenAtlas-8K: Annotating 8,000 CT Volumes for Multi-Organ Segmentation in Three Weeks</b> <br/>
  [Chongyu Qu](https://github.com/Chongyu1117)<sup>1</sup>, [Tiezheng Zhang](https://github.com/ollie-ztz)<sup>1</sup>, [Hualin Qiao](https://www.linkedin.com/in/hualin-qiao-a29438210/)<sup>2</sup>, [Jie Liu](https://ljwztc.github.io/)<sup>3</sup>, [Yucheng Tang](https://scholar.google.com/citations?hl=en&user=0xheliUAAAAJ)<sup>4</sup>, [Alan L. Yuille](https://www.cs.jhu.edu/~ayuille/)<sup>1</sup>, and [Zongwei Zhou](https://www.zongweiz.com/)<sup>1,*</sup> <br/>
  <sup>1 </sup>Johns Hopkins University,  <br/>
  <sup>2 </sup>Rutgers University,  <br/>
  <sup>3 </sup>City University of Hong Kong,   <br/>
  <sup>4 </sup>NVIDIA <br/>
  NeurIPS 2023 <br/>
  [paper](https://www.cs.jhu.edu/~alanlab/Pubs23/qu2023abdomenatlas.pdf) | [code](https://github.com/MrGiovanni/AbdomenAtlas) | [dataset](https://huggingface.co/datasets/AbdomenAtlas/AbdomenAtlas1.0Mini) | [poster](document/neurips_poster.pdf)

  <b>AbdomenAtlas-8K: Human-in-the-Loop Annotating Eight Anatomical Structures for 8,448 Three-Dimensional Computed Tomography Volumes in Three Weeks</b> <br/>
  [Chongyu Qu](https://github.com/Chongyu1117)<sup>1</sup>, [Tiezheng Zhang](https://github.com/ollie-ztz)<sup>1</sup>, [Hualin Qiao](https://www.linkedin.com/in/hualin-qiao-a29438210/)<sup>2</sup>, [Jie Liu](https://ljwztc.github.io/)<sup>3</sup>, [Yucheng Tang](https://scholar.google.com/citations?hl=en&user=0xheliUAAAAJ)<sup>4</sup>, [Alan L. Yuille](https://www.cs.jhu.edu/~ayuille/)<sup>1</sup>, and [Zongwei Zhou](https://www.zongweiz.com/)<sup>1,*</sup> <br/>
  <sup>1 </sup>Johns Hopkins University,  <br/>
  <sup>2 </sup>Rutgers University,  <br/>
  <sup>3 </sup>City University of Hong Kong,   <br/>
  <sup>4 </sup>NVIDIA <br/>
  RSNA 2023 (Oral Presentation) <br/>
  [paper](document/rsna_abstract.pdf) | [code](https://github.com/MrGiovanni/AbdomenAtlas) | [slides](document/rsna_slides.pdf)

  **&#9733; An improved version, AbdomenAtlas 1.1, can be found at [SuPreM](https://github.com/MrGiovanni/SuPreM) [![GitHub stars](https://img.shields.io/github/stars/MrGiovanni/SuPreM.svg?logo=github&label=Stars)](https://github.com/MrGiovanni/SuPreM).**

  **&#9733; Touchstone - [Let's benchmark!](https://www.cs.jhu.edu/~zongwei/advert/TutorialBenchmarkV1.pdf) [![GitHub stars](https://img.shields.io/github/stars/MrGiovanni/Touchstone.svg?logo=github&label=Stars)](https://github.com/MrGiovanni/Touchstone)**

  **&#9733; We have maintained a document for [Frequently Asked Questions](document/frequently_asked_questions.md).**



  ```bash
  git clone https://github.com/MrGiovanni/AbdomenAtlas
  ```

  See [installation instructions](document/INSTALL.md) to create an environment and obtain requirements.



  We offer pre-trained checkpoints of Swin UNETR and U-Net. The models were trained on a combination of 14 publicly available CT datasets, consisting of 3,410 (see details in [CLIP-Driven Universal Model](https://github.com/ljwztc/CLIP-Driven-Universal-Model)).
  Download the trained models and save them into `./pretrained_checkpoints/`.

  | Architecture | Param | Download |
  |  ----  | ----  |  ----  |
  | U-Net  | 19.08M | [link](https://www.dropbox.com/s/lyunaue0wwhmv5w/unet.pth) |
  | Swin UNETR | 62.19M | [link](https://www.dropbox.com/s/jdsodw2vemsy8sz/swinunetr.pth) |



  It can be publicly available datasets (e.g., BTCV) or your private datasets. Currently, we only take data formatted in `nii.gz`. This repository will help you assign annotations to these datasets, including 25 organs and six types of tumors (*where the annotation of eight organs is pretty accurate*).



  Taking the BTCV dataset as an example, download this dataset and save it to the `datapath` directory.
  ```bash
  cd $datapath
  wget https://www.dropbox.com/s/jnv74utwh99ikus/01_Multi-Atlas_Labeling.tar.gz
  tar -xzvf 01_Multi-Atlas_Labeling.tar.gz
  ```



  Generate a list for this dataset.

  ```bash
  cd AbdomenAtlas/
  python -W ignore generate_datalist.py --data_path $datapath --dataset_name $dataname --folder img --out ./dataset/dataset_list --save_file $dataname.txt
  ```




  ```bash
  CUDA_VISIBLE_DEVICES=0 python -W ignore test.py --resume pretrained_checkpoints/unet.pth --backbone unet --save_dir $savepath --dataset_list $dataname --data_root_path $datapath --store_result >> logs/$dataname.unet.txt
  ```


  ```bash
  CUDA_VISIBLE_DEVICES=0 python -W ignore test.py --resume pretrained_checkpoints/swinunetr.pth --backbone swinunetr --save_dir $savepath --dataset_list $dataname --data_root_path $datapath --store_result >> logs/$dataname.swinunetr.txt
  ```
  To generate attention maps for the active learning process (Step 5 [optional]), remember to save entropy and soft predictions by using the options `--store_entropy` and `--store_soft_pred`



  In the assembly process, our utmost priority is given to the original annotations supplied by each public dataset. Subsequently, we assign secondary priority to the revised labels from our annotators. The pseudo labels, generated by AI models, are accorded the lowest priority. The following code can implement this priority into the assembled dataset.

  ```bash
  python -W ignore assemble.py --data_path $savepath --dataset_name $dataname --backbone swinunetr --save_dir SAVE_DIR --version V1
  ```

  This is how our AbdonmenAtlas-8K appears
  ```
      $savepath/
      ├── $dataname_img0001
      ├── $dataname_img0002
      ├── $dataname_img0003
          │── ct.nii.gz
          ├── original_label.nii.gz
          ├── pseudo_label.nii.gz
          └── segmentations
              ├── spleen.nii.gz
              ├── liver.nii.gz
              ├── pancreas.nii.gz
  ```



  If you want to perform the active learning process, you will need the following [active learning instructions](document/active_learning_instructions.md) to generate the attention map for human annotators.

  <p align="center"><img width="100%" src="document/fig_attention_map.jpg" /></p>
  Figure. Illustration of an attention map.



  - [x] Release pre-trained AI model checkpoints (U-Net and Swin UNETR)
  - [x] Release the AbdomenAtlas-8K dataset (we commit to releasing 3,410 of the 8,448 CT volumes)
  - [ ] Support more data formats (e.g., dicom)



  ```
  @article{li2024abdomenatlas,
    title={AbdomenAtlas: A large-scale, detailed-annotated, \& multi-center dataset for efficient transfer learning and open algorithmic benchmarking},
    author={Li, Wenxuan and Qu, Chongyu and Chen, Xiaoxi and Bassi, Pedro RAS and Shi, Yijia and Lai, Yuxiang and Yu, Qian and Xue, Huimin and Chen, Yixiong and Lin, Xiaorui and others},
    journal={Medical Image Analysis},
    pages={103285},
    year={2024},
    publisher={Elsevier},
    url={https://github.com/MrGiovanni/AbdomenAtlas}
  }

  @article{qu2023abdomenatlas,
    title={Abdomenatlas-8k: Annotating 8,000 CT volumes for multi-organ segmentation in three weeks},
    author={Qu, Chongyu and Zhang, Tiezheng and Qiao, Hualin and Tang, Yucheng and Yuille, Alan L and Zhou, Zongwei and others},
    journal={Advances in Neural Information Processing Systems},
    volume={36},
    year={2023}
  }

  @inproceedings{li2024well,
    title={How Well Do Supervised Models Transfer to 3D Image Segmentation?},
    author={Li, Wenxuan and Yuille, Alan and Zhou, Zongwei},
    booktitle={The Twelfth International Conference on Learning Representations},
    year={2024}
  }
  ```


  This work was supported by the Lustgarten Foundation for Pancreatic Cancer Research and partially by the Patrick J. McGovern Foundation Award. We appreciate the effort of the MONAI Team to provide open-source code for the community.


pkgId: 9ac54cf6fc6e662db9ec6e79709668ba672bf9b127a05c88f737559c84331072
name: python-Abg
arch: src
version: 2.5.1
epoch: 0
release: 1
summary: add-on for Pyrogram || add-on for Hydrogram || Telegram bot helpers || Easy botting
url: https://github.com/AshokShau/Abg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Abg-2.5.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <b> ABG </b>
  </p>

  <p align="center"><a href="https://pepy.tech/project/abg"> <img src="https://static.pepy.tech/personalized-badge/abg?period=total&units=international_system&left_color=black&right_color=black&left_text=Downloads" width="169" height="29.69" alt="Downloads"/></a></p>



  - Python 3.8 ᴏʀ higher.
  - hydrogram 0.0.1 ᴏʀ higher.


  > **Note**: If you are using Hydrogram, avoid installing Pyrogram or its forks to prevent potential conflicts.

  ```bash
  pip install -U Abg # For Pyrogram or Pyrogram Forks
  ```

  ```bash
  pip install -U Abg[hydrogram] # For Hydrogram
  ```
  ```bash
  pip install -U Abg[pyrofork] # for pyrofork
  ```



  ```python
  from hydrogram import Client
  from hydrogram.types import CallbackQuery, Message

  from Abg import *  # type: ignore
  from hydrogram.helpers import ikb

  app = Client(
      name='Abg',
      api_id=6,
      api_hash='eb06d4abfb49dc3eeb1aeb98ae0f581e',
      bot_token="TOKEN",
      in_memory=True,
  )


  @app.on_cmd("start")
  async def start(self: Client, ctx: Message):
      await ctx.reply_text("Hello World", reply_markup=ikb([[("Hello", "hello")]]))


  @app.on_cb("hello")
  async def hello(_: Client, q: CallbackQuery):
      await q.answer("Hello From Abg", show_alert=True)


  app.run()

  ```


  ```python
  from Abg import *  # type: ignore # (all patch)
  from hydrogram.types import Message
  from hydrogram import Client

  app = Client("my_account")

  @app.on_cmd("del", group_only=True)
  @adminsOnly(
      self=app,
      permissions="can_delete_messages",
      is_both=True,
  ) # also you can use like this @app.adminsOnly(permissions="can_delete_messages", is_both=True)
  async def del_msg(self: Client, m: Message):
      if m.reply_to_message:
          await m.delete()
          await self.delete_messages(
              chat_id=m.chat.id,
              message_ids=m.reply_to_message.id,
          )
      else:
          await m.reply_text(text="Reply to a message to delete it")

  app.run()
  ```


  >


  ```python
  from Abg.patch.inline import InlineKeyboard, InlineButton

  keyboard = InlineKeyboard(row_width=3)
  keyboard.add(
      InlineButton('1', 'inline_keyboard:1'),
      InlineButton('2', 'inline_keyboard:2'),
      InlineButton('3', 'inline_keyboard:3'),
      InlineButton('4', 'inline_keyboard:4'),
      InlineButton('5', 'inline_keyboard:5'),
      InlineButton('6', 'inline_keyboard:6'),
      InlineButton('7', 'inline_keyboard:7')
  )
  ```


pkgId: 0d93dbf0ea07bbef5a86c8c8146d97beb619ec49f3419c28f24e124859bff22c
name: python-Abinde
arch: src
version: 2.5
epoch: 0
release: 1
summary: Abinde is an easy-to-use python module for pygame.
url: https://github.com/Abinde-Game-Dev/Abinde
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Abinde-2.5-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License Copyright (c) 2022 _TheRealPenguin 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: c45e774cc566616b67f7212561a746ace93ed0244fcffd7304f27df1f3f0b610
name: python-Aboutn
arch: src
version: 0.2.2.10
epoch: 0
release: 1
url: https://github.com/AkiraDemenech/About-n-Squares/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Aboutn-0.2.2.10-1.src.rpm
checksum_type: sha256
summary:
  An Art and Genetic Algorithms Exploration Package based on Russian Constructivism bidimensional graphic works, ideas and method;

description:
      About n [Squares]

  projeto de pesquisa/software de TCC sobre este Pacote de Exploração de Algoritmos Genéticos e Arte baseado em obras, ideias e métodos gráficos bidimensionais do Construtivismo Russo;


pkgId: 5822f7675193b0de59419f2871e3021eb8b926c76c885f8395abf25fb38f33cf
name: python-Accern
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A python library for Accern Data API
url: https://github.com/Accern/accern-python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Accern-0.4.0-1.src.rpm
checksum_type: sha256
description:
  *Accern*: A Python library for Accern's API.

  Accern primarily serves institutional investors. The majority of our current
  clients are quantitative hedge funds. Many small firms are coming to us
  because of our flexible and affordable pricing options. Large firms are coming
  to us due to our dedicated support, news source customization, and much more.
  Aside from hedge funds, our existing clients include pension and endowment
  funds, banks, brokerage firms, and more.

  Accern library for Python helps user to get fast, flexible data structures from
  Accern historical and streaming api.

  All Accern wheels from PyPI are MIT licensed.


pkgId: bb5fbf615d188a16972f1ac82c323aac9e83bdee4a73df649f81f7892ef686b0
name: python-AccuRating
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: AccuRating is a library for accurate player ranking based on match results.
url: https://github.com/lukaszlew/accurating
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AccuRating-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Library computing accurate ratings based on match results.

  - [Documentation](https://lukaszlew.github.io/accurating/accurating.html)
  - [Package](https://pypi.org/project/accurating/)
  - [Usage example](https://github.com/lukaszlew/accurating/blob/main/accurating/tests/model_test.py#L50)



  Yes. With the same data, AccuRating will return much more accurate ratings than chess ELO or EGD.
  For instance if a player Leon manages to win against player Caesar, Leon will "get" some X points for that victory.
  If later Caesar will win against strong players Alusia and EmCee, his rating will increase, but that would not affect Leon's rating in chess or EGD.
  If we want to use data efficienty Leon's rating should be adjusted because Caesar clearly demonstrated his power and it was not long ago that poor Leon lucked out a victory against Caesar.

  EGD, Chess ELO go over the data once, so they have no way of taking that into account.
  AccuRating shows that we need about 1500 - 2000 passes over the data to converge to accurate ratings.

  AccuRating is a variant of [Whole-History-Rating](https://www.remi-coulom.fr/WHR/), which is also used at https://www.goratings.org/.

  [Interesting discussion](https://www.mail-archive.com/computer-go@computer-go.org/msg07781.html) on why WHR is good.



  Only differences matter, i.e. adding say 100 to all the ratings would yield equally valid points.

  - 100 AccuRating point difference is 1:2 win odds (33% vs 66%)
  - 200 AccuRating point difference is 1:5 win odds (20% vs 80%)
  - 300 AccuRating point difference is 1:9 win odds (11% vs 89%)

  The exact formula is $P(win) = 1 / (1 + 2^{d / 100})$.
  Optimization algorithm find ratings that maximize probability of the data.



  Chess ELO is similar, but the points are rescaled by 1.20412:

  - 120.412 chess ELO difference for 1:2 win odds (33% vs 66%)
  - 240.824 chess ELO difference for 1:5 win odds (20% vs 80%)
  - 361.236 chess ELO difference for 1:9 win odds (11% vs 89%)

  The Chess ELO formula is $P(win) = 1 / (1 + 10^{d / 400})$



  [In EGD, winning odds for 100 points of rating is not fixed.](http://goratings.eu/Home/About)
  This is beacuse: 1 dan/kyu difference = 100 EGD = 1 handicap.
  The nature of Go is that 1 handicap (i.e. 100 EGD) means more on a dan level than on a kyu level.

  On the dan level:

  - 90 EGD point difference is approximately 1:2 win odds (33% vs 66%)
  - 180 EGD point difference is approximately 1:5 win odds (20% vs 80%)
  - 270 EGD point difference is approximately 1:9 win odds (11% vs 89%)

  On the kyu level:

  - 300 EGD point difference is approximately 1:2 win odds (33% vs 66%)
  - 600 EGD point difference is approximately 1:5 win odds (20% vs 80%)
  - 900 EGD point difference is approximately 1:9 win odds (11% vs 89%)

  [Based on these tables.](https://www.europeangodatabase.eu/EGD/winning_stats.php)



  Typical ELO systems (like EGD) use every game result only once and update rating based on it.
  This model can do 1500 passes over the data until it converged (the first pass returns numbers more or less like standard ELO system, equations are almost the same).
  However so many passes is too expensive when the number of games is as big as EGD.



  This system does not have any gamification incentives so it is bad to player motivation.
  It uses data efficiently and nicely approximates true strength.
  It can be compared to hidden MMR used for match-making in games like Starcraft 2, not to the player-visible motivating points with various "bonus points".



  The model finds a single number (ELO strength) for each player.
  Given ELO of two players, the model predicts probability of win in a game:
  If we assume that $P$ and $Q$ are rankings of two players, the model assumes:

  $$P(\text{P vs Q win}) = \frac{2^P}{2^P + 2^Q} = \frac{1}{1 + 2^{Q-P}} $$

  This means that if both rankings are equal to $a$, then: $P(win) = \frac{2^a}{2^a+2^a} = 0.5$.
  If a ranking difference is one point, we have $P(win) = \frac{2^{a+1}}{2^{a+1}+2^{a}} = \frac{2}{2+1}$
  Two point adventage yields $P(win) = \frac{1}{5}$
  $n$ point adventage yields $P(win) = \frac{1}{1+2^n}$

  For readability reasons we rescale the points by 100. This is exactly equivalent to using this equation:

  $$ \frac{1}{1 + 2^{\frac{Q-P}{100}}} $$



  In single pass systems, if you play a game, it will not affect the model estimation of your rating yesterday.
  In multi-pass system we can estimate every player's rating for every season (or even every day).
  Then iteratively pass over the data again and again until we find rating curves that best fit the data.

  There is a parameter that controlls how fast the rating can change.
  WHR model assumes that player rating is a gaussian process in time, and this parameter is variance of this gaussian process.

  The consequence is that data flows both time directions: if you play game in season 20, it will also affect your ratings for season 19 (a bit) and season 18 (very small bit) etc.
  The data also flows over the whole graph of games and players on each iteration.



  Because EGD is using different exponent base, it is not that easy to convert directly.
  These is a monotonic conversion function but it is non-linear, and it would take some work to derive the formula.

  It would be interesting to plot EGD ratings against AccuRating ratings.



  This repo implements:

  - Implement [Bradley-Terry (BT) model](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) for player ranking (better variant of ELO).
  - Generalization BT model to a variant of [WHR model](https://www.remi-coulom.fr/WHR/) with time as seasons.



  - distribution fit to account for heavy tail
  - Chess units
  - EGD conversion
  - Fit player variance (high variance player can more easily win against stonger players and more easily lose against weaker players)
  - Follow this: https://www.marwandebbiche.com/posts/python-package-tooling/



  ```shell
  git config --global core.hooksPath .githooks/
  ```

  ```shell
  git clone https://github.com/lukaszlew/accurating
  virtualenv /tmp/venv
  source /tmp/venv/bin/activate
  pip install poetry
  poetry install
  poetry run pytest
  poetry run mypy .


  poetry build
  poetry publish
  ```


pkgId: 81d5c13cfb346fa02492b2489d972626e71137b743b8742a743e02b45b7590c0
name: python-Accuinsight
arch: src
version: 3.5.20231124
epoch: 0
release: 1
summary: Model life cycle and monitoring library in Accuinsight+
url: https://pypi.org/project/Accuinsight/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Accuinsight-3.5.20231124-1.src.rpm
checksum_type: sha256
description:
  1. set up virtual environment for python
      - for Pycharm
          - https://www.jetbrains.com/help/pycharm/creating-virtual-environment.html
      - for pure python
          - go to your/download/src/directory and run the below commands
          >>> python3 -m venv venv
          >>> source venv/bin/activate
  2. after downloading source from git, open terminal and run the below command.
      >>>  python setup.py test install
  3. if you added a new package then run the following commend
      >>> python setup.py install
  4. Install protobuf 3.6.1 on Ubuntu 18.04
          
          
          curl -OL https://github.com/google/protobuf/releases/download/v3.6.1/protoc-3.6.1-linux-x86_64.zip
          https://github.com/google/protobuf/releases/download/v3.6.1/protoc-3.6.1-linux-x86_64.zip
          
          unzip protoc-3.6.1-linux-x86_64.zip -d protoc3
          
          sudo mv(or cp -pr) protoc3/bin/* /usr/local/bin/
          
          sudo mv(or cp -pr) protoc3/include/* /usr/local/include/
          
          sudo chown $USER /usr/local/bin/protoc
          sudo chown -R $USER /usr/local/include/google
      - if you update or add "\*.proto" file in protos package
          - excute generate-protos.sh
  How to use
      - for Lifecycle
          - see Lifecycle/README.MD


pkgId: ac3eff1d682b60319ca9b1549a983960f60b7683484ba96ae0593e53addb71c9
name: python-AcodisApiHandler
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: A simple API handler for Python
url: https://pypi.org/project/AcodisApiHandler/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AcodisApiHandler-0.3.7-1.src.rpm
checksum_type: sha256
description:
  This package provides easy to use python classes and functions to communicate with Acodis API (https://acodis.io).
  Acodis is an IDP solution that focuses on extracting and structuring complex documents (PDFs, Images)


  ```bash
  pip install AcodisApiHandler
  ```


  This package is particularly useful for programmatic access, since ACODIS' API structure requires a different
  **user** and **password** for every export step. Hence, if you have to manage multiple exports
  (e.g. multiple workflows), you just need to update the main class `user` and `password` attribute,
  and call the `authenticate()` method.
  ```python
  from AcodisApiHandler import AcodisApiHandler


  ACODIS_BASE_URL = "https://<YOUR-ACOIDS-INSTANCE-URL>/workbench/api/transaction"
  ACODIS_USER = "<YOUR-EXPORT-USERNAME>"
  ACODIS_PASSWORD = "<YOUR-EXPORT-PASSWORD>"


  handler = AcodisApiHandler(ACODIS_BASE_URL)


  handler.user = ACODIS_USER
  handler.password = ACODIS_PASSWORD


  handler.authenticate()

  handler.workflow(pdf_path="<PATH-TO-PDF-FILE>")



  print(handler.result)
  ```


  This package also provides some utils to help you with the extraction process.


  Tags are used to identify the data points that you want to extract from the document.
  This function will create a dictionary with the tags as keys and the extracted data as values.
  ```python
  from AcodisApiHandler import extract_tags

  tags_list = ["example_tag_1", "example_tag_1", "example_tag_1"]


  tagged_data = extract_tags(handler, tags_list)
  ```

  If we print the `tagged_data` variable we will get:
  ```python
  {
      "example_tag_1": "Example data 1",
      "example_tag_2": "Example data 2",
      "example_tag_3": "Example data 3"
  }
  ```


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


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


  - [ ] Additional utils: parsing tables, extracting images, etc.
  - [ ] Add unit tests
  - [ ] Add batch processing and parallelization


pkgId: 8d9082ad0eb9589605daef958284b4897f021a0748139fae75e1ea64f61d25e1
name: python-Acquisition
arch: src
version: 6.1
epoch: 0
release: 1
url: https://github.com/zopefoundation/Acquisition
rpm_license: ZPL 2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Acquisition-6.1-1.src.rpm
checksum_type: sha256
summary:
  Acquisition is a mechanism that allows objects to obtain attributes from the containment hierarchy they're in.

description:
  This package implements "environmental acquisiton" for Python, as
  proposed in the OOPSLA96_ paper by Joseph Gil and David H. Lorenz:
      We propose a new programming paradigm, environmental acquisition in
      the context of object aggregation, in which objects acquire
      behaviour from their current containers at runtime. The key idea is
      that the behaviour of a component may depend upon its enclosing
      composite(s). In particular, we propose a form of feature sharing in
      which an object "inherits" features from the classes of objects in
      its environment.  By examining the declaration of classes, it is
      possible to determine which kinds of classes may contain a
      component, and which components must be contained in a given kind of
      composite. These relationships are the basis for language constructs
      that supports acquisition.


pkgId: 78143ba5db9576d5d90000ee9ecd05bebbe1a8660174799571251d0f6247f4b6
name: python-AcraNetwork
arch: src
version: 0.17.12
epoch: 0
release: 1
summary: Classes and utilities to support Flight Test Instrumentation Ethernet networks
url: https://github.com/diarmuidcwc/AcraNetwork
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AcraNetwork-0.17.12-1.src.rpm
checksum_type: sha256
description:
  A collection of classes that can be used to decom network or PCM based FTI traffic
  Summary
  ~~~~~~~
  * iNetX : Class for packing and unpacking iNetX objects
  * IENA  : Class for packing and unpacking IENA objects
  * SimpleEthernet : A  simplified set of classes for Ethernet, IP and UDP packets. These are not fully featured is sufficient for the network systems used in the KAM500 networks
  * Pcap : Class and helper methods for reading pcap files
  * McastSocket : Class to bind to ports to capture multicast packets
  Install
  ~~~~~~~
  Install using the standard setuptools install method
  	python setup.py install
  or clone this repository to your local directory
  	git clone https://github.com/diarmuidcwc/AcraNetwork.git
  Usage
  ~~~~~
  Here are two brief examples on how to create and read a pcap file. Further examples can be viewed in the examples
  directory or in the unittest folder
  To read in a pcap file with multiple ethernet packets all containing an iNetX packet wrapped in UDP
  	import AcraNetwork.iNetX as inetx
  	import AcraNetwork.SimpleEthernet as SimpleEthernet
  	import AcraNetwork.Pcap as pcap
  	import struct
  	mypcap = pcap.Pcap("inetx_test.pcap")       # Read the pcap file
  	for mypcaprecord in mypcap:
  		ethpacket = SimpleEthernet.Ethernet()   # Create an Ethernet object
  		ethpacket.unpack(mypcaprecord.packet)   # Unpack the pcap record into the eth object
  		ippacket =  SimpleEthernet.IP()         # Create an IP packet
  		ippacket.unpack(ethpacket.payload)      # Unpack the ethernet payload into the IP packet
  		udppacket = SimpleEthernet.UDP()        # Create a UDP packet
  		udppacket.unpack(ippacket.payload)      # Unpack the IP payload into the UDP packet
  		inetxpacket = inetx.iNetX()             # Create an iNetx object
  		inetxpacket.unpack(udppacket.payload)   # Unpack the UDP payload into this iNetX object
  		print("INETX: StreamID ={:08X} Sequence = {:8d} PTP Seconds = {}".format(inetxpacket.streamid,inetxpacket.sequence,inetxpacket.ptptimeseconds))
  To Make a Distribution
  ~~~~~~~~~~~~~~~~~~~~~~
  	pip  install --upgrade pip wheel setuptools twine
  	rm dist/*
  	python ./setup.py sdist bdist_wheel --universal sdist
  	twine upload dist/*


pkgId: bb3c442d2bdac46a266e17d9d427dd677d792e00322cd8d0f0b83ce648994e31
name: python-Actifio
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Actifio Restful API wrapper for Python.
url: https://github.com/Actifio/actifio-python-package
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Actifio-1.0.5-1.src.rpm
checksum_type: sha256
description:
  Copyright 2018 <Kosala Atapattu kosala.atapattu@actifio.com>
  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: 6587ec0fe24efa2a1238e3bbb88640197925f8ef2f0e24cc7a9e29a36003ce94
name: python-ActionTree
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: Executes (long) actions in parallel, respecting dependencies between those actions
url: http://jacquev6.github.io/ActionTree
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ActionTree-0.13.2-1.src.rpm
checksum_type: sha256
description:
  Install from PyPI::
      $ pip install ActionTree
  With dependencies to create Gantt charts and dependency graphs::
      $ pip install 'ActionTree[dependency_graphs,gantt]'
  Import:
  >>> from ActionTree import execute
  >>> from ActionTree.stock import CallSubprocess
  Execute some action:
  >>> link = CallSubprocess(["g++", "a.o", "b.o", "-o", "test"])
  >>> link.add_dependency(CallSubprocess(["g++", "-c", "a.cpp", "-o", "a.o"]))
  >>> link.add_dependency(CallSubprocess(["g++", "-c", "b.cpp", "-o", "b.o"]))
  >>> report = execute(link)
  And verify everything went well:
  >>> report.is_success
  True
  >>> os.path.isfile("test")
  True


pkgId: 5b199b6ee80aaf90c0a2965a2a52ce55fe8318361704638dffc002a6b09bd766
name: python-Activate-App
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Activate is a free activity log and analysis tool.
url: https://gitlab.com/Tom_Fryers/activate
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Activate-App-0.0.10-1.src.rpm
checksum_type: sha256
description:
  Activate, a free activity log and analysis tool.
  Copyright © 2020–2021 Tom Fryers
  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/>.


pkgId: 3a9b54dacde595cb4f43dd08940011582751cf884c1e863cb15ad4758d2efc64
name: python-ActiveCollab
arch: src
version: 3.6
epoch: 0
release: 1
summary: A python library working with activeCollab
url: https://github.com/AnkushRozra/ActiveCollab
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ActiveCollab-3.6-1.src.rpm
checksum_type: sha256
description:
  Library for Active Collab. Perform actions such as list projects, list users, add note, add task, get project detail.
  Request Feature/Suggestion: https://forms.gle/efGD5DuTpWsX96GG7


  [![Downloads](https://static.pepy.tech/badge/ActiveCollab)](https://pepy.tech/project/ActiveCollab)


  ```console
  pip install ActiveCollab
  ```
  ActiveCollab supports Python 3+.




  ```python
  import ActiveCollab

  host_url = 'host_url' # Active Collab hosted URL

  user_name = 'your_email' # Active Collab username or email

  password = 'your_password' # Active Collab Password

  ac = ActiveCollab.Connect(host_url,user_name,password)  # Login to Active Collab
  ```


  ```python
  ac.list_projects()  # List out all project assigned to logged in user
  ```


  ```python
  ac.list_project_tasklist(project_id)  # List out all task-list of a project
  ```


  ```python
  ac.list_users()  # List out all users in your organization with id, name and email
  ```


  ```python
  ac.project_detail(project_id)  # List out all info like id, name, users/members of a project (project_id)
  ```


  ```python
  ac.add_note_in_project(project_id,note_title,note_content)  # Add note in the provided project_id
  ```


  ```python
  ac.add_task_in_project(project_id,task_title,task_description,task_assignee)  # Add task in the provided project_id
  ```


pkgId: f6711ee4cca2d724be7480f6da2f1421e788adc86b4c67bf9d243dce05702ace
name: python-ActiveDirectoryEnum
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Enumerate Active Directory with standard vectors
url: https://github.com/CasperGN/ActiveDirectoryEnumeration
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ActiveDirectoryEnum-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub stars](https://img.shields.io/github/stars/CasperGN/ActiveDirectoryEnumeration)](https://github.com/CasperGN/ActiveDirectoryEnumeration/stargazers) [![GitHub forks](https://img.shields.io/github/forks/CasperGN/ActiveDirectoryEnumeration)](https://github.com/CasperGN/ActiveDirectoryEnumeration/network) [![GitHub license](https://img.shields.io/github/license/CasperGN/ActiveDirectoryEnumeration)](https://github.com/CasperGN/ActiveDirectoryEnumeration/blob/master/LICENSE) [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FCasperGN%2FActiveDirectoryEnumeration.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FCasperGN%2FActiveDirectoryEnumeration?ref=badge_shield) [![Total alerts](https://img.shields.io/lgtm/alerts/g/CasperGN/ActiveDirectoryEnumeration.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/CasperGN/ActiveDirectoryEnumeration/alerts/) [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/CasperGN/ActiveDirectoryEnumeration.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/CasperGN/ActiveDirectoryEnumeration/context:python)

  [![Packaging status](https://repology.org/badge/vertical-allrepos/activedirectoryenum.svg)](https://repology.org/project/activedirectoryenum/versions)


  ```
   python -m ade
  usage: ade [-h] [--dc DC] [-o OUT_FILE] [-u USER] [-s] [-smb] [-kp] [-bh] [-spn] [-sysvol] [--all] [--no-creds] [--dry-run]
             [--exploit EXPLOIT]

          ___        __  _            ____  _                __                   ______
         /   | _____/ /_(_)   _____  / __ \(_)_______  _____/ /_____  _______  __/ ____/___  __  ______ ___
        / /| |/ ___/ __/ / | / / _ \/ / / / / ___/ _ \/ ___/ __/ __ \/ ___/ / / / __/ / __ \/ / / / __ `__ \
       / ___ / /__/ /_/ /| |/ /  __/ /_/ / / /  /  __/ /__/ /_/ /_/ / /  / /_/ / /___/ / / / /_/ / / / / / /
      /_/  |_\___/\__/_/ |___/\___/_____/_/_/   \___/\___/\__/\____/_/   \__, /_____/_/ /_/\__,_/_/ /_/ /_/
                                                                        /____/

  /*----------------------------------------------------------------------------------------------------------*/

  optional arguments:
    -h, --help            show this help message and exit
    --dc DC               Hostname of the Domain Controller
    -o OUT_FILE, --out-file OUT_FILE
                          Path to output file. If no path, CWD is assumed (default: None)
    -u USER, --user USER  Username of the domain user to query with. The username has to be domain name as `user@domain.org`
    -s, --secure          Try to estalish connection through LDAPS
    -smb, --smb           Force enumeration of SMB shares on all computer objects fetched
    -kp, --kerberos_preauth
                          Attempt to gather users that does not require Kerberos preauthentication
    -bh, --bloodhound     Output data in the format expected by BloodHound
    -spn                  Attempt to get all SPNs and perform Kerberoasting
    -sysvol               Search sysvol for GPOs with cpassword and decrypt it
    --all                 Run all checks
    --no-creds            Start without credentials
    --dry-run             Don't execute a test but run as if. Used for testing params etc.
    --exploit EXPLOIT     Show path to PoC exploit code

  ```

  The new inclusion of imbedded exploits can yield results such as:
  ```
  ...
  [ WARN ] DC may be vulnerable to: [ cve-2020-1472 ]
  ...
  ```

  To query an exploit do for PoC code:
  ```
  $ python -m ade --exploit cve-2020-1472
  Exploit for: cve-2020-1472 can be found at: https://github.com/dirkjanm/CVE-2020-1472
  ```



  Run installation through pip3:
  ```
  pip3 install ActiveDirectoryEnum
  python -m ade
  ```

  If you run BlackArch, ActiveDirectoryEnum is available through `pacman` as such:
  ```
  pacman -S activedirectoryenum
  ```



  - [X] ASREPRoasting
  - [X] Kerberoasting
  - [X] Dump AD as BloodHound JSON files
  - [X] Searching GPOs in SYSVOL for cpassword and decrypting
  - [X] Run without creds and attempt to gather for further enumeration during the run
  - [X] Sample exploits included:
   - CVE-2020-1472



  While this project is developed to fit my need, any collaboration is appriciated. Please feel free to fork the project, make changes according to the License agreements and make a Pull Request.
  I only ask that:
  - Keep equivilent naming standard as the base project
  - Keep equivilent syntaxing
  - Test your code
  - Error handling is incorporated
  - Document the feature - both in code but also for potential Wiki page



  Big thanks to the creators of:
  `Impacket` [@github](https://github.com/SecureAuthCorp/impacket)
  `BloodHound` [@github](https://github.com/BloodHoundAD/BloodHound)
  `BloodHound.py` [@github](https://github.com/fox-it/BloodHound.py)
  `CVE-2020-1472` by Tom Tervoort of [Secura](https://github.com/SecuraBV/CVE-2020-1472)

  Without the above this wrapper was not possible.



  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FCasperGN%2FActiveDirectoryEnumeration.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FCasperGN%2FActiveDirectoryEnumeration?ref=badge_large)


pkgId: d0d7044f26b7067e2414991249dd14a4c7aee02cc7a752c94ecd4fa27f80586c
name: python-AdNoise
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Adversarial Noise
url: https://pypi.org/project/AdNoise/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdNoise-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Introduce adversarial noise into an input image to trick an image classification model into misclassifying it as the desired target class.


pkgId: 1037ed70e8093be080c492546eb16c9ec832ac6ec401fae001b235bb212e3550
name: python-Adafruit-ADS1x15
arch: src
version: 1.0.2
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/adafruit/Adafruit_Python_ADS1x15/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adafruit-ADS1x15-1.0.2-1.src.rpm
checksum_type: sha256
summary:
  Python code to use the ADS1015 and ADS1115 analog to digital converters with a Raspberry Pi or BeagleBone black.


pkgId: 4a61b77e41ae426f521efa7412aab5e37424aaf8728057fb3f1316465961cb54
name: python-Adafruit-GPIO
arch: src
version: 1.0.3
epoch: 0
release: 1
url: https://github.com/adafruit/Adafruit_Python_GPIO/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adafruit-GPIO-1.0.3-1.src.rpm
checksum_type: sha256
summary:
  Library to provide a cross-platform GPIO interface on the Raspberry Pi and Beaglebone Black using the RPi.GPIO and Adafruit_BBIO libraries.


pkgId: 590b119ac6ce8012e93778d06172bce6d0e6dd5a61eb06a3739aa4e1de279360
name: python-Adafruit-LED-Backpack
arch: src
version: 1.8.1
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/adafruit/Adafruit_Python_LED_Backpack/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adafruit-LED-Backpack-1.8.1-1.src.rpm
checksum_type: sha256
summary:
  Library to control LED backpack displays such as 8x8 single and bi-color matrices, bargraphs, 7 segment, and 14 segment displays.


pkgId: 40a6b07c510dc7d5e93003ba27ff15c970c8a1bdce9e54000c71166947b2513c
name: python-Adafruit-MAX31855
arch: src
version: 1.6.1
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/adafruit/Adafruit_Python_MAX31855/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adafruit-MAX31855-1.6.1-1.src.rpm
checksum_type: sha256
summary:
  Library for accessing the MAX31855 thermocouple temperature sensor on a Raspberry Pi or Beaglebone Black.


pkgId: d482a5bf49e1e77a7acf245bff9d97bf2ebc9ecafa03ff42ad5d803866beccf0
name: python-Adafruit-PN532
arch: src
version: 1.2.1
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/adafruit/Adafruit_Python_PN532/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adafruit-PN532-1.2.1-1.src.rpm
checksum_type: sha256
summary:
  Python library for accessing a PN532 NFC breakout over a SPI connection from a Raspberry Pi, BeagleBone Black, etc.


pkgId: ff9fe8329b7f0bd8a56d468fdf1d7e5aad7cf2574dbf00c37394a00ff11fae76
name: python-Adafruit-PlatformDetect
arch: src
version: 3.75.0
epoch: 0
release: 1
summary: Platform detection for use by libraries like Adafruit-Blinka.
url: https://github.com/adafruit/Adafruit_Python_PlatformDetect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adafruit-PlatformDetect-3.75.0-1.src.rpm
checksum_type: sha256
description:
  This library provides best-guess platform detection for a range of single-board
  computers and (potentially) other platforms.  It was written primarily for use
  in `Adafruit_Blinka <https://github.com/adafruit/Adafruit_Blinka>`_, but may be
  useful in other contexts.
  Platform detection is divided into "chip" and "board" detection, with the latter
  generally dependent on the former.  Platform info is gathered from:
    - Python's `sys.platform`
    - Various files on Linux systems:
      - /proc/cpuinfo (for processor info, Raspberry Pi hardware revisions, etc.)
      - /proc/device-tree/compatible (for 96Boards info)
    - Beaglebone EEPROM board IDs
    - Distribution-specific files such as /etc/armbian-release.


pkgId: 862e7c505a1f50b5c3d6d3d9535b9230ae521b94ec229a0aa87c030d2bab91cf
name: python-Adafruit-PureIO
arch: src
version: 1.1.11
epoch: 0
release: 1
url: https://github.com/adafruit/Adafruit_Python_PureIO
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adafruit-PureIO-1.1.11-1.src.rpm
checksum_type: sha256
summary:
  Pure python (i.e. no native extensions) access to Linux IO    including I2C and SPI. Drop in replacement for smbus and spidev modules.

description:
  Pure python (i.e. no native extensions) access to Linux IO including I2C and SPI. Drop in replacement for smbus and spidev modules.


pkgId: 2e1a3a8a24f6400a14eb94b3c06eba560d4c4761c1366c26684db828d74bec83
name: python-Adafruit-SSD1306
arch: src
version: 1.6.2
epoch: 0
release: 1
url: https://github.com/adafruit/Adafruit_Python_SSD1306/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adafruit-SSD1306-1.6.2-1.src.rpm
checksum_type: sha256
summary:
  Python library to use SSD1306-based 128x64 or 128x32 pixel OLED displays with a Raspberry Pi or Beaglebone Black.

description:
  Python library to use SSD1306-based 128x64 or 128x32 pixel OLED displays with a Raspberry Pi or Beaglebone Black.
  Designed specifically to work with the Adafruit SSD1306-based OLED displays ----> https://www.adafruit.com/categories/98
  Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!


pkgId: 27a11083f19af57fe02b70332c8813ea0c0009e5dd9d1737ac1ffceec62b3dc3
name: python-Aditzak
arch: src
version: 0.3.32
epoch: 0
release: 1
summary: A Python package to analyse and build Euskera/Basque verbs.
url: https://github.com/HCook86/Aditzak/
rpm_license: BSD 2-clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Aditzak-0.3.32-1.src.rpm
checksum_type: sha256
description:
  A library to analyze and build verbs in Euskera



  Using pip:

      `pip install Aditzak`



  Basic example:

      `
      from Aditzak import builder

      builder({"Aditza":None, "Kasua":"NOR-NORK", "Modua":"Ondorioa","Denbora":"Iragana", "Nor":"ni", "Nori":None, "Nork":"hark"})
      `


pkgId: eba795f3a697f05ad8fabf68a67c9210275943e89e3e7a91f145c789cd7645ac
name: python-AdobeConnect2Video
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: A handy tool to convert adobe connect zip data into a single video file
url: https://github.com/AliRezaBeigy/AdobeConnect2Video
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdobeConnect2Video-1.2.1-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/AdobeConnect2Video?style=for-the-badge)
  [![MIT License](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://github.com/AliRezaBeigy/AdobeConnect2Video/blob/master/LICENSE)
  [![PR's Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=for-the-badge)](http://makeapullrequest.com)
  ![GitHub Repo stars](https://img.shields.io/github/stars/AliRezaBeigy/AdobeConnect2Video?style=for-the-badge)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/AdobeConnect2Video?style=for-the-badge)

  A handy tool to convert adobe connect zip data into a single video file



  - Python 3
  - FFMPEG
    - Download [ffmpeg](https://www.ffmpeg.org/download.html) and put the installation path into PATH enviroment variable



  You need to [ffmpeg](https://www.ffmpeg.org) to use this app, so you can simply download ffmpeg from [Official Site](https://www.ffmpeg.org/download.html) then put the installation path into PATH enviroment variable

  Now you should install AdobeConnect2Video as global app:

  ```shell
  $ pip install -U AdobeConnect2Video
  or
  $ python -m pip install -U AdobeConnect2Video
  ```

  **Use `-U` option to update AdobeConnect2Video to the last version**



  Download the adobe connect zip data by adding following path to the address of online recorded class
  ```url
  output/ClassName.zip?download=zip
  ```
  for exmple if you online recorded class link is
  ```url
  http://online.GGGGG.com/p81var0hcdk5/
  ```
  you can download zip data from following link
  ```url
  http://online.GGGGG.com/p81var0hcdk5/output/ClassName.zip?download=zip
  ```
  Then extract the zip in 'data' directory and install AdobeConnect2Video from pip
  ```shell
  $ AdobeConnect2Video

  $ AdobeConnect2Video -i [classId]
  ```

  Example:
  If data extracted into 'Course1' directory inside 'data' directory and you want to have output in 'output' directory with 480x470 resolution you can use following command
  ```shell
  $ AdobeConnect2Video -i Course1 -d data -o output -r 480x470
  ```
  If there is any timing issue use ```--repair``` option to repair the video
  ```shell
  $ AdobeConnect2Video -i Course1 -d data -o output -r 480x470 --repair
  ```

  For more details:

  ```text
  $ AdobeConnect2Video -h
  usage: AdobeConnect2Video [-h] -i ID [-d DATA_PATH] [-o OUTPUT_PATH] [-r RESOLUTION]

  options:
    -h   --help          show this help message and exit
    -i   --id            the name of directory data is available
    -d   --data-path     the path extracted data must be available as directory
    -o   --output-path   the output path that generated data saved
    -r   --resolution    the resolution of output video
    -p   --repair    repair screen share video
  ```



  If you're interested in contributing to this project, first of all I would like to extend my heartfelt gratitude.

  Please feel free to reach out to me if you need help. My Email: AliRezaBeigyKhu@gmail.com
  Telegram: [@AliRezaBeigy](https://t.me/AliRezaBeigyKhu)



  MIT


pkgId: 653f5f4291a54deb6bd2d8885b4f9f1caffc0dc0f1888e318dcc69cebfb4b527
name: python-Adv2
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Adv2reader reads version 2 Astro Digital Video files.
url: https://github.com/bob-anderson-ok/adv2reader
rpm_license: License :: OSI Approved :: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Adv2-1.2.0-1.src.rpm
checksum_type: sha256
description:
  This package provides a 'reader' for .adv (AstroDigitalVideo) Version 2 files.
  It is the result of a collaborative effort involving Bob Anderson and Hristo Pavlov.
  The specification for Astro Digital Video files can be
  found at: <http://www.astrodigitalvideoformat.org/spec.html>
  To install this package on your system:
      pip install Adv2
  Then, sample usage from within your Python code is:
      from pathlib import Path
      from Adv2.Adv2File import Adv2reader
      try:
          
          file_path = str(Path('path/to/your/file.adv'))  # Python will make Windows version as needed
          
          rdr = Adv2reader(file_path)
      except AdvLibException as adverr:
          print(repr(adverr))
          exit()
      except IOError as ioerr:
          print(repr(ioerr))
          exit()
  Now that the file has been opened and a 'reader' (rdr) created for it,
  there are instance variables available that will be useful.
  Here is how to print some of those out (these give the image size and number of images in the file):
      print(f'Width: {rdr.Width}  Height: {rdr.Height}  NumMainFrames: {rdr.CountMainFrames}')
  There is also an composite instance variable called `FileInfo` which gives access to all
  of the values defined in the structure `AdvFileInfo` (there are 20 of them).
  For example:
      print(rdr.FileInfo.UtcTimestampAccuracyInNanoseconds)
  To get (and show) the file metadata (returned as a Dict[str, str]):
      print(f'\nADV_FILE_META_DATA:')
      meta_data = rdr.getAdvFileMetaData()
      for key in meta_data:
          print(f'    {key}: {meta_data[key]}')
  The main thing that one will want to do is read image data, timestamps, and frame status information
  from image frames.
  Continuing with the example and assuming that the adv file contains a MAIN stream (it
  might also contain a CALIBRATION stream):
      for frame in range(rdr.CountMainFrames):
          
          err, image, frameInfo, status = rdr.getMainImageAndStatusData(frameNumber=frame)
          
          if not err:
              
              
              if frameInfo.StartOfExposureTimestampString:
                  print(frameInfo.DateString, frameInfo.StartOfExposureTimestampString)
              print(f'\nframe: {frame} STATUS:')
              for entry in status:
                  print(f'    {entry}: {status[entry]}')
          else:
              print(err)
  `err` is a string that will be empty if image bytes and metadata where successfully extracted.
  In that case, `image` will contain a numpy array of uint16 values. If `err` is not empty, it will contain
  a human-readable description of the error encountered.
  The 'shape' of image will be `image[Height, Width]` for grayscale images. Color video
  files are not yet supported.
  Finally, the file should closed as in the example below:
      print(f'closeFile returned: {rdr.closeFile()}')
      rdr = None
  The value returned will be the version number (2) of the file closed or 0, which indicates an attempt to close a file that was
  already closed.


pkgId: 1ed09738df423c2d494c354d747a7afe2f3af9b2e9bc70fb3e822037f95a0517
name: python-AdvEMDpy
arch: src
version: 0.0.17
epoch: 0
release: 1
url: https://github.com/Cole-vJ/AdvEMDpy.git
rpm_license: cc-by-nc-4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdvEMDpy-0.0.17-1.src.rpm
checksum_type: sha256
summary:
  Advanced Empirical Mode Decomposition package with numerous extensions to various aspects of core algorithm.

description:
  AdvEMDpy is a Python library that performs Empirical Mode Decomposition with numerous algorithmic variations available at key stages of the core algorithm. This package was developed out of research performed by Cole van Jaarsveldt, Matthew Ames, Gareth W. Peters, and Mike Chantler.


pkgId: b45fc7daa2c9afe0927ab0dabbf06d1229fffd3bb6874bd404a20861ca23f0d8
name: python-AdvanceForCaesar
arch: src
version: 2.0.1
epoch: 0
release: 1
url: https://pypi.org/project/AdvanceForCaesar/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdvanceForCaesar-2.0.1-1.src.rpm
checksum_type: sha256
summary:
  An advanced Caesar cipher encryption tool that supports both encryption and decryption of text using a range of shift values.

description:
  This implementation includes features for handling non-alphabetic characters, providing multiple encryption modes, and ensuring the security and reversibility of the cipher process.



  We will be rolling out version 3.0.Version 3.0 will merge the first two versions



  To install AdvanceForCaesar, run:

      pip install AdvanceForCaesar



  ```python
  import AdvanceForCaesar


  AdvanceForCaesar      #package
  │- eshifts
  │- decrypt_once
  │- encrypt
  │- decrypt


pkgId: 6cca8243347b3e4cabbd55256b2101e57f04386ee14a396f882730c78733e644
name: python-Advanced-Py-Functions
arch: src
version: 0.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/Advanced-Py-Functions/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Advanced-Py-Functions-0.2-1.src.rpm
checksum_type: sha256
description:
  This is a Python package containing advanced functions for:

  - Custom sorting of dictionaries
  - Fibonacci sequence calculation using memoization
  - Palindrome checking
  - Matrix multiplication and inversion
  - Prime number generation using the Sieve of Eratosthenes



  ```bash
  pip install mypackage


pkgId: e990b24bc03502615785b986ed239ea83a17e782d2e2d324be1bbb7ea0f15f2a
name: python-AdvancedAnalytics
arch: src
version: 1.39
epoch: 0
release: 1
summary: Python support for 'The Art and Science of Data Analytics'
url: https://github.com/tandonneur/AdvancedAnalytics
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdvancedAnalytics-1.39-1.src.rpm
checksum_type: sha256
description:
  A collection of python modules, classes and methods for simplifying the use of machine learning solutions.  **AdvancedAnalytics** provides easy access to advanced tools in **Sci-Learn**, **NLTK** and other machine learning packages.  **AdvancedAnalytics** was developed to simplify learning python from the book *The Art and Science of Data Analytics*.


pkgId: 52a004b51f2507ce153d846f0d9b3fec89445bf2c2da766c14d960fa5b0233d8
name: python-AdvancedHTMLParser
arch: src
version: 9.0.2
epoch: 0
release: 1
url: https://github.com/kata198/AdvancedHTMLParser
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdvancedHTMLParser-9.0.2-1.src.rpm
checksum_type: sha256
summary:
  A Powerful HTML Parser/Scraper/Validator/Formatter that constructs a modifiable, searchable DOM tree, and includes many standard JS DOM functions (getElementsBy*, appendChild, etc) and additional methods

description:
  AdvancedHTMLParser is an Advanced HTML Parser, with support for adding, removing, modifying, and formatting HTML.
  It aims to provide the same interface as you would find in a compliant browser through javascript ( i.e. all the getElement methods, appendChild, etc), an XPath implementation, as well as many more complex and sophisticated features not available through a browser. And most importantly, it's in python!
  There are many potential applications, not limited to:
   * Webpage Scraping / Data Extraction
   * Testing and Validation
   * HTML Modification/Insertion
   * Outputting your website
   * Debugging
   * HTML Document generation
   * Web Crawling
   * Formatting HTML documents or web pages
  It is especially good for servlets/webpages. It is quick to take an expertly crafted page in raw HTML / css, and have your servlet's ingest with AdvancedHTMLParser and create/insert data elements into the existing view using a simple and well-known interface ( javascript-like + HTML DOM ).
  Another useful scenario is creating automated testing suites which can operate much more quickly and reliably (and at a deeper function-level), unlike in-browser testing suites.


pkgId: d57806e1eb263fce8347eaeaed6accce7829a570061f2f3985a5d11b781ff043
name: python-AdvancedHTTPServer
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: A standalone web server built on Python's BaseHTTPServer.
url: https://github.com/zeroSteiner/AdvancedHTTPServer
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdvancedHTTPServer-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Standalone web server built on Python’s BaseHTTPServer
  |Build Status| |Documentation Status| |Github Issues| |PyPi Release|


pkgId: 26c0ca036f9a2f75d436defc5162c3c354173bce91d1b8bfbd5f1679c823d254
name: python-AdvancedTagScriptEngine
arch: src
version: 3.2.2
epoch: 0
release: 1
summary: An easy drop in user-provided Templating system.
url: https://github.com/japandotorg/TagScriptEngine
rpm_license: Creative Commons Attribution 4.0 International License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdvancedTagScriptEngine-3.2.2-1.src.rpm
checksum_type: sha256
description:
  <a href="https://pypi.python.org/pypi/AdvancedTagscriptEngine/">
      <img src="https://img.shields.io/pypi/pyversions/AdvancedTagscriptEngine" alt="AdvancedTagScriptEngine" />
  </a>
  <a href="https://pypi.python.org/pypi/AdvancedTagscriptEngine/">
      <img src="https://img.shields.io/pypi/v/AdvancedTagScriptEngine" alt="PyPI - Version">
  </a>
  <a href="https://tagscriptengine.readthedocs.io/en/latest/?badge=latest">
      <img src="https://readthedocs.org/projects/tagscriptengine/badge/?version=latest" alt="Documentation Status" />
  </a>
  <a href="https://pypi.python.org/pypi/AdvancedTagscriptEngine/">
      <img src="https://img.shields.io/pypi/dm/AdvancedTagScriptEngine" alt="PyPI - Downloads" />

  </a>

  This repository is a fork of JonSnowbd's [TagScript](https://github.com/JonSnowbd/TagScript), a string templating language.
  This fork adds support for Discord object adapters and a couple Discord related blocks, as
  well as multiple utility blocks. Additionally, several tweaks have been made to the engine's
  behavior.

  This TagScriptEngine is used on [MELON, a Discord bot](https://melonbot.io/invite).
  An example implementation can be found in the [Tags cog](https://github.com/japandotorg/Seina-Cogs/tree/main/tags).

  Additional documentation on the TagScriptEngine library can be [found here](https://tagscriptengine.readthedocs.io/en/latest/).



  Download the latest version through pip:

  ```
  pip(3) install AdvancedTagScriptEngine
  ```

  Download from a commit:

  ```
  pip(3) install git+https://github.com/japandotorg/TagScriptEngine.git@<COMMIT_HASH>
  ```

  Install for editing/development:

  ```
  git clone https://github.com/japandotorg/TagScriptEngine.git
  pip(3) install -e ./TagScriptEngine
  ```



  AdvancedTagScriptEngine is a drop in easy to use string interpreter that lets you provide users with ways of
  customizing their profiles or chat rooms with interactive text.

  For example TagScript comes out of the box with a random block that would let users provide
  a template that produces a new result each time its ran, or assign math and variables for later
  use.



  `Python 3.8+`

  `pyparsing`

  `discord.py`

  `Red-DiscordBot` [optional]


pkgId: 601fbfd97e938dd47524389141064c7bb4db4d8508fae5252cf2d9459a654c71
name: python-AdvantitiousBush
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: A Python library for implementing the Advantitious Bush algorithm
url: https://github.com/senseiwhales/advantitious-bush
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AdvantitiousBush-1.0.6-1.src.rpm
checksum_type: sha256
description:
  Advantitious Bush is a Python library for implementing a machine learning algorithm based on the Advantitious Bush method.



  Email me at senseiwhales@gmail.com



  You can install Advantitious Bush via pip:

  ```bash
  pip install AdvantitiousBush


pkgId: cd689958f2b12973f8b2639884738f042e2e8a1028065422d34330492d58e8bb
name: python-AeroSandbox
arch: src
version: 4.2.6
epoch: 0
release: 1
url: https://peterdsharpe.github.io/AeroSandbox/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AeroSandbox-4.2.6-1.src.rpm
checksum_type: sha256
summary:
  AeroSandbox is a Python package that helps you design and optimize aircraft and other engineered systems.

description:
  Use AeroSandbox to design and optimize entire aircraft:
  <table>
      <tr>
          <td width="50%" valign="top">
              <p align="center">
                  <a href="https://github.com/peterdsharpe/Feather-RC-Glider"><i>Feather</i> (an ultra-lightweight 1-meter-class RC motor glider)</a>
              </p>
              <img src="https://raw.githubusercontent.com/peterdsharpe/Feather-RC-Glider/master/CAD/feather.png" alt="Feather first page">
          </td>
          <td width="50%" valign="top">
              <p align="center">
                  <a href="https://github.com/peterdsharpe/solar-seaplane-preliminary-sizing"><i>SEAWAY-Mini</i> (a solar-electric, 13' wingspan seaplane)</a>
              </p>
              <img src="https://raw.githubusercontent.com/peterdsharpe/solar-seaplane-preliminary-sizing/main/CAD/renders/seaway_mini_packet_Page_1.png" alt="Seaway-Mini first page">
          </td>
      </tr>
  </table>
  Use AeroSandbox to support real-world aircraft development programs, all the way from your very first sketch to your first-flight and beyond:
  <table>
      <tr>
          <td width="50%" valign="top">
              <p align="center">
                  <a href="https://github.com/peterdsharpe/DawnDesignTool">Initial concept sketches + sizing of <i>Dawn</i> (a solar-electric airplane for climate science research) in AeroSandbox, Spring 2020</a>
              </p>
              <img src="./media/images/dawn1-first-sketch.png" alt="Dawn initial design">
          </td>
          <td width="50%" valign="top">
              <p align="center">
                  <a href="https://youtu.be/CyTzx9UCvyo"><i>Dawn</i> (later renamed <i>SACOS</i>) in first flight, Fall 2022</a>
              </p>
              <p align="center"><a href="https://www.electra.aero/news/sacos-first-flight">(A massive build effort with excellent engineering and coordination by Electra.aero!)</a></p>
              <img src="./media/images/SACOS%20First%20Flight%20Zoomed.jpg" alt="SACOS first flight">
          </td>
      </tr>
  </table>
  Use AeroSandbox to explore counterintuitive, complicated design tradeoffs, all at the earliest stages of conceptual design *where these insights make the most difference*:
  <table>
  	<tr>
  		<td width="33%" valign="top">
  			<p align="center">
  				<a href="https://github.com/peterdsharpe/DawnDesignTool">Exploring how big a solar airplane needs to be to fly, as a function of seasonality and latitude</a>
  			</p>
  			<img src="https://github.com/peterdsharpe/DawnDesignTool/raw/master/docs/30kg_payload.svg" alt="Dawn seasonality latitude tradespace">
  		</td>
  		<td width="33%" valign="top">
  			<p align="center">
  				<a href="https://www.popularmechanics.com/military/aviation/a13938789/mit-developing-mach-08-rocket-drone-for-the-air-force/">Exploring how the mission range of <i>Firefly</i>, a Mach 0.8 rocket drone, changes if we add an altitude limit, simultaneously optimizing aircraft design and trajectories</a>
  			</p>
  			<img src="./media/images/firefly-range-ceiling-trade.png" alt="Firefly range ceiling trade">
  		</td>
  		<td width="33%" valign="top">
  			<p align="center">
  				<a href="https://github.com/peterdsharpe/transport-aircraft">Exploring how many LH2 aircraft classes an airline fleet needs to cover the market, considering off-design performance</a>
  			</p>
  			<img src="https://github.com/peterdsharpe/transport-aircraft/raw/master/figures/lh2_market_segmentation_2.svg" alt="LH2 Market Coverage">
  		</td>
  	</tr>
  </table>
  Use AeroSandbox as a pure aerodynamics toolkit:
  <table>
  	<tr>
  		<td width="33%" valign="top">
  			<p align="center">
  				<a href="https://github.com/peterdsharpe/AeroSandbox/blob/master/tutorial/06%20-%20Aerodynamics/01%20-%20AeroSandbox%203D%20Aerodynamics%20Tools/01%20-%20Vortex%20Lattice%20Method/01%20-%20Vortex%20Lattice%20Method.ipynb">VLM simulation of a glider, aileron deflections of +-30°</a>
  			</p>
  			<img src="./media/images/vlm3_with_control_surfaces.png" alt="VLM simulation">
  		</td>
  		<td width="33%" valign="top">
  			<p align="center">
  				<a href="https://github.com/peterdsharpe/AeroSandbox/blob/master/tutorial/06%20-%20Aerodynamics/01%20-%20AeroSandbox%203D%20Aerodynamics%20Tools/01%20-%20Vortex%20Lattice%20Method/01%20-%20Vortex%20Lattice%20Method.ipynb">Aerodynamic shape optimization of a wing planform, using an arbitrary objective and constraints</a>
  			</p>
  			<img src="./media/images/wing_optimization.png" alt="Wing optimization">
  		</td>
  		<td width="33%" valign="top">
  			<p align="center">
  				<a href="https://github.com/peterdsharpe/AeroSandbox/blob/master/tutorial/06%20-%20Aerodynamics/02%20-%20AeroSandbox%202D%20Aerodynamics%20Tools/02%20-%20NeuralFoil%20Optimization.ipynb">Optimize airfoil shapes with aerodynamic, structural, and manufacturing considerations</a>
  			</p>
  			<img src="./media/images/airfoil_optimization.png" alt="Airfoil optimization">
  		</td>
  	</tr>
  </table>
  Among many other discplines:
  <table>
  	<tr>
  		<td width="50%" valign="top">
  			<p align="center">
  				Structural optimization of a composite tube spar
  			</p>
  			<img src="./media/images/beam-optimization.png" alt="Beam optimization">
  		</td>
  		<td width="50%" valign="top">
  			<p align="center">
  				<a href="https://github.com/peterdsharpe/AeroSandbox/blob/master/aerosandbox/library/propulsion_electric.py">Electric motor analysis for propeller matching</a>
  			</p>
  			<img src="./media/images/motor_perf.png" alt="Motor performance">
  		</td>
  	</tr>
  	<tr>
  		<td>
  			<p align="center" valign="top">
  				<a href="https://github.com/peterdsharpe/transport-aircraft">Tools to analyze unconventional propulsion (e.g., LH2)</a>
  			</p>
  			<img src="https://github.com/peterdsharpe/transport-aircraft/raw/master/figures/three_view_annotated.svg" alt="LH2 airplane three-view">
  		</td>
  		<td>
  			<p align="center" valign="top">
  				<a href="https://github.com/peterdsharpe/AeroSandbox/tree/master/aerosandbox/library/weights">Detailed weights estimation for aircraft ranging from micro-UAVs to airliners</a>
  			</p>
  			<img src="https://github.com/peterdsharpe/transport-aircraft/raw/master/figures/mass_budget.png" alt="Mass Budget">
  		</td>
  </tr>
  </table>
  Easily interface AeroSandbox with all your favorite tools:
  <table>
      <tr>
          <td width="33%" valign="top">
              <p align="center">
                  Other conceptual design tools (AVL, XFLR5, XFoil, ASWING, MSES, etc.)
              </p>
              <img src="./media/images/airfoil_contours.png" alt="XFoil">
          </td>
            <td width="33%" valign="top">
                  <p align="center">
                      CAD tools via STEP export (SolidWorks, Fusion 360, etc.)
                  </p>
  				<p align="center">
  				(STL, OBJ, etc. supported too)
  				</p>
                  <img src="https://github.com/peterdsharpe/solar-seaplane-preliminary-sizing/raw/main/CAD/renders/raytrace-lowres.jpg" alt="CAD">
              </td>
            <td width="33%" valign="top">
  			<p align="center">
  				User-provided models + code (for custom aerodynamics, structures, propulsion, or anything else - e.g., for optimizing flight through a probabilistic wind field, shown below)
  			</p>
  			<img src="./media/images/wind_speeds_model.png" alt="Wind speed">
  		</td>
  	</tr>
  </table>
  Or, throw all the airplane-design-specific code out entirely, and use AeroSandbox purely as an optimization solver or as a solver for nonlinear systems of equations (or ODEs, or PDEs):
  <table>
  	<tr>
  		<td width="50%" valign="top">
  			<p align="center">
  				<a href="https://github.com/peterdsharpe/AeroSandbox/blob/develop/tutorial/01%20-%20Optimization%20and%20Math/01%20-%202D%20Rosenbrock.ipynb">Optimize the 2D Rosenbrock function</a>
  			</p>
  			<img src="./media/images/optimization.png" alt="Optimization">
  		</td>
  		<td width="50%" valign="top">
  			<p align="center">
  				<a href="https://github.com/peterdsharpe/AeroSandbox/tree/develop/tutorial/03%20-%20Trajectory%20Optimization%20and%20Optimal%20Control/01%20-%20Solving%20ODEs%20with%20AeroSandbox">Specify the Falkner Skan ODE (nonlinear, 3rd-order BVP) and let AeroSandbox automatically take care of the discretization, solution, and even inverse solving.</a>
  			</p>
  			<img src="./media/images/falkner-skan.png" alt="FS ODE">
  		</td>
  </tr>
  </table>
  And much, much more. Best of all, combine these tools arbitrarily without any loss in optimization speed and without any tedious derivative math, all thanks to AeroSandbox's end-to-end automatic-differentiability.


  In short:
  * `pip install aerosandbox[full]` for a complete install.
  * `pip install aerosandbox` for a lightweight (headless) installation with minimal dependencies. All optimization, numerics, and physics models are included, but optional visualization dependencies are skipped.
  For more installation details (e.g., if you're new to Python), [see here](./INSTALLATION.md).

  To get started, [check out the tutorials folder here](./tutorial/)! All tutorials are viewable in-browser, or you can open them as Jupyter notebooks by cloning this repository.
  For a more detailed and theory-heavy introduction to AeroSandbox, [please see this thesis](./tutorial/sharpe-pds-sm-AeroAstro-2021-thesis.pdf).
  For a yet-more-detailed developer-level description of AeroSandbox modules, [please see the developer README](aerosandbox/README.md).
  For fully-detailed API documentation, see [the documentation website](https://aerosandbox.readthedocs.io/en/master/).
  You can print documentation and examples for any AeroSandbox object by using the built-in `help()` function (e.g., `help(asb.Airplane)`). AeroSandbox code is also documented *extensively* in the source and contains hundreds of unit test examples, so examining the source code can also be useful.


  One final point to note: **all inputs and outputs to AeroSandbox are expressed in base SI units, or derived units thereof** (e.g., m, kg, sec, N, m/s, J, Pa). Since this unit system is [coherent](https://en.wikipedia.org/wiki/Coherence_(units_of_measurement)), an [enormous number of quantities](https://en.wikipedia.org/wiki/SI_derived_unit) can be converted without any scaling factors. This improves readability and reduces the likelihood of errors.
  There are only two exceptions to this SI-everywhere rule:
  1. If alternate units are noted in a variable name's suffix. For example:
     * `battery_capacity` → Joules
     * `battery_capacity_watt_hours` → Watt-hours
     * `aircraft_endurance` → Seconds
     * `aircraft_endurance_hours` → Hours
  2. Angle of attack (`alpha`, α) and sideslip angle (`beta`, β) are given in degrees due to long-standing aerospace convention. All other angles and angular rates use radians.
  Also, in case of any confusion on the units of a function's inputs and outputs, units are listed on all function docstrings.
  If you wish to use other units, consider using [`aerosandbox.tools.units`](./aerosandbox/tools/units.py) to convert easily.


  Please feel free to join the development of AeroSandbox - contributions are always so welcome! If you have a change you'd like to make, the easiest way to do that is by submitting a pull request.
  The text file [`CONTRIBUTING.md`](./CONTRIBUTING.md) has more details for developers and power users.
  If you've already made several additions and would like to be involved in a more long-term capacity, please message me!
  Contact information can be found next to my name near the top of this README.

  If you like this software, please consider donating to support development [via PayPal](https://paypal.me/peterdsharpe)
  or [GitHub Sponsors](https://github.com/sponsors/peterdsharpe/)! Proceeds will go towards more coffee for the grad students.

  Please, please report all bugs by [creating a new issue](https://github.com/peterdsharpe/AeroSandbox/issues)!

  AeroSandbox loosely uses [semantic versioning](https://semver.org/), which should give you an idea of whether or not you can probably expect backward-compatibility and/or new features from any given update.
  For more details, see the [changelog](./CHANGELOG.md).

  If you find AeroSandbox useful in a research publication, please cite it using the following BibTeX snippet:
  ```bibtex
  @mastersthesis{aerosandbox,
      title = {AeroSandbox: A Differentiable Framework for Aircraft Design Optimization},
      author = {Sharpe, Peter D.},
      school = {Massachusetts Institute of Technology},
      year = {2021}
  }
  ```
  Commercial users: I'm more than happy to discuss consulting work for active AeroSandbox support if this package proves helpful - use the email address in the header of this README to get in touch.

  [MIT License applies, full terms here](LICENSE.txt). In short: use AeroSandbox for anything you want (commercial or non-commercial). AeroSandbox is released in hope that it will be useful but without any warranty of merchantability (either express or implied).
  If you use AeroSandbox, attribution is appreciated.

  [![Stargazers over time](https://starchart.cc/peterdsharpe/AeroSandbox.svg)](https://starchart.cc/peterdsharpe/AeroSandbox)


pkgId: b8b7b8e92c65e3ce70bb65bdab67bc83cba97f6fdb25745c91d2de1677cbf3b2
name: python-AeroViz
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Aerosol science
url: https://github.com/Alex870521/AeroViz
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AeroViz-0.1.11-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  ![Python](https://img.shields.io/pypi/pyversions/aeroviz?logo=python)
  ![PyPI](https://img.shields.io/pypi/v/aeroviz?logo=pypi)
  ![Pytest](https://img.shields.io/github/actions/workflow/status/Alex870521/aeroviz/pytest.yml?logo=pytest&label=pytest)
  ![GitHub last commit](https://img.shields.io/github/last-commit/Alex870521/aeroviz?logo=github)

  </div>

  <div align="center">

  <a href="https://github.com/Alex870521"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-github.png?raw=true" width="3%" alt="Alex870521 GitHub"></a>
  <img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-transparent.png?raw=true" width="3%">
  <a href="https://www.linkedin.com/in/Alex870521/"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-linkedin.png?raw=true" width="3%" alt="Alex870521 LinkedIn"></a>
  <img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-transparent.png?raw=true" width="3%">
  <a href="https://medium.com/@alex870521"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-medium.png?raw=true" width="3%" alt="Alex870521 Medium"></a>
  </div>


  ```bash
  pip install AeroViz
  ```





  Built-in `RawDataReader` supporting multiple aerosol instruments:
  - **Particle Sizers**: SMPS, APS, GRIMM, OPC
  - **Mass & Optical**: TEOM, NEPH, Aurora, AE33/43, BC1054
  - **Chemical Analysis**: OCEC, IGAC, XRF, VOC

  > Features include quality control, data filtering, flexible resampling, and CSV export. For detailed instrument support
  > and usage, check our [RawDataReader Guide](docs/guide/RawDataReader.md).



  Built-in `DataProcess` provides advanced aerosol analysis:
  - **Size Distribution**: Mode Fitting, Log-Normal Analysis
  - **Optical Properties**: Mie Theory, SOAP Calculation
  - **Chemical**: Mass Closure, Source Apportionment
  - **VOC**: OFP, SOAP



  Comprehensive visualization tools `plot`:
  - **Time Analysis**: Trends, Diurnal Patterns
  - **Statistical**: Distributions, Correlations
  - **Specialized**: Size Contours, Wind Rose, Polar Plots, Hysplit, CBPF

  > **Note:** We are continuously adding support for more instruments and features. Contributions are welcome!



  ```python
  from datetime import datetime
  from pathlib import Path
  from AeroViz import RawDataReader, DataProcess, plot


  data = RawDataReader('NEPH', Path('/path/to/data'), start=datetime(2024, 2, 1), end=datetime(2024, 4, 30))


  plot.timeseries(data, y='scattering_coefficient')
  ```

  For more detailed usage instructions, please refer to our [User Guide](docs/guide).



  For detailed documentation, please refer to the `docs` folder, which includes:

  <div align="center">

  | Documentation                  | Description              |
  |--------------------------------|--------------------------|
  | [User Guide](docs/guide)       | Basic usage instructions |
  | [Changelog](docs/CHANGELOG.md) | List of changes          |
  </div>


  For bug reports and feature requests please visit [GitHub Issues](https://github.com/Alex870521/DataPlot/issues).

  <div align="center">

  <a href="https://github.com/Alex870521"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-github.png?raw=true" width="3%" alt="Alex870521 GitHub"></a>
  <img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-transparent.png?raw=true" width="3%">
  <a href="https://www.linkedin.com/in/Alex870521/"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-linkedin.png?raw=true" width="3%" alt="Alex870521 LinkedIn"></a>
  <img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-transparent.png?raw=true" width="3%">
  <a href="https://medium.com/@alex870521"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-medium.png?raw=true" width="3%" alt="Alex870521 Medium"></a>
  </div>


pkgId: 39d47db84e422e3666cb245e32a86e441f1f0fade6b8aa270c0b36ef9d8f233b
name: python-AeroViz
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: Aerosol science
url: https://github.com/Alex870521/AeroViz
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AeroViz-0.1.12-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  ![Python](https://img.shields.io/pypi/pyversions/aeroviz?logo=python)
  ![PyPI](https://img.shields.io/pypi/v/aeroviz?logo=pypi)
  ![Pytest](https://img.shields.io/github/actions/workflow/status/Alex870521/aeroviz/pytest.yml?logo=pytest&label=pytest)
  ![GitHub last commit](https://img.shields.io/github/last-commit/Alex870521/aeroviz?logo=github)

  </div>

  <div align="center">

  <a href="https://github.com/Alex870521"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-github.png?raw=true" width="3%" alt="Alex870521 GitHub"></a>
  <img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-transparent.png?raw=true" width="3%">
  <a href="https://www.linkedin.com/in/Alex870521/"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-linkedin.png?raw=true" width="3%" alt="Alex870521 LinkedIn"></a>
  <img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-transparent.png?raw=true" width="3%">
  <a href="https://medium.com/@alex870521"><img src="https://github.com/Alex870521/AeroViz/blob/main/assets/media/logo-social-medium.png?raw=true" width="3%" alt="Alex870521 Medium"></a>
  </div>


  ```bash
  pip install AeroViz
  ```





  Built-in `RawDataReader` supporting multiple aerosol instruments:
  - **Particle Sizers**: SMPS, APS, GRIMM, OPC
  - **Mass & Optical**: TEOM, NEPH, Aurora, AE33/43, BC1054
  - **Chemical Analysis**: OCEC, IGAC, XRF, VOC

  > Features include quality control, data filtering, flexible resampling, and CSV export. For detailed instrument support
  > and usage, check our [RawDataReader Guide](docs/guide/RawDataReader.md).



  Built-in `DataProcess` provides advanced aerosol analysis:
  - **Size Distribution**: Mode Fitting, Log-Normal Analysis
  - **Optical Properties**: Mie Theory, SOAP Calculation
  - **Chemical**: Mass Closure, Source Apportionment
  - **VOC**: OFP, SOAP



  Comprehensive visualization tools `plot`:
  - **Time Analysis**: Trends, Diurnal Patterns
  - **Statistical**: Distributions, Correlations
  - **Specialized**: Size Contours, Wind Rose, Polar Plots, Hysplit, CBPF

  > **Note:** We are continuously adding support for more instruments and features. Contributions are welcome!



  ```python
  from datetime import datetime
  from pathlib import Path
  from AeroViz import RawDataReader, DataProcess, plot


  data = RawDataReader(
      'NEPH',
      Path('/path/to/data'),
      start=datetime(2024, 2, 1),
      end=datetime(2024, 4, 30)
  )
  ```

  ```pycon
  > Concole output
  ╔════════════════════════════════════════════════════════════════════════════════╗
  ║     Reading NEPH RAW DATA from 2024-02-01 00:00:00 to 2024-04-30 23:59:59      ║
  ╚════════════════════════════════════════════════════════════════════════════════╝
  ▶ Reading NEPH files ━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:00 file_name.dat
  		▶ Scatter Coe. (550 nm)
  			├─ Sample Rate    :   100.0%
  			├─ Valid  Rate    :   100.0%
  			└─ Total  Rate    :   100.0%
  ```

  For more detailed usage instructions, please refer to our [User Guide](docs/guide).



  For detailed documentation, please refer to the `docs` folder, which includes:

  <div align="center">

  | Documentation                  | Description              |
  |--------------------------------|--------------------------|
  | [User Guide](docs/guide)       | Basic usage instructions |
  | [Changelog](docs/CHANGELOG.md) | List of changes          |
  </div>


  For bug reports and feature requests please visit [GitHub Issues](https://github.com/Alex870521/DataPlot/issues).


pkgId: 04414f7375db24b11cca35a9301b66e3d49bf958f2f22bef45db2a0264b5cf5d
name: python-Affirmations
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Randomly adds affirming print statements to functions.
url: https://github.com/TimNicholsonShaw/affirmation
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Affirmations-0.0.10-1.src.rpm
checksum_type: sha256
description:
  A module that gives you a little bump of encouragement.


  - A positive attitude
  - A can-do spirit



  ```bash
  pip install Affirmations
  ```



  Decorate any function to get a random affirmation printed to stdout every time that function is run

  ```
  from Affirmations import affirm

  @affirm() # prints an affirmation to stdout 100% of the time this function is run
  def hello_world():
      print("hello")

  @affirm(0.2) # prints an affirmation to stdout 20% of the time this function is run
  def hello_world2():
      print("hello")

  hello_world()
  ```
  ```bash
  hello
  You are awesome!
  ```


pkgId: 926ebf6a9a6302f26452cde0001818f4acca4b8463b9e1e1d24ed21b60426eeb
name: python-AfroTranslate
arch: src
version: 0.0.6
epoch: 0
release: 1
url: https://github.com/hgilles06/AfroTranslate
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AfroTranslate-0.0.6-1.src.rpm
checksum_type: sha256
summary:
  This package allows you to obtain translations from Masakhane JoeyNMT based models. Masakhane is a grassroots research community aiming to revive and strengthen African languages through AI.

description:
  This package allows you to obtain translations from Masakhane JoeyNMT based models with very few lines of code. Masakhane is a grassroots research community aiming to revive and strengthen African languages through AI.

  Available models can be found [here](https://github.com/masakhane-io/masakhane-mt/tree/master/benchmarks).

  Note: Please, install the cuda supported version of pytorch to use the GPU. Ex: pip install torch==1.8.0+cu111 -f https://download.pytorch.org/whl/torch_stable.html.


  Here are some useful links:

  [Masakhane](https://www.masakhane.io/): Visit the Masakhane home page.

  [Masakhane web](http://translate.masakhane.io/): Get translations using the Masakhane web application.

  [Masakhane Github](https://github.com/masakhane-io): Take a look at the community main projects here!

  [JoeyNMT Github](https://github.com/joeynmt/joeynmt): Get hands on JoeyNMT here!




  pip install AfroTranslate





  ```
  from afrotranslate import MasakhaneTranslate

  translator = MasakhaneTranslate(model_name="en-fon")

  translator.translate("I love you so much!", n_best=1)

  'Un yí wǎn nú we tawun'
  ```



  ```
  translator = MasakhaneTranslate(model_path="<directory-where-your-model-resides>")
  ```



  The models are trained on individual sentences, so we automatically detect sentence boundaries in inputs and translate them separately. The output shows alternatives for each of them.

  ```
  translator.translate("I love you so much! Our love is very strong!", n_best=1)

  {'Sentence1': 'Un yí wǎn nú we tawun',
   'Sentence2': 'Wanyiyi mǐtɔn ɖò taji tawun'}
  ```



  This is a community research project and as such, this service is not a production system. The models are only trained using religious data. Therefore, it should not be used for official translations.



  I want to thank [Julia Kreutzer](https://scholar.google.de/citations?user=j4cOSzAAAAAJ&hl=en) for her precious feedback on this work.


pkgId: a7bde9cf9eafc0dfcf59b7ef924dcbc5747063f80627546220e6479f27238113
name: python-AgeXtend
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Discovering geroprotectors through the explainable artificial intelligence-based platform AgeXtend
url: https://pypi.org/project/AgeXtend/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AgeXtend-0.0.2-1.src.rpm
checksum_type: sha256
description:
  ![Overview](https://raw.githubusercontent.com/the-ahuja-lab/AgeXtend/main/Images/Overview.png)

  **AgeXtend** is a multimodal, bioactivity-based, and mechanism-backed Explainable AI Predictor for geroprotectors. AgeXtend supports 2 distinct work packages: Predictor and Browser.
  The first work package, **Predictor**, involves a bioactivity-based classifier for predicting geroprotective compounds, coupled with an **explainability** module providing mechanistic insights into biological processes behind the predictions, a **toxicity** module to evaluate their toxicity in the biological context, and finally, a **target** module that suggests protein targets of the putative geroprotective compounds.
  The second work package, **Browser**, allows the user to explore through the 20 pre-screened databases specifically curated for these functionalities.



  **AgeXtend is free for academic institutions, however, for commercial utilization a commercial license key is required. Users (academic/commercial) may apply for a valid "License Key" [here](https://forms.gle/y1sCpSGEAML8XWGGA).**

  You can also generate your own predictions using AgeXtend’s [Colab notebook](https://colab.research.google.com/drive/1yS70GuI4H29KICQlLDQHLDk3nyULWJ94)



  **Major dependencies**
  1. [Signaturizer (v1.1.11)](https://gitlabsbnb.irbbarcelona.org/packages/signaturizer)
  2. [RDKit (v2022.3.1)](https://www.rdkit.org/)

  **Minor dependencies**
  1. os
  2. [scikit-learn (v1.2.1)](https://scikit-learn.org/stable/whats_new/v1.0.html)
  3. [xgboost (v1.5.1)](https://github.com/dmlc/xgboost)
  4. [pandas (v1.4.3)](https://pandas.pydata.org/)
  5. [numpy (v>=1.20.3)](https://numpy.org)
  6. [tqdm](https://tqdm.github.io)
  7. [joblib (v1.1.1)](https://pypi.org/project/joblib/)
  8. [matplotlib (v>=3.2.2)](https://pypi.org/project/matplotlib/)
  9. [seaborn (v0.11.2)](https://seaborn.pydata.org/)
  10. [importlib ](https://pypi.org/project/importlib/)
  11. [importlib-resources (v5.7.1)](https://github.com/python/importlib_resources)


  **Quick setup**

  The file [requirement.txt](https://github.com/the-ahuja-lab/AgeXtend/blob/main/env/requirement.txt) will be used for the environment setup and by running the following command.
  ```
  $ pip install -r requirement.txt
  ```





  ```
  $ pip install -i https://pypi.org/simple/AgeXtend
  ```


  To apply for the license [click here](https://forms.gle/y1sCpSGEAML8XWGGA)

  ```
  >>> from AgeXtend import Predictor
  ```
  Activate AgeXtend license
  ```
  >>> Predictor.license('license key') #Example: Predictor.license('KKKVFZ41111WF6RTQ')
  ```


  AgeXtend supports 2 distinct work packages:<br/>
  1. Predictor
  2. Browser





  Predicts the anti-aging potential for the input SMILES:<br/>
  ```
  >>> from AgeXtend import Predictor
  ```
  Prepare a list of canonical SMILES (Open Babel generated) strings
  ```
  >>> smiles = ['ClCC=C', 'C=CCOC(=O)CC(C)C']
  ```
  Create an AgeXtend type object to featurize the query compounds (i.e. list of canonical SMILES)
  ```
  >>> agex_obj = Predictor.featurize(smiles)
  ```
  Use the AgeXtend object for predictions
  ```
  >>> output = Predictor.predict(agex_obj)
  ```
  Get the list of resulting data frames that are part of the rest of the modules
  ```
  >>> output.keys()
  dict_keys(['Anti_Aging_Prediction', 'Explainability_Status', 'Explainability_Probabilities'])
  ```
  **Note:** Explainability_Probabilities will be empty by default unless selected otherwise by supplying additional arguments.

  Get the result of a specific output data frame
  ```
  >>> output['Explainability_Status']
  ```



  **AgeXtend** also supports the following modules along with the Prediction and Explainability modules, which can be chosen using the boolean option (True)

  | Parameter Name | Description | Type | Default value | **Output (If True)** |
  | -------- | -------- | -------- | -------- | -------- |
  | probs | Probabilities of Explainability and/or Toxicity Module | boolean  | False | Explainability_Probabilities / Explainability_Toxicity_Probabilities |
  | HC | Run Toxicity Module (Health Check) | boolean  | False | Explainability_Toxicity_Status |
  | TS | Sub Explainability Level Tanimoto Similarity Test | boolean  | False | Explainability_response |
  | BDL | BindingDB Target Information and Druggability (Lipinski Rule) | boolean  | False | Druggability_and_Potential_Targets |


  **Example**
  ```
  >>> output = Predictor.predict(agex_obj, TS=True)
  >>> output.keys()
  dict_keys(['Anti_Aging_Prediction', 'Explainability_Status', 'Explainability_Probabilities', 'Explainability_response'])
  >>> output = Predictor.predict(agex_obj, HC=True, BDL=True)
  >>> output.keys()
  dict_keys(['Anti_Aging_Prediction', 'Explainability_Toxicity_Status', 'Explainability_Toxicity_Probabilities', 'Druggability_and_Potential_Targets'])
  ```


  Predictor module also provides functionalities for efficient bulk data prediction
  ```
  >>> Predictor.bulk_predict(input=smiles_list)
  ```
  Or user can also use pre-calculated AgeXtend type object as input
  ```
  >>> agex_obj = Predictor.featurize(smiles_list)
  >>> Predictor.bulk_predict(input=agex_obj)
  ```



  | Parameter Name | Description | Type | Default value |
  | -------- | -------- | -------- | -------- |
  | outfolder | Output Database type folder name | string | AgeXtendDB |
  | chunksize | Number of predictions input per iteration for faster job completion | Integer | 10000 |

  **Note**
  The output folder of Bulk prediction function can be used as a Custom database for input in AgeXtend Browser module





  To explore the AgeXtend pre-complied predictions of various databases:<br/>
  ```
  >>> from AgeXtend import Browser
  ```
  Use Open Babel to Generate Canonical SMILES format of the query compound as input
  ```
  >>> Browser.search(query='OC(=O)CCCc1c[nH]c2c1cccc2', output='/path/to/output/folder/')
  ```

  Unzip the **AgeXtendBrowserOut.zip** file to visualize/print the generated report (HTML format)

  **Note:** the **report file** (AgeXtend_BrowserOut.html) must be in the same folder with the **images** folder



  **AgeXtend** also supports the use of locally complied Predictor module outputs (Folder containing CSV format outputs)

  | Parameter Name | Description | Default Database |
  | -------- | -------- | -------- |
  | path | Path to the AgeXtend pre-complied prediction database | gutMGene |

  **Example**
  ```
  >>> Browser.search(path='/path/to/Database/Folder/', query='OC(=O)CCCc1c[nH]c2c1cccc2', output='/path/to/output/folder/')
  ```


  | DB Name | DB version | FTP size | FTP link |
  | -------- | -------- | -------- | -------- |
  | FOODB | Pre-release 1.0 | 63M | [http://agextend.ahujalab.iiitd.edu.in:8080/FOODB/](http://agextend.ahujalab.iiitd.edu.in:8080/FOODB/) |
  | HMDB | v5.0 | 231M | [http://agextend.ahujalab.iiitd.edu.in:8080/HMDB/](http://agextend.ahujalab.iiitd.edu.in:8080/HMDB/) |
  | IMPPAT | v2.0 | 4K | [http://agextend.ahujalab.iiitd.edu.in:8080/IMPPAT/](http://agextend.ahujalab.iiitd.edu.in:8080/IMPPAT/) |
  | AfroDB | - | 756K | [http://agextend.ahujalab.iiitd.edu.in:8080/AfroDB/](http://agextend.ahujalab.iiitd.edu.in:8080/AfroDB/) |
  | AgingAtlas | v1.0 | 748K | [http://agextend.ahujalab.iiitd.edu.in:8080/AgingAtlas/](http://agextend.ahujalab.iiitd.edu.in:8080/AgingAtlas/) |
  | Chembridge | - | 788K | [http://agextend.ahujalab.iiitd.edu.in:8080/Chembridge/](http://agextend.ahujalab.iiitd.edu.in:8080/Chembridge/) |
  | ChemdivBBlocks | - | 39M | [http://agextend.ahujalab.iiitd.edu.in:8080/ChemdivBBlocks/](http://agextend.ahujalab.iiitd.edu.in:8080/ChemdivBBlocks/) |
  | CMNPD | v1.0 | 20M | [http://agextend.ahujalab.iiitd.edu.in:8080/CMNPD/](http://agextend.ahujalab.iiitd.edu.in:8080/CMNPD/) |
  | DDPD | - | 4K | [http://agextend.ahujalab.iiitd.edu.in:8080/DDPD/](http://agextend.ahujalab.iiitd.edu.in:8080/DDPD/) |
  | ECMDB | v2.0 | 4K | [http://agextend.ahujalab.iiitd.edu.in:8080/ECMDB/](http://agextend.ahujalab.iiitd.edu.in:8080/ECMDB/) |
  | RepoHub | release-3/24/2020 | 3.9M | [http://agextend.ahujalab.iiitd.edu.in:8080/RepoHub/](http://agextend.ahujalab.iiitd.edu.in:8080/RepoHub/) |


pkgId: 7bcb03c5507afc663de6e1f30b024a7a74e009b1fe50b122a9f5fe9d704f609b
name: python-AgenciBr
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Package to work with data from brazilian agenci
url: https://pypi.org/project/AgenciBr/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AgenciBr-0.1.8-1.src.rpm
checksum_type: sha256
description:
  > The objective is create a package that help to usa data of **Agencia Nacional de Águas (ANA)**, **Instituto Nacional de Meteorologia (INEMET)**, **Merge**, **Brazilian Daily Weather Gridded Data (BR-DWGD)** and **Instituto de Hidrología, Meteorología y Estudios Ambientales (IDEAM)**. All the data above is from Brazil, minus the **IDEAM** that is from Colombia.

   - **ANA** [https://www.gov.br/ana/pt-br] or [https://www.snirh.gov.br/hidroweb/apresentacao]
   - **INEMET** [https://portal.inmet.gov.br]
   - **MERGE** [http://ftp.cptec.inpe.br/modelos/tempo/MERGE/GPM/DAILY/]
   - **BR-DWGD** [https://github.com/AlexandreCandidoXavier/BR-DWGD]
   - **IDEAM** [http://www.ideam.gov.co]

  **Usage**
  > pip install AgenciBr

  In python:

  **Import Ana**
  ```python
  from AgenciBr import Ana.Ana
  data = Ana.Ana('path file')

  """ Properties """
  data.dataset # return the dataset

  data.code #Return the

  data.startdate #return the first date from dataset

  data.enddate  #return the end date from dataset

  data.len #return the length from dataset

  data.type_data #return the data informations (precipitation, temperature, t_maxmin, wind, ...)

  data.type #return if data is original, format1, format2 ...
  ```

  **Import Inemet**

  ```python
  from AgenciBr import Inemet

  data = Inemet.Inemet('path file')
  ```

     **Import Merge**
   ```python
   from AgenciBr import Merge

  data = Merge.Merge('path file')
   ```

   **Import Alexandre**
   ```python
   from AgenciBr import Alexandre

  data = Alexandre.Alexandre('path file')
   ```

  **Import Ideam**

  ```python
  from AgenciBr import Ideam

  data = Ideam.Ideam('path file')
  ```

  **Suported functions**

  |Agenci| Precipitacion | vazão | Temperature(mean) | Temperature (minimun, maximum)|
  |------|---------------|-------|-------------------|-------------------------------|
  | Ana  | [x]           |[ ]    |      [ ]          |            [ ]                |
  |Inemet|      [x]      |       |      [x]          |                               |
  |Merge |   [ ]         | [ ]   |      [ ]          |            [ ]                |
  |Alexandre|  [ ]       |  [ ]  |       [ ]         |     [ ]                       |
  | Ideam|  [ ]          | [ ]   |        [ ]        |        [ ]                    |


  From internal function we construct function1, functon2







  We work with distints data and dataframe models, bacause this, was create the function format1 in each agenci.
  This function have three param:
  - **Comma_to_dot**: change the comma of all file to dot and to float number
  - **grow**: Change the dataframe from de lower to larger
  - **years**: is a vector of two numbers (year1, year2) that you wish be the start and end, the year can be the future

  **The principal objective of this function is**
  1) put date that can be jumped
  2) organize the file from to smaler to larger based in time
  3) Change the ',' to '.'
  4) Remove same values from file
  5) Change the name of time variable to time
  6) padronize a file to work with Ana, Inemet, Merge and etc
  7) have option to select a series of year start and year end. The date that not exist, are created and set NaN

  **The outfile have format precipitation**
  ```python
                           time        pr
                          1997-07-01  0.1
                          1997-07-02  0.3
                          ....
                          ...
                          ...
                          2020-01-01  0.3
                          2020-01-02  0.0

  ```
  **The outfile have format temperature**
  ```python
                                  time   max   min
                      0     1961-01-01   NaN   NaN
                      1     1961-01-02   NaN   NaN
                      2     1961-01-03   NaN   NaN
                      3     1961-01-04   NaN   NaN
                      4     1961-01-05   NaN   NaN
                      ...          ...   ...   ...
                      22276 2021-12-28  28.7  21.6
                      22277 2021-12-29  29.3  21.6
                      22278 2021-12-30  26.9  21.8
                      22279 2021-12-31  32.3  21.6
                      22280 2022-01-01  27.6  23.8

                      [22281 rows x 3 columns]
  ```

  We work with datasets, to padronize, we create the function format2 that exists only when you are working with dataset files.



  | Indices | Ana | Inemet | Xavier | Merge | IDEAM |
  | ------- | --- | ------ | ------ | ----- | ----- |
  | TXX     |     | [X]    |        |       |    [X]   |
  | TNX     |     | [X]    |        |       | [X]      |
  | TX90P   |     | [X]    |        |       |     [X]  |
  | TN90P   |     | [X]    |        |       |     [X]  |
  | CDD     | [X] |        |        |       |       |
  | CWD     | [X] |        |        |       |      |
  | PRCPTOT | [X] |        |        |       |     [X]  |
  | RX5DAY  | [X] |        |        |       |   [X]    |
  | TN10P   |     |        |        |       |       |
  | FD      |     |        |        |       |       |
  | SU      |     |        |        |       |       |
  | ETR     |     |        |        |       |       |
  | RNNMM   |     |        |        |       |       |
  | R99P    |     |        |        |       |       |
  | R95P    |     |        |        |       |       |
  | R10MM   |     |        |        |       |       |
  | R20MM   |     |        |        |       |       |
  | R99PTOT |     |        |        |       |       |


pkgId: 4ef11616b99eb7a7dd37c89e6f1cf3925572eb1b538b35cd3d22a6320ceefb61
name: python-AgentX
arch: src
version: 0.0.27
epoch: 0
release: 1
url: https://github.com/erfanzar/AgentX
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AgentX-0.0.27-1.src.rpm
checksum_type: sha256
summary:
  AgentX: Seamlessly integrate intelligent agents into your projects. Empower your applications with advanced AI capabilities.

description:
  AgentX is a versatile toolkit designed to seamlessly integrate intelligent agents into your projects. With AgentX,
  developers can effortlessly bridge the gap between different frameworks and platforms, empowering their applications
  with advanced AI capabilities. AgentX facilitates the connection and collaboration of diverse agents, enhancing the
  synergy between neural networks and decision-making processes. Whether you're working on machine learning, robotics, or
  data analysis projects, AgentX provides the essential tools to create dynamic and adaptive systems. Experience the power
  of intelligent fusion with AgentX and unlock new possibilities for your applications.



  1. **Seamless Integration**: AgentX allows for the seamless integration of intelligent agents into your projects,
     regardless of the underlying frameworks or platforms.

  2. **Versatility**: With AgentX, you can connect and collaborate with diverse agents, enabling a wide range of
     applications in fields such as machine learning, robotics, and data analysis.

  3. **Advanced AI Capabilities**: Empower your applications with advanced AI capabilities by leveraging AgentX's tools
     and functionalities.

  4. **Flexibility**: AgentX offers flexibility in designing and implementing dynamic and adaptive systems, providing
     developers with the freedom to explore new possibilities.

  5. **Framework Agnostic**: AgentX is framework-agnostic, meaning it can work with various AI frameworks, allowing you to
     choose the best tools for your specific project needs.

  6. **Efficiency**: AgentX is designed for efficiency, ensuring optimal performance and resource utilization in your
     applications.

  7. **Community Support**: Join a vibrant community of developers using AgentX, where you can find support, share ideas,
     and collaborate on enhancing the toolkit.

  8. **Documentation**: Comprehensive documentation and examples are provided to help you get started quickly and make the
     most out of AgentX in your projects.

  9. **Continuous Updates**: Expect regular updates and improvements to AgentX, ensuring that you stay up-to-date with the
     latest advancements in AI integration and functionality.

  10. **Open Source**: AgentX is an open-source project, inviting contributions from the community to help enhance its
      features, usability, and effectiveness in real-world applications.


  AgentX support usage Via CLI for more information just use
  ```shell
  agentx serve --help
  ```


  Here's an Example of Serving and using Model with AgentX with torch Backend.

  > [!NOTE]
  > You can just don't pass `prompter` or prompt template and just pass the tokenizer
  > engine will use tokenizer chat template

  ```python
  from agentx import ServeEngine, PromptTemplates
  import torch

  engine = ServeEngine.from_torch_pretrained(
      huggingface_repo_id="meta-llama/Meta-Llama-3-8B-Instruct",
      sample_config=None,  # torch support Auto Set from Model Config.
      
      
      
      
      
      
      
      prompter=PromptTemplates.from_prompt_templates(
          "llama_3",
          eos_token=None,  # Auto Set is supported for some models
          bos_token=None  # Auto Set is supported for some models
      ),
      tokenizer_huggingface_repo_id=None,
      bnb_4bit_compute_dtype=torch.float16,
      device_map="auto",
      _attn_implementation="sdpa",
      bnb_4bit_quant_type="fp4"
  )

  response = engine.execute("You Are Using AgentX Execute Function")
  for char in engine.process(
          "You Are Using AgentX Process/Stream Function"
  ):
      print(char, end="")



  engine.build_inference().launch(server_name="0.0.0.0", server_port=7860)
  ```



  Here's an Example of Serving and using Model with AgentX with Ollama Backend.
  (Ollama and Llama CPP kinda have same usage examples.)

  ```python
  from agentx import ServeEngine, PromptTemplates, EngineGenerationConfig

  engine = ServeEngine.from_ollama_model(
      ollama_model="LLAMA-3-OLLAMA",
      sample_config=EngineGenerationConfig(
          max_new_tokens=8192,
          max_sequence_length=8192,
          top_k=20,
          top_p=0.95,
          temperature=0.2,
      ),
      prompter=PromptTemplates.from_prompt_templates(
          "llama_3",
          eos_token=None,  # Auto Set is supported for some models
          bos_token=None  # Auto Set is supported for some models
      ),
  )

  response = engine.execute("You Are Using AgentX Execute Function")
  for char in engine.process(
          "You Are Using AgentX Process/Stream Function"
  ):
      print(char, end="")



  engine.build_inference().launch(server_name="0.0.0.0", server_port=7860)
  ```



  If you would like to contribute to AgentX, please follow the guidelines outlined in the CONTRIBUTING.md file in the
  repository.



  AgentX is licensed under the [MIT](https://github.com/erfanzar/AgentX/blob/main/LICENSE). See the LICENSE.md file
  for more details.



  For any questions or issues, please get in touch with me at [erfanzare810@gmail.com](erfanzare810@gmail.com).

  Thank you for using AgentX! We hope it will help you have a personal computer experience.


pkgId: ee14dca35a5c6c6793514b4500d37f4a60f248f0b1cb8ddb39ede183aa092129
name: python-AgentsWorker
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Libreria para crear agentes que responden a eventos desde kafka
url: https://pypi.org/project/AgentsWorker/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AgentsWorker-1.0.6-1.src.rpm
checksum_type: sha256
description:
  Framework para implementar agenes con acciones que permitan ejecutarlos bajo un protocolo
  basado en json-rpc.

  ```python

  @Agents.Define(options(
      Name = '',
      Kafka = []
  ))
  class Example:

      @Agents.Methods('list')
      def NameMethod(data, Resquest):
          
          return 10
  ```


pkgId: e41f1a8adfc49920de9f07cfdceac68c81f5d728b3e55e050a49e2defb7d7ef5
name: python-Agilize
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Unofficial client to access Agilize
url: https://github.com/lucasrcezimbra/agilize
rpm_license: LGPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Agilize-0.0.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://badge.fury.io/py/Agilize.svg)](https://badge.fury.io/py/Agilize)
  [![Coverage Status](https://coveralls.io/repos/github/lucasrcezimbra/agilize/badge.svg?branch=master)](https://coveralls.io/github/lucasrcezimbra/agilize?branch=master)

  Unofficial client to access [Agilize](https://www.agilize.com.br/).




  ```bash
  pip install agilize
  ```




  High-level API

  ```python
  from agilize import Agilize, Competence


  agilize = Agilize(username='11222333000160', password='p4ssw0rd')


  companies = agilize.companies()

  for company in companies:
      print(company)


  company = companies[0]

  competence = Competence(year=2022, month=5)
  prolabore = company.prolabores.get(competence)
  print(prolabore)

  with open(f'./prolabore_{competence}.pdf', 'wb') as f:
      f.write(prolabore.download())
  ```

  Low-level API

  ```python
  from agilize import Client


  agilize = Client(username='11222333000160', password='p4ssw0rd')

  print(agilize.info)
  company_id = agilize.info['party']['companies'][0]['__identity']

  agilize.prolabores(company_id=company_id, year=2022)
  ```




  Contributions are welcome, feel free to open an Issue or Pull Request.

  Pull requests must be for the `develop` branch.

  ```bash
  git clone https://github.com/lucasrcezimbra/agilize
  cd agilize
  git checkout develop
  python -m venv .venv
  pip install -r requirements-dev.txt
  pre-commit install
  pytest
  ```


pkgId: d58690c4b9aefcde139cd1634ce006f8fae5fa27c0f189adfdbdada10f67e5a5
name: python-AioKafkaEngine
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Wrapper around aio-kafka to use and receive via a asyncio queue
url: https://github.com/Bot-detector/AioKafkaEngine
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AioKafkaEngine-0.1.0-1.src.rpm
checksum_type: sha256
description:
  AsyncKafkaEngine is a wrapper around the aiokafka package.

  its build with the idea of decoupling the reading & batching task from your main application task, this way the queue of batches is always full and reading from kafka is not being blocked by the work of your application logic.


  Installing the package using uv
  ```bash
  uv add AioKafkaEngine
  ```
  Install the package using pip:
  ```bash
  pip install AioKafkaEngine
  ```




  The ConsumerEngine class manages the consumption of messages from Kafka topics asynchronously and places them into an queue. Your application can consume the queue.
  Example

  ```python
  import asyncio
  from AioKafkaEngine import ConsumerEngine
  from aiokafka import AIOKafkaConsumer
  import json

  async def work(queue):
      message = await queue.get()
      print(message)

  async def main():
      """
      Test that the consumer fetches and processes a single batch of messages.
      """
      test_queue = asyncio.Queue()

      
      engine = ConsumerEngine(
          consumer=AIOKafkaConsumer(
              *["test_topic"],
              bootstrap_servers="localhost:9092",
              group_id="my_group",
              value_deserializer=lambda x: json.loads(x.decode("utf-8")),
              auto_offset_reset="earliest",
          ),
          queue=test_queue,
          batch_size=10,
          timeout=1,
      )
      await engine.start()
      consume_task = asyncio.create_task(engine.consume())

      
      workers = [asyncio.create_task(work(queue)) for _ in range(10)]

      
      await asyncio.gather(consume_task, *workers)

  asyncio.run(main())
  ```


  The ProducerEngine class manages the production of messages to a Kafka topic asynchronously by retrieving messages from an internal queue. It also logs production statistics periodically.
  Example

  ```python
  import asyncio
  from AioKafkaEngine import ProducerEngine
  from aiokafka import AIOKafkaProducer
  import json

  async def work(queue):
      await queue.put(item={"key": 1})

  async def main():
      """
      Test that the consumer fetches and processes a single batch of messages.
      """
      queue = asyncio.Queue()
      await queue.put(item={"key": "k", "key2": 2})

      
      engine = ProducerEngine(
          producer=AIOKafkaProducer(
              bootstrap_servers="localhost:9092",
              value_serializer=lambda v: json.dumps(v).encode(),
              acks="all",
          ),
          queue=queue,
          topic="produce_topic",
      )
      await engine.start()

      produce_task = asyncio.create_task(engine.produce())

      
      workers = [asyncio.create_task(work(queue)) for _ in range(10)]

      
      await asyncio.gather(produce_task, *workers)
  asyncio.run(main())
  ```


  Contributions are welcome! Please submit a pull request or open an issue on GitHub.



  This project is licensed under the BSD 2-Clause License.


pkgId: 26e067b52300de9e6510a985704ec9e963da2d2a61af40a3113b28432c8d3ce1
name: python-AioMemcached
arch: src
version: 0.8.4
epoch: 0
release: 1
summary: A pure-Python(3.7+) asyncio memcached client, fork from aiomcache.
url: https://pypi.org/project/AioMemcached/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AioMemcached-0.8.4-1.src.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/rexzhang/aiomemcached)
  ![Pytest Workflow Status](https://github.com/rexzhang/aiomemcached/actions/workflows/check-pytest.yml/badge.svg)
  [![codecov](https://codecov.io/gh/rexzhang/aiomemcached/branch/main/graph/badge.svg?token=UCO9BUNU6C)](https://codecov.io/gh/rexzhang/aiomemcached)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![](https://img.shields.io/pypi/v/aiomemcached.svg)](https://pypi.org/project/aiomemcached/)
  [![](https://img.shields.io/pypi/pyversions/aiomemcached.svg)](https://pypi.org/project/aiomemcached/)
  [![](https://img.shields.io/pypi/dm/aiomemcached.svg)](https://pypi.org/project/aiomemcached/)

  A pure-Python(3.7+) zero-depend asyncio memcached client, fork from [aiomcache](https://pypi.org/project/aiomcache/).

  |               | people                                         |
  |---------------|------------------------------------------------|
  | Author        | Nikolay Kim <fafhrd91@gmail.com>               |
  | Maintainer    | Rex Zhang <rex.zhang@gmail.com>                |
  | Contributions | Nikolay Novik <nickolainovik@gmail.com>        |
  |               | Andrew Svetlov <andrew.svetlov@gmail.com>      |
  |               | Rex Zhang <rex.zhang@gmail.com>                |
  |               | Manuel Miranda <manu.mirandad@gmail.com>       |
  |               | Jeong YunWon <https://github.com/youknowone>   |
  |               | Thanos Lefteris <https://github.com/alefteris> |
  |               | Maarten Draijer <maarten@madra.nl>             |
  |               | Michael Gorven <michael@gorven.za.net>         |



  ```shell
  pip install -U AioMemcached
  ```





  Code

  ```python
  import asyncio

  import aiomemcached


  async def base_command():
      client = aiomemcached.Client()

      print('client.version() =>', await client.version())

      print('\ninit key and value:')
      k1, k2, v1, v2 = b'k1', b'k2', b'1', b'v2'
      print("k1, k2, v1, v2 = b'k1', b'k2', b'1', b'2'")
      keys = [k1, k2]
      print("keys = [k1, k2]")

      print('\nget and set key:')
      print('client.set(k1, v1) =>', await client.set(k1, v1))
      print('client.get(k1) =>', await client.get(k1))
      print('client.set(k2, v2) =>', await client.set(k2, v2))
      print('client.get(k2) =>', await client.get(k2))

      print('\nincr and decr value:')
      print('client.incr(k1) =>', await client.incr(k1))
      print('client.decr(k1) =>', await client.decr(k1))

      print('\nget multi key:')
      print('client.get_many(keys) =>', await client.get_many(keys))
      print('client.gets_many(keys) =>', await client.gets_many(keys))
      print('client.set(k2, v2) =>', await client.set(k2, v2))
      print('client.gets_many(keys) =>', await client.gets_many(keys))

      print('\ndelete key:')
      print('client.delete(k1) =>', await client.delete(k1))
      print('client.gets_many(keys) =>', await client.gets_many(keys))

      print('\nappend value to key:')
      print("client.append(k2, b'append') =>",
            await client.append(k2, b'append'))
      print('client.get(k2) =>', await client.get(k2))

      print('flush memcached:')
      print('client.flush_all() =>', await client.flush_all())
      print('client.get_many(keys) =>', await client.get_many(keys))

      return


  if __name__ == '__main__':
      asyncio.run(base_command())
  ```

  Output

  ```
  client.version() => b'1.6.9'

  init key and value:
  k1, k2, v1, v2 = b'k1', b'k2', b'1', b'2'
  keys = [k1, k2]

  get and set key:
  client.set(k1, v1) => True
  client.get(k1) => (b'1', {'flags': 0, 'cas': None})
  client.set(k2, v2) => True
  client.get(k2) => (b'v2', {'flags': 0, 'cas': None})

  incr and decr value:
  client.incr(k1) => 2
  client.decr(k1) => 1

  get multi key:
  client.get_many(keys) => ({b'k1': b'1', b'k2': b'v2'}, {b'k1': {'flags': 0, 'cas': None}, b'k2': {'flags': 0, 'cas': None}})
  client.gets_many(keys) => ({b'k1': b'1', b'k2': b'v2'}, {b'k1': {'flags': 0, 'cas': 168}, b'k2': {'flags': 0, 'cas': 166}})
  client.set(k2, v2) => True
  client.gets_many(keys) => ({b'k1': b'1', b'k2': b'v2'}, {b'k1': {'flags': 0, 'cas': 168}, b'k2': {'flags': 0, 'cas': 169}})

  delete key:
  client.delete(k1) => True
  client.gets_many(keys) => ({b'k2': b'v2'}, {b'k2': {'flags': 0, 'cas': 169}})

  append value to key:
  client.append(k2, b'append') => True
  client.get(k2) => (b'v2append', {'flags': 0, 'cas': None})
  flush memcached:
  client.flush_all() => True
  client.get_many(keys) => ({}, {})

  ```


  Unit test and coverage report

  ```shell
  python -m pytest
  ```


pkgId: c2d3d8e817493fe837ad86b89b4b201a104af8fe48e9673ac16d621465435abd
name: python-AioPTTCrawler
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: PTT crawler using asyncio
url: https://github.com/DOUIF/aio-ptt-crawler
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AioPTTCrawler-0.0.12-1.src.rpm
checksum_type: sha256
description:
  ```python
  article_dict = ptt_data.get_article_dict()
  comment_dict = ptt_data.get_comment_dict()
  ```
  article's dict format
  ```json
  [
      {
          "article" : "Article's ID. ex:M.1663144920.A.A6E",
          "article_title" : "Article's title. ex:[公告] 批踢踢27週年活動宣導公告更新",
          "user_id" : "Author's ID. ex: ubcs",
          "user_name" : "Author's name. ex:(覺★青年超冒險蓋)",
          "board" : "BBS Board ex: Gossiping",
          "datetime" : "Post time. ex: Wed Sep 14 16:41:58 2022.",
          "context" : "Context of article. ex: PTT 27 周年活動開始囉，本篇為置底宣導，詳情參閱下面資料...",
          "ip_address" : "IP address. ex: 59.120.192.119",
          "comment_list" : [
              {"comment_dict"},
              {"comment_dict"},
          ]
      }, {"..."}
  ]
  ```
  comment's dict format
  ```json
  [
      {
          "article_id" : "Article's ID. ex:M.1663144920.A.A6E",
          "tag" : "comment's reaction. ex: 推 噓 →",
          "user_id" : "User's ID. ex: bill403777",
          "comment_order" : "order of comment. ex: 1",
          "context" : "Context of comment. ex: 錢",
          "datetime" : "Post time. ex: 09/14 16:42",
          "ip_address" : "27.53.96.42",
      }, {"..."}
  ]
  ```

  [article]: https://www.ptt.cc/bbs/Gossiping/M.1663144920.A.A6E.html


  ![time diff](/time-diff.png)


  You may report bugs, ask for help and discuss various other issues on the [issuse][]
  [issuse]: https://github.com/DOUIF/aio-ptt-crawler/issues


pkgId: 951ba4abfb9511c94be3d7d342edd6834467afe7d61eca481f3d01e12e30296d
name: python-AirThings-API
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Python Wrappers for AirThings API
url: https://github.com/braibaud/airthings-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AirThings-API-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Python Wrappers for AirThings API



  * Package published at https://pypi.org/project/airthings-api/
  * Install package: `pip install -i airthings-api`



  > NB: You can now use async/await at the top level in the IPython terminal and in the notebook, it should — in most of the cases — “just work”. Update IPython to version 7+, IPykernel to version 5+.

  ```python

  ata = __import__('airthings-api')
  import aiohttp

  session = aiohttp.ClientSession()


  manager = ata.api.web.AirThingsManager(
      username='jdoe@gmail.com',
      password='xxxxxxxx',
      session=session)


  me = await manager.get_me_instance()

  print(me.email)



  locations_instance = await manager.get_locations_instance()


  for location in locations_instance.locations:
      for device in location.devices:
          print('device: {0}'.format(device.room_name))

          for current_sensor_value in device.current_sensor_values:
              print('  {0}: {1} {2}'.format(
                  current_sensor_value.type_,
                  current_sensor_value.value,
                  current_sensor_value.provided_unit))

  await session.close()











  ```



  > NB: If you run in a Python file, wrapping the call within `asyncio.run(...)` will do the trick.

  ```python
  ata = __import__('airthings-api')
  import aiohttp
  import asyncio


  async def test():

      session = aiohttp.ClientSession()

      
      manager = ata.api.web.AirThingsManager(
          username='jdoe@gmail.com',
          password='xxxxxxxx',
          session=session)

      
      me = await manager.get_me_instance()

      print(me.email)
      

      
      locations_instance = await manager.get_locations_instance()

      
      for location in locations_instance.locations:
          for device in location.devices:
              print('device: {0}'.format(device.room_name))

              for current_sensor_value in device.current_sensor_values:
                  print('  {0}: {1} {2}'.format(
                      current_sensor_value.type_,
                      current_sensor_value.value,
                      current_sensor_value.provided_unit))

      await session.close()

      
      
      
      
      
      
      
      
      
      


  if __name__ == '__main__':

      asyncio.run(test())
  ```


pkgId: e88660173c1aea411c1e687b7b82f74b14f37ad09cc9be54b051e3187af8604e
name: python-AirobotLibrary
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Robotframework Library For Airobot Test Framework
url: https://github.com/BSTester/AirobotLibrary
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AirobotLibrary-1.2.4-1.src.rpm
checksum_type: sha256
description:
  全端自动化测试框架Airobots的扩展插件库，集成以下扩展库

      selenium
      appium
      robotframework
      robotframework-seleniumlibrary
      robotframework-appiumlibrary
      robotframework-requests
      robotframework-databaselibrary
      robotframework-ftplibrary
      robotframework-archivelibrary
      robotframework-difflibrary

  请自行在 `https://npm.taobao.org/mirrors/chromedriver` 下载跟Chrome浏览器版本对应的驱动，放在系统PATH中。


pkgId: 293e92a30ba5a370dd510b639a6ca81a02402966b20305ac4605c07a46d63df9
name: python-Airshare
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Cross-platform content sharing in a local network.
url: https://github.com/KuroLabs/airshare
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Airshare-0.1.6-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <br>
    <img src="https://raw.githubusercontent.com/KuroLabs/Airshare/master/assets/Airshare.svg" alt="Airshare" width="100">
    <br>
    <br>
    <span>Airshare</span>
    <br>
    <br>
  </h1>

  <h4 align="center">Cross-platform content sharing in a local network.</h4>

  <p align="justify"><b>Airshare</b> is a Python-based CLI tool and module that lets you transfer data between two machines in a local network, P2P, using Multicast-DNS. It also opens an HTTP gateway for other non-CLI external interfaces. It works completely offline! Built with aiohttp and zeroconf.</p>



  * Blazing fast content transfer within a local network.

  * Lets you transfer plain text, send from or receive into your clipboard.

  * Supports transfer of multiple files, directories and large files - content is sent chun$

  * Lets you send files whose paths have been copied into the clipboard (more details in th$

  * Cross-platform, works on Linux, Windows and Mac (CLI and Web Interface), and also suppo$

  * Uses Multicast-DNS service registration and discovery - so you can access content with $

  * Can be used as a module in other Python programs.



  Source Code: https://github.com/KuroLabs/Airshare <br>
  Bug Reports: https://github.com/KuroLabs/Airshare/issues <br>
  Documentation: https://airshare.rtfd.io <br>
  PyPI: https://pypi.org/project/Airshare <br>



  * Install using `pip`

  ```bash
  $ pip install Airshare
  ```

  * Install using `pipx`

  ```bash
  $ pipx install Airshare
  ```

  * Install using Homebrew

  ```bash
  $ brew install airshare
  ```



  Send and receive files and directories.

  To send using the CLI,

  ```bash
  $ airshare noobmaster requirements.txt
  ```
  To receive using the CLI,

  ```bash
  $ airshare noobmaster
  ```

  or visit `http://noobmaster.local:8000` in the browser to download.

  You can also `import airshare` in any Python program. Visit the documentation for detailed usage instructions.



  * Link-local Name Resolution (for the `.local` addresses) on non-Apple devices requires Avahi (on Linux) or Bonjour (on Windows). Chances are you already have them, but if you don't, do check the web on how to install them.

  * Android browsers do not have inbuilt Multicast-DNS service discovery, and cannot resolve the `.local` addresses. For this reason, we included QR Code support, for you to visit the URLs easily.

  * Windows users with Python < 3.8, use <kbd>Ctrl</kbd> + <kbd>Break</kbd> to quit, as <kbd>Ctrl</kbd> + <kbd>C</kbd> will not work. This is a known issue with `asyncio`, which has been fixed in Python 3.8. If you do not have a <kbd>Break</kbd> key, try using <kbd>Ctrl</kbd> + <kbd>Fn</kbd> + <kbd>B</kbd>, or check the web for other alternatives (depending on your PC).



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



  [MIT](https://github.com/KuroLabs/Airshare/blob/master/LICENSE.md) - Copyright (c) 2020 [Kandavel A](http://github.com/AK5123), [Mohanasundar M](https://github.com/mohanpierce99), [Nanda H Krishna](https://github.com/nandahkrishna)



  The Airshare logo was designed by [Siddique](https://dribbble.com/thesideeq).

  The Airshare GIF was created by [Anam Saatvik](https://github.com/kalki7).


pkgId: 9da09ac927d666d0220673dcdd7deed22a0f0477d7e73b1df2e9f046321e0677
name: python-AirzoneCloud
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Python3 library for Airzone Cloud API
url: https://github.com/max13fr/AirzoneCloud
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AirzoneCloud-1.2.2-1.src.rpm
checksum_type: sha256
description:
  - [Airzone Cloud](#airzone-cloud)
    - [Presentation](#presentation)
      - [Abstract](#abstract)
      - [Module classes](#module-classes)
    - [Usage](#usage)
      - [Install](#install)
      - [Start API](#start-api)
      - [Get installations](#get-installations)
      - [Get installations](#get-installations-1)
      - [Get groups for each installation](#get-groups-for-each-installation)
      - [Get devices for each grou of each installation](#get-devices-for-each-grou-of-each-installation)
      - [Get all devices from all installations shortcut](#get-all-devices-from-all-installations-shortcut)
      - [Control a device](#control-a-device)
      - [HVAC mode](#hvac-mode)
        - [Available modes](#available-modes)
        - [List supported modes for each devices](#list-supported-modes-for-each-devices)
        - [Set HVAC mode on a master thermostat device (and all linked thermostats)](#set-hvac-mode-on-a-master-thermostat-device-and-all-linked-thermostats)
    - [API documentation](#api-documentation)
    - [Tests](#tests)
      - [Update configuration in config_test.json](#update-configuration-in-config_testjson)
      - [Run test script](#run-test-script)





  Allow to communicate easily with Airzone Cloud to retrieve information or to send commands (on/off, temperature, HVAC mode, ...)

  This library manage the main Airzone Cloud API (try to connect to [www.airzonecloud.com](https://www.airzonecloud.com) to be sure).

  Official API documentation is available here : https://developers.airzonecloud.com/docs/web-api/



  - **AirzoneCloud** : represent your AirzoneCloud account. Contains a list of your **installations** :
    - **Installation**: represent one of your installation (like your home, an office, ...). Contains a list of its **groups** :
      - **Group** : represent a group of **devices** in the installation
        - **Device** : represent your thermostat to control

  ![Airzonecloud tree elements](airzonecloud_tree_elements.png)





  ```bash
  pip3 install AirzoneCloud
  ```



  ```python
  from AirzoneCloud import AirzoneCloud
  api = AirzoneCloud("email@domain.com", "password")
  ```



  ```python
  for installation in api.installations:
      print(
          "Installation(name={}, access_type={}, ws_ids=[{}], id={})".format(
              installation.name, installation.access_type, ", ".join(installation.ws_ids), installation.id
          )
      )
  ```

  Output :

  <pre>
  Installation(name=Home, access_type=admin, ws_ids=[AA:BB:CC:DD:EE:FF], id=60f5cb990123456789abdcef)
  </pre>



  ```python
  for installation in api.installations:
      print(
          "Installation(name={}, access_type={}, ws_ids=[{}], id={})".format(
              installation.name, installation.access_type, ", ".join(installation.ws_ids), installation.id
          )
      )
  ```

  Output :

  <pre>
  Installation(name=Home, access_type=admin, ws_ids=[AA:BB:CC:DD:EE:FF], id=60f5cb990123456789abdcef)
  </pre>



  ```python
  for installation in api.installations:
      print(installation)
      for group in installation.groups:
          print(
              "  Group(name={}, installation={}, id={})".format(
                  group.name, group.installation.name, group.id
              )
          )
  ```

  Output :

  <pre>
  Installation(name=Home)
    Group(name=System 1, installation=Home, id=60f5cb990123456789abdce0)
  </pre>



  ```python
  for installation in api.installations:
      print(installation)
      for group in installation.groups:
          print("  " + str(group))
          for device in group.devices:
              print(
                  "    Device(name={}, is_connected={}, is_on={}, mode={}, current_temp={}, target_temp={}, id={}, ws_id={})".format(
                      device.name,
                      device.is_connected,
                      device.is_on,
                      device.mode,
                      device.current_temperature,
                      device.target_temperature,
                      device.id,
                      device.ws_id,
                  )
              )
  ```

  Output :

  <pre>
  Installation(name=Home)
    Group(name=System 1, installation=Home)
      Device(name=Salon, is_connected=True, is_on=True, mode=heating, current_temp=20.9, target_temp=20.0, id=60f5cb990123456789abdce1, ws_id=AA:BB:CC:DD:EE:FF)
      Device(name=Ch parents, is_connected=True, is_on=False, mode=heating, current_temp=17.2, target_temp=18.0, id=60f5cb990123456789abdce2, ws_id=AA:BB:CC:DD:EE:FF)
      Device(name=Ch bebe, is_connected=True, is_on=False, mode=heating, current_temp=18.6, target_temp=19.5, id=60f5cb990123456789abdce3, ws_id=AA:BB:CC:DD:EE:FF)
  </pre>



  ```python
  for device in api.all_devices:
      print(
          "Device(name={}, is_on={}, mode={}, current_temp={}, target_temp={}, id={})".format(
              device.name,
              device.is_on,
              device.mode,
              device.current_temperature,
              device.target_temperature,
              device.id,
          )
      )
  ```

  Output :

  <pre>
  Device(name=Salon, is_connected=True, is_on=True, mode=heating, current_temp=20.9, target_temp=20.0, id=60f5cb990123456789abdce1, ws_id=AA:BB:CC:DD:EE:FF)
  Device(name=Ch parents, is_connected=True, is_on=False, mode=heating, current_temp=17.2, target_temp=18.0, id=60f5cb990123456789abdce2, ws_id=AA:BB:CC:DD:EE:FF)
  Device(name=Ch bebe, is_connected=True, is_on=False, mode=heating, current_temp=18.6, target_temp=19.5, id=60f5cb990123456789abdce3, ws_id=AA:BB:CC:DD:EE:FF)
  </pre>



  All actions by default are waiting 1 second then refresh the device.
  You can disable this behavior by adding auto_refresh=False.

  ```python

  device = api.all_devices[0]
  print(device)


  device.turn_on(auto_refresh=False).set_temperature(22)
  print(device)


  device.turn_off()
  print(device)
  ```

  Output :

  <pre>
  Device(name=Salon, is_connected=True, is_on=False, mode=heating, current_temp=20.8, target_temp=20.0)
  Device(name=Salon, is_connected=True, is_on=True, mode=heating, current_temp=20.8, target_temp=22.0)
  Device(name=Salon, is_connected=True, is_on=False, mode=heating, current_temp=20.8, target_temp=22.0)
  </pre>





  - **stop** : Stop mode
  - **auto** : Automatic mode
  - **cooling** : Cooling mode
  - **heating** : Heating mode
  - **ventilation** : Ventilation mode
  - **dehumidify** : Dehumidifier / Dry mode
  - **emergency-heating** : Emergency heat mode
  - **air-heating** : Heat air mode (only compatible systems)
  - **radiant-heating** : Heat radiant mode (only compatible systems)
  - **combined-heating** : Heat combined mode (only compatible systems)
  - **air-cooling** : Cooling air mode (only compatible systems)
  - **radiant-cooling** : Cooling radiant mode (only compatible systems)
  - **combined-cooling** : Cooling combined mode (only compatible systems)

  Only master thermostat device can update the mode.



  ```python
  for device in api.all_devices:
      print(
          "Device(name={}, mode={}, modes_availables={})".format(
              device.name,
              device.mode,
              device.modes_availables,
          )
      )
  ```

  Output :

  <pre>
  Device(name=Salon, mode=heating, modes_availables=['cooling', 'heating', 'ventilation', 'dehumidify', 'stop'])
  Device(name=Ch parents, mode=heating, modes_availables=[])
  Device(name=Ch bebe, mode=heating, modes_availables=[])
  </pre>

  If modes_availables is an empty list, your device is not the master thermostat.



  ```python
  device = api.all_devices[0]
  print(device)


  device.set_mode("cooling")
  print(device)
  ```

  Output :

  <pre>
  Device(name=Salon, is_connected=True, is_on=True, mode=heating, current_temp=20.8, target_temp=20.0)
  Device(name=Salon, is_connected=True, is_on=True, mode=cooling, current_temp=20.8, target_temp=20.0)
  </pre>



  [API full doc](API.md)





  - **email** : used to log-in to you AirzoneCloud account (default to *changeme@example.com*)
  - **password** : used to log-in to you AirzoneCloud account (default to *changeme*)
  - **log_level** : minimum level of log to display : DEBUG | INFO | WARNING | ERROR | CRITICIAL (default to *INFO*)
  - **display_group_properties** : display all properties for each group (default to *true*).
  - **display_device_properties** : display all properties for each device (default to *true*).
  - **display_api_token** : ask to display token used to connect to the AirzoneCloud API (default to *false*). Useful for https://developers.airzonecloud.com/docs/web-api/
  - **refresh_before_display** : ask to call all refresh functions before displaying for test purpose (default to *false*).



  ```bash
  ./test.py
  ```


pkgId: d4ca2d986029f2deab867b397f4399c6b9247a572cf2c55693068c7f7870cee0
name: python-Ais-cryoET
arch: src
version: 1.0.40
epoch: 0
release: 1
url: https://github.com/bionanopatterning/Ais
rpm_license: GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Ais-cryoET-1.0.40-1.src.rpm
checksum_type: sha256
summary:
  Segmentation of cryo-electron tomography data - https://ais-cryoet.readthedocs.org/ https://aiscryoet.org/

description:
  This repository comprises a standalone pre-release of the scNodes _Segmentation Editor_. For the joint project, see the [superclem repository](https://www.github.com/bionanopatterning/scNodes)

  A timelapse video of the full workflow, from reconstructed tomograms to segmented volumes showing membranes, ribosomes, mitochondrial granules, and microtubuli, is available on our [YouTube channel](https://www.youtube.com/watch?v=2JIBVJf3kYQ&ab_channel=scNodes).

  Contact: m.g.f.last@lumc.nl


  Ais works on Windows and Linux machines but not on MacOS. Install as follows:
  ```
  conda create --name ais
  conda activate ais
  conda install python==3.9
  conda install pip
  pip install ais-cryoet
  ```

  Then run using either of the following commands:
  ```
  ais
  ais-cryoet
  ```

  Compatibility between Python, tensorflow, and CUDA versions can be an issue. The following combination was used during development and is know to work:

  Python 3.9<br/>
  Tensorflow 2.8.0<br/>
  CUDA 11.8<br/>
  cuDNN 8.6<br/>
  protobuf 3.20.0<br/>

  The software will work without CUDA, but only on the CPU. This is much slower but still reasonably interactive if the tomograms aren't too big (in XY). We do recommend installing CUDA and cuDNN in order for tensorflow to be able to use the GPU. See: https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html for help installing CUDA and cuDNN.



  ![](Ais/res/scR_segmentation.PNG)
  In this example, four features (membranes, microtubuli, mitochondrial granules, and ribosomes) are concurrently annotated.


  ![](Ais/res/scR_trainset.PNG)
  After preparing some annotations, the user in this example selects positive and negative features before compiling a training dataset for a network that will learn to recognize lipid membranes.


  ![](Ais/res/scR_models_2.PNG)
  Here, four previously prepared training datasets are used to train four segmentation models. The menu on the left shows the set-up for the four models; the first three models have already been trained, while the fourth (microtubuli, orange) is being set up for a second training run.


  ![](Ais/res/scR_interactions.png)
  Model interactions add an extra layer of nonlinear filtering to the model outputs, and can aid significantly in reducing false positive predictions. Here, competition between the single and double membrane models enhances the differentiation between these two (similar) features, and a colocalization dependency of the viral pore model conditioned on the double membrane model suppresses spurious false positives by the pore model near biologically non-relevant other features.


  ![](Ais/res/scR_export.png)
  An example of the batch processing interface, in the 'Export' tab. Only one tomogram is imported, but any number can be linked into the software and processed in one go (typically, in an overnight process). Six features are being segmented: ribosome, coronaviral replication organelle pores, double membranes, intermediate filaments, microtubuli, and actin filaments.


  ![](Ais/res/scR_render.PNG)
  After processing a volume, the resulting segmented volume datasets are automatically available in the 'Render' tab, where the segmentation results can be interactively viewed. Opening the results in more familiar suites such as Blender or ChimeraX is facilitated in the bottommost 'Export 3D scene' tab.


  ![](Ais/res/scR_fluo_g_seg.png)
  In [scNodes](github.com/bionanopatterning/scNodes) + Ais, data can be forwarded from the correlation editor into Ais's segmentation editor. In the above image, a tomogram overlayed with a single molecule fluorescence localization map of rsEGFP2-labelled vimentin is being segmented; the fluorescence localizations reveal the location of vimentin filaments surrounded by a bundle of actin filaments an microtubules.


  ![](Ais/res/scR_fluo_overlay.png)
  Rendering in [scNodes](github.com/bionanopatterning/scNodes) + Ais combines the default isosurface viewer with 3D ray-traced fluorescence overlays. Here, a 2D single molecule localization map is projected into the 3D volume of the tomogram. Membranes, ribosomes, and the two vimentin filaments revealed by the fluorescence overlay are segmented and rendered.


pkgId: d77b07836c2f82bf183d4f93393e4efcae1158b705410301fd260e3b293e9dc5
name: python-AixWeather
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: A weather data generation tool for building energy system simulations.Pull, Transform, Export.
url: https://github.com/RWTH-EBC/AixWeather
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AixWeather-0.1.7-1.src.rpm
checksum_type: sha256
description:
  ![E.ON EBC RWTH Aachen University](./docs/source/_static/EBC_Logo.png)

  [![pylint](https://rwth-ebc.github.io/AixWeather//main//pylint/pylint.svg )](https://rwth-ebc.github.io/AixWeather//main//pylint/pylint.html)
  [![documentation](https://rwth-ebc.github.io/AixWeather//main//docs/doc.svg)](https://rwth-ebc.github.io/AixWeather//main//docs/index.html)
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)

  <div align="center">
    <img src="./docs/aixweather_logo/AixWeather_Logo.png" alt="AixWeather Logo" width="50%">
  </div>


  **A weather data generation tool for building energy system simulations. Pull, Transform, Export.**

  It is being developed at RWTH Aachen University, E.ON Energy Research Center,
  Institute for Energy Efficient Buildings and Indoor Climate (EBC) in Aachen, Germany.

  As the library is developed at RWTH Aachen University's EBC, the library's name AixWeather is derived from the
  city's French name Aix-la-Chapelle, which the people of Aachen are very fond of and use a lot.
  With the name AixWeather we follow this local tradition.

  If you have any questions regarding AixWeather, feel free to contact us at aixweather@eonerc.rwth-aachen.de.



  For fast access without setup, use the WebApp.
  The repository [AixWeather-WebApp](https://github.com/RWTH-EBC/AixWeather-WebApp) contains the corresponding WebApp for this repo.
  This repository contains the functionalities useful for, e.g., automation of tasks.


  For each data origin, a class is defined. Use generic functions to create the desired output file.
  See the examples to know how to use them.



  **This tool consists of three layers:**

  1. Import raw weather data from several sources

  2. Transform the weather data to a defined core format with consideration of:

      2.1. Time zone

      2.2. Time of measurement (whether a value at a certain time stamp is for the indicated time or, e.g., the average of the preceding hour)

      2.3. Avoidance of smoothing through interpolation (pass through variables without interpolation if possible)

      2.4. Units

      2.5. Calculate missing variables from available ones, e.g., horizontal direct radiation from diffuse and global radiation

      2.6. Missing data.

  3. Transform the core-format data to your desired output format

  **Overview**

  ![Weather Data Tool Diagram](docs/Overview_WeatherTool.drawio.png)

  **Known limitations:**

  - only hourly data

  **Chances:**

  - generic code base that allows for fast and easy extensions to both other import formats and output formats




  The station IDs for the DWD weather stations to pull historical data from are listed [here](https://www.dwd.de/DE/leistungen/klimadatendeutschland/stationsliste.html). Only german stations available. Aachen would be 15000.

  The DWD MOSMIX station IDs for the DWD forecast are listed [here](https://www.dwd.de/DE/leistungen/met_verfahren_mosmix/mosmix_stationskatalog.cfg?view=nasPublication&nn=16102) or located on a map [here](https://wettwarn.de/mosmix/mosmix.html). Worldwide station available. Aachen would be 10505.

  You may use the imported package [Wetterdienst](https://github.com/earthobservations/wetterdienst) to search for stations automatically, as described [here](https://bookdown.org/brry/rdwd/station-selection.html).






  **Test Reference Years (TRY)**:

  [Handbuch](https://www.bbsr.bund.de/BBSR/DE/forschung/programme/zb/Auftragsforschung/5EnergieKlimaBauen/2013/testreferenzjahre/try-handbuch.pdf).

  TRY data can be downloaded from the DWD (sign up required but for free) [TRY data sets](https://www.bbsr.bund.de/BBSR/DE/forschung/programme/zb/Auftragsforschung/5EnergieKlimaBauen/2013/testreferenzjahre/01-start.html;jsessionid=5D9912D230EB887C1F831671303A8A0F.live21304?nn=2544408&pos=2).

  Additional information on the suitability of TRY data (last update: 2019):
  There are typical TRY datasets grouped by the year of publication:
  - 2004 datasets: (DWD; some errors in solar radiation; dataset should be avoided).
  - 2010 datasets: suitable for EnEV and GEG, not for solar thermal simulations.
  - 2015 datasets: not suitable for EnEV and GEG, but for solar thermal simulations
  - Overall: Reliable quantities in TRYs are only the air temperature
  and the global radiation!


  **DWD historical**: [open data website](https://opendata.dwd.de/climate_environment/CDC/observations_germany/climate/)

  **DWD forecasts (MOSMIX i.e. KML files)**: [open data website](https://opendata.dwd.de/weather/local_forecasts/) go to content.log.bz2.

  **EnergyPlus (EPW)**:

  For format information, see the corresponding output format description.

  Online sources for EPW data: https://climate.onebuilding.org/default.html and https://www.ladybug.tools/epwmap/

  **ERC data:**

  This data is from the weather station of the Institute for Energy Efficient Buildings and Indoor Climate (RWTH). Access requires user credentials. Such credentials are pre-defined if you use the WebApp.



  **EnergyPlus (EPW):**

  [3rd party format description](https://designbuilder.co.uk/cahelp/Content/EnergyPlusWeatherFileFormat.htm)

  **Modelica ReaderTMY3:**

  TMY3 reader from the [IBPSA](https://github.com/ibpsa/modelica-ibpsa) library used in the [AixLib](https://github.com/RWTH-EBC/AixLib) library. Model info at [OpenModelica](https://build.openmodelica.org/Documentation/Buildings.BoundaryConditions.WeatherData.ReaderTMY3.html).
  It claims to use mainly [TMY3 data](https://www.nrel.gov/docs/fy08osti/43156.pdf), though we found that the pressure is used in mbar instead of Pa. Further deviations possible.

  Additional information for AixLib users.

  Weather data usage in the low order model (LOM):

  Used in LOM:
  - TDryBul
  - RelHum
  - TBlaSky (calculated via HInfHor, TDryBul, TDewPoi, and OpaSkyCov)
  - HGloHor
  - HDifHor
  - HDirNor

  Not used in the LOM:
  - total sky cover
  - ceiling height
  - wind direction
  - wind speed
  - atmospheric pressure

  **Unconverted to x**

  exports the core data without conversion to .csv, .json, or .pickle files.



  You are invited to contribute to the development of this weather tool.
  Issues can be reported using this site's Issues section.
  Furthermore, you are welcome to contribute via Pull Requests.
  More info on how to contribute can be found [here](docs/source/Contribution.md).

  <!-- This section is a work in progress and needs further editing



  [ToDo]()
  DOI:  ToDo

  ```
  @inproceedings{ToDo}
  ```
   -->



  The weather tool is released by RWTH Aachen University, E.ON Energy Research Center, Institute for Energy Efficient Buildings and Indoor Climate and is available under a 3-clause BSD license.
  See [license](LICENSE).


pkgId: 461764977b0739ba44998660097f98282f1b017f506fb60c738086772e9a8134
name: python-Akkoma.py
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Python wrapper for the [Akkoma](https://akkoma.dev/AkkomaGang/akkoma) API.
url: https://git.mastodont.cat/spla/Akkoma.py
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Akkoma.py-0.1.6-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for the Akkoma (https://akkoma.dev/AkkomaGang/akkoma) API.

      

      from akkoma import Akkoma

      '''
      client_id, client_secret = Akkoma.create_app(
          'app_name',
          to_file="app_clientcred.txt",
          api_base_url = 'https://yourakkoma.instance'
          )
      '''

      

      from akkoma import Akkoma

      akkoma = Akkoma(client_id = "app_clientcred.txt", api_base_url = 'https://yourakkoma.instance')

      grant_type = 'password'

      akkoma.log_in(
          client_id,
          client_secret,
          grant_type,
          'user',
          'password',
      to_file = "app_usercred.txt"
      )

      

      from akkoma import Akkoma

      akkoma = Akkoma(
          access_token = 'app_usercred.txt',
          api_base_url = 'https://yourakkoma.instance'
      )
      akkoma.status_post('Posting from python using Akkoma.py !')


pkgId: 9232833fc4b5a1578ea5a5187b53996837bd4d15643f4cb379750074191bf1f6
name: python-AkvoDjangoFormGateway
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: A Django library that enables seamless integration of messenger services
url: https://github.com/akvo/Akvo-DjangoFormGateway
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AkvoDjangoFormGateway-0.0.9-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/akvo/Akvo-DjangoFormGateway/actions/workflows/test.yml/badge.svg)](https://github.com/akvo/Akvo-DjangoFormGateway/actions) [![Repo Size](https://img.shields.io/github/repo-size/akvo/Akvo-DjangoFormGateway)](https://img.shields.io/github/repo-size/akvo/Akvo-DjangoFormGateway) [![Coverage Status](https://coveralls.io/repos/github/akvo/Akvo-DjangoFormGateway/badge.svg?branch=main)](https://coveralls.io/github/akvo/Akvo-DjangoFormGateway?branch=main) [![Languages](https://img.shields.io/github/languages/count/akvo/Akvo-DjangoFormGateway
  )](https://img.shields.io/github/languages/count/akvo/Akvo-DjangoFormGateway
  ) [![Issues](https://img.shields.io/github/issues/akvo/Akvo-DjangoFormGateway
  )](https://img.shields.io/github/issues/akvo/Akvo-DjangoFormGateway
  ) [![Last Commit](https://img.shields.io/github/last-commit/akvo/Akvo-DjangoFormGateway/main
  )](https://img.shields.io/github/last-commit/akvo/Akvo-DjangoFormGateway/main) [![GitHub license](https://img.shields.io/github/license/akvo/Akvo-DjangoFormGateway.svg)](https://github.com/akvo/Akvo-DjangoFormGateway/blob/main/LICENSE)

  **Akvo-DjangoFormGateway** is a Django library that enables seamless integration of messenger services such as WhatsApp, SMS, and SSID for collecting form data. It provides an easy-to-use gateway to receive and process form submissions from various messaging platforms, empowering developers to build interactive and conversational form experiences within their Django applications.

  Please note that you can further customize and expand upon this description to provide more specific details about the features, functionality, and benefits of your library.


pkgId: bb565b9548d56a3c6e0556acebcba40b0cb08192f02116d59c3563dd6a8966c5
name: python-AkvoResponseGrouper
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Fast-API Response catalog for pre-computed query
url: https://github.com/akvo/Akvo-ResponseGrouper
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AkvoResponseGrouper-1.2.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/AkvoResponseGrouper)
  [![Build Status](https://github.com/akvo/Akvo-ResponseGrouper/actions/workflows/test.yml/badge.svg)](https://github.com/akvo/Akvo-ResponseGrouper/actions) [![Repo Size](https://img.shields.io/github/repo-size/akvo/Akvo-ResponseGrouper)](https://img.shields.io/github/repo-size/akvo/Akvo-ResponseGrouper) [![Coverage Status](https://coveralls.io/repos/github/akvo/Akvo-ResponseGrouper/badge.svg?branch=main)](https://coveralls.io/github/akvo/Akvo-ResponseGrouper?branch=main) [![Languages](https://img.shields.io/github/languages/count/akvo/Akvo-ResponseGrouper
  )](https://img.shields.io/github/languages/count/akvo/Akvo-ResponseGrouper
  ) [![Issues](https://img.shields.io/github/issues/akvo/Akvo-ResponseGrouper
  )](https://img.shields.io/github/issues/akvo/Akvo-ResponseGrouper
  ) [![Last Commit](https://img.shields.io/github/last-commit/akvo/Akvo-ResponseGrouper/main
  )](https://img.shields.io/github/last-commit/akvo/Akvo-ResponseGrouper/main) [![Documentation Status](https://readthedocs.org/projects/Akvo-ResponseGrouper/badge/?version=latest)](https://Akvo-ResponseGrouper.readthedocs.io/en/latest/?badge=latest) [![GitHub license](https://img.shields.io/github/license/akvo/Akvo-ResponseGrouper.svg)](https://github.com/akvo/Akvo-ResponseGrouper/blob/main/LICENSE)

  Fast-API Response catalog for pre-computed query


  ```
  $ pip install AkvoResponseGrouper
  ```



  Please follow [the required schema](https://github.com/akvo/Akvo-ResponseGrouper/blob/main/docs/database.org) before using AkvoResponseGrouper.



  1. Database Migration

  Database migration is the first required step for AkvoResponseGrouper to work. Use the akvo-responsegrouper CLI to migrate all data sources with JSON configuration files to generate Materialized Views that AkvoResponseGrouper can then use.

  ```bash
  $ akvo-responsegrouper
  usage: akvo-responsegrouper [-h] [-c CONFIG] [-d]

  optional arguments:
    -h, --help            show this help message and exit
    -c CONFIG, --config CONFIG
                          akvo-responsegrouper -c <json_file_config>
    -d, --drop            Drop the ar_category view table
  ```

  2. Router

  To get the new endpoint provided by AkvoResponseGrouper, import the collection route to the App by:

  ```python
  from fastapi import FastAPI
  from AkvoResponseGrouper.routes import collection_route

  app = FastAPI(
      root_path="/",
      title="Akvo Response Grouper Demo",
  )

  app.include_router(collection_route)

  @app.get("/", tags=["Dev"])
  def read_main():
      return "OK"
  ```

  3. Query







  The dev environment contains two containers: FastAPI backend and PostGres db, to run:

  ```bash
  docker compose up -d
  ```
  Before go to the next step, wait until the service started at [http://localhost:5000](http://localhost:5000).



  In order to debug the data itself. We need to seed the example form and fake datapoints


  ```bash
  docker compose exec backend python -m script.seeder_form
  docker compose exec backend python -m script.seeder_datapoint <number_of_datapoint>
  ```



  Dev environment uses contents that is available in `Akvo-ResponseGrouper/src/AkvoResponseGrouper`. To create the Category Materialized View via CLI in dev environment:

  Upgrade:

  ```bash
  python -m AkvoResponseGrouper.cli.migrate -c './sources/category.json'
  ```

  After upgrade, you can see "AkvoResponseGrouper - Collection" is available in API docs, ussualy [http://locahhost:5000/docs](http://localhost:5000/docs) (Depends on the root path api).

  Downgrade:
  ```
  python -m AkvoResponseGrouper.cli.migrate -c './sources/category.json'
  ```


  ```
  docker compose down -v
  ```


pkgId: ba5fa47f0be93cc6d3551d3c2ca9fa9d7e45929e9b7952d4bc76dc25b243e953
name: python-AlbertUnruhUtils
arch: src
version: 2022.1.29.2
epoch: 0
release: 1
summary: A collection of utils written in Python.
url: https://github.com/AlbertUnruh/AlbertUnruhUtils.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlbertUnruhUtils-2022.1.29.2-1.src.rpm
checksum_type: sha256
description:
  A collection of utils written in Python

  **Python 3.9 or higher is required!**
  via pip: (recommended)
  ```shell
  pip3 install -U AlbertUnruhUtils
  ```
  latest develop-version:
  *(requires git to be installed)*
  ```shell
  git clone https://github.com/AlbertUnruh/AlbertUnruhUtils.py
  cd AlbertUnruhUtils.py
  pip3 install -U .
  ```
  or simply
  ```shell
  pip3 install -U git+https://github.com/AlbertUnruh/AlbertUnruhUtils.py.git#egg=AlbertUnruhUtils
  ```

  coming soon...


pkgId: a177b855202d936ec6631ed7094fab6b00ae9a653c14a014460d0c15b7dbecfb
name: python-AlbertUnruhUtils.py
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: A collection of utils written in Python.
url: https://github.com/AlbertUnruh/AlbertUnruhUtils.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlbertUnruhUtils.py-2.3.0-1.src.rpm
checksum_type: sha256
description:
  latest develop-version:
  *(requires git to be installed)*
  ```shell
  git clone https://github.com/AlbertUnruh/AlbertUnruhUtils.py
  cd AlbertUnruhUtils.py
  pip3 install -U .
  ```
  If you want async-support you have to append `[async]` to the last command.

  The docs can be found [here](https://AlbertUnruhUtilsPy.rtfd.io)


pkgId: ff73adf07d253575b2b789af2ebe545b754ac682a4e152abd0016d2e2f426b03
name: python-Alchemynger
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Simple SQLAlchemy connector manager.
url: https://github.com/Resheba/Alchemynger
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Alchemynger-0.2.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center"> Alchemynger </h1>
  <h3 align="center"> SQLAlchemy Connection Manager </h3>

  <p align="center">
      <img alt="Python" src="https://img.shields.io/badge/python-3.9_|_3.10_|_3.11-blue" />
  </p>
  <p align="center">
      <img alt="Python" src="https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54" />
      <img alt="Зostgres" src="https://img.shields.io/badge/postgres-%23316192.svg?style=for-the-badge&logo=postgresql&logoColor=white" />
      <img alt="SQLite" src="https://img.shields.io/badge/sqlite-%2307405e.svg?style=for-the-badge&logo=sqlite&logoColor=white" />
      <img alt="Flask" src="https://img.shields.io/badge/flask-%23000.svg?style=for-the-badge&logo=flask&logoColor=white" />
      <img alt="MySQL" src="https://img.shields.io/badge/mysql-%2300f.svg?style=for-the-badge&logo=mysql&logoColor=white" />
      <img alt="FastAPI" src="https://img.shields.io/badge/FastAPI-005571?style=for-the-badge&logo=fastapi" />
      <img alt="Flask" src="https://img.shields.io/badge/flask-%23000.svg?style=for-the-badge&logo=flask&logoColor=white" />
  </p>


  Alchemynger is a versatile Python library that simplifies database connectivity and interaction using SQLAlchemy. It offers both synchronous and asynchronous database management for applications that require efficient database operations.




  You can install Alchemynger using pip:

  ```bash
  pip install alchemynger
  ```





  SyncManager is designed for traditional synchronous applications. Here's how to use it:

  ```python
  from alchemynger import SyncManager
  from alchemynger.sqlalchemy import Column, String


  manager = SyncManager('sqlite:///path/to/db')


  class User(manager.Base):
      __tablename__ = 'user'
      name = Column(String(30), primary_key=True)


  manager.create_all()


  stmt = manager[User].insert.values(name='username')

  manager.execute(stmt, commit=True) # or manager(stmt, commit=True)
  ```



  AsyncManager is tailored for asyncio-based applications. Here's how to use it:

  ```python
  from asyncio import run
  from alchemynger import AsyncManager
  from alchemynger.sqlalchemy import Column, String


  manager = AsyncManager('sqlite+aiosqlite:///path/to/db')


  class User(manager.Base):
      __tablename__ = 'user'
      name = Column(String(30), primary_key=True)


  async def main():
      await manager.create_all()

      stmt = manager[User].insert.values(name='username')

      await manager.execute(stmt, commit=True) # or await manager(stmt, commit=True)

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



  Selectors can be used with Columns, a Column, or the Table Model.

  ```python

  manager[User.name].select
  manager[User.name, User.any_col].select
  ```

  ```python

  manager[User].select
  manager[User].delete
  manager[User].insert
  manager[User].update
  ```
  then execute
  ```python

  manager.execute(stmt, scalars=False)
  ```


  You can also utilize the standard query-writing methods provided by SQLAlchemy, for example, if you find that the library's functionality is insufficient for your needs. Just user `from sqlalchemy import select, insert, ...` or import from `from alchemynger.sqlalchemy import select, insert`

  ```python
  from alchemynger import SyncManager
  from alchemynger.sqlalchemy import select, insert, Column, String, Integer


  manager = SyncManager('sqlite:///path/to/db')


  class User(manager.Base):
      __tablename__ = 'user'
      id = Column(Integer, primary_key=True, autoincrement=True)
      name = Column(String(30))


  manager.create_all()



  stmt = select(User).where(User.id > 5)

  manager.execute(stmt)


  stmt = insert(User).values(name="Lex")

  manager.execute(stmt, commit=True) # or manager(stmt, commit=True)
  ```



  Both SyncManager and AsyncManager provide context managers for managing database sessions. This ensures that sessions are properly closed, even in the event of an exception.

  ```python

  with manager.get_session() as session:
      stmt = manager[User].select

      result = session.execute(stmt)
      
  ```



  Contributions to Alchemynger are welcome! If you have ideas for improvements, bug fixes, or new features, please open an issue or submit a pull request on the [GitHub repository](https://github.com/Resheba/Alchemynger).



  Alchemynger is licensed under the MIT License. See the [LICENSE](https://github.com/Resheba/Alchemynger/blob/main/LICENSE) file for more details.


