# packages

pkgId: b4eb6392920e80fd98a6959824547c5e0aba79d6e7a657ecceb54cfe75b3256e
name: python-0-core-client
arch: src
version: 1.1.0a8
epoch: 0
release: 1
summary: Zero-OS 0-core client
url: https://github.com/zero-os/0-core
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0-core-client-1.1.0a8-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip3 install 0-core-client
  ```



  ```python
  from zeroos.core0.client import Client

  cl = Client(host='<0-core-host-address>', password='<JWT>')


  print(cl.ping())


  print(
      cl.system('ps -eF').get()
  )

  print(
      cl.system('ip a').get()
  )


  print(
      cl.disk.list()
  )
  ```


pkgId: 29ef365c35eb29b42b3cf0d15e5cf0b236cdf58ddd8a919b26d763d561df15ce
name: python-01OS
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: The #1 open-source voice interface for desktop, mobile, and ESP32 chips.
url: https://pypi.org/project/01OS/
rpm_license: AGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-01OS-0.0.14-1.src.rpm
checksum_type: sha256
description:
  We no longer support installation from `pip`, and instead recommend cloning the repository locally.

  Visit [our GitHub repository](https://github.com/OpenInterpreter/01/) for more information.

  *The 01 is an open-source voice interface for desktop, mobile, and ESP32 chips.*


pkgId: ef33553b6d69dd770dfcef3158752c67ab4e98b246503176cf57a28f5b14186e
name: python-0fdb5604
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/0fdb5604/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0fdb5604-1.0.7-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <img src="docs/assets/swe-rex-logo.png" alt="SWE-ReX" style="height: 12em"/>



  [![Pytest](https://github.com/SWE-agent/swe-rex/actions/workflows/pytest.yaml/badge.svg)](https://github.com/SWE-agent/swe-rex/actions/workflows/pytest.yaml)
  [![Check Markdown links](https://github.com/SWE-agent/swe-rex/actions/workflows/check-links.yaml/badge.svg)](https://github.com/SWE-agent/swe-rex/actions/workflows/check-links.yaml)
  [![build-docs](https://github.com/SWE-agent/swe-rex/actions/workflows/build-docs.yaml/badge.svg)](https://github.com/SWE-agent/swe-rex/actions/workflows/build-docs.yaml)
  </div>



  ```bash
  pip install -e .

  pip install -e '.[modal]'

  pip install -e '.[dev]'
  ```


pkgId: a3a8d12ee78039eed3580c7c2821ba98501bd7ef46048655c41cf1a715f36086
name: python-0x-contract-addresses
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Addresses at which the 0x smart contracts have been deployed
url: https://github.com/0xproject/0x-monorepo/tree/development/python-packages/contract_addresses
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0x-contract-addresses-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Addresses at which the 0x smart contracts have been deployed.

  Read the [documentation](http://0x-contract-addresses-py.s3-website-us-east-1.amazonaws.com/)



  ```bash
  pip install 0x-contract-addresses
  ```



  We welcome improvements and fixes from the wider community! To report bugs within this package, please create an issue in this repository.

  Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.



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



  `./setup.py clean --all`



  `./setup.py lint`



  `./setup.py build_sphinx`



  See `./setup.py --help-commands` for more info.


pkgId: ae201215667ea61cbf614383b0ce6e117cb317a4b89ed21621fd45968ed90d0e
name: python-0x-contract-artifacts
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: 0x smart contract compilation artifacts
url: https://github.com/0xproject/0x-monorepo/tree/development/python-packages/contract_artifacts
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0x-contract-artifacts-3.0.0-1.src.rpm
checksum_type: sha256
description:
  0x smart contract compilation artifacts

  Read the [documentation](http://0x-contract-artifacts-py.s3-website-us-east-1.amazonaws.com/)



  ```bash
  pip install 0x-contract-artifacts
  ```



  We welcome improvements and fixes from the wider community! To report bugs within this package, please create an issue in this repository.

  Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.



  ```bash
  ./setup.py pre_install
  ```



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



  `./setup.py clean --all`



  `./setup.py lint`



  `./setup.py build_sphinx`



  See `./setup.py --help-commands` for more info.


pkgId: be762d999733983555b987a6f224f2ebcd93d83ff02054528b553390cc69b52b
name: python-0x-contract-wrappers
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Python wrappers for 0x smart contracts
url: https://github.com/0xproject/0x-monorepo/tree/development/python-packages/contract_wrappers
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0x-contract-wrappers-2.0.0-1.src.rpm
checksum_type: sha256
description:
  0x contract wrappers for those developing on top of 0x protocol.

  Read the [documentation](http://0x-contract-wrappers-py.s3-website-us-east-1.amazonaws.com/)



  ```bash
  pip install 0x-contract-wrappers
  ```



  We welcome improvements and fixes from the wider community! To report bugs within this package, please create an issue in this repository.

  Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.



  This package contains code generated via npm package @0x/abi-gen. Preparing this package for development or installation requires running `./setup.py pre_install`, which will invoke abi-gen to write the files to the src hierarchy. It expects to find abi-gen and the contract artifacts at the relative directory locations in the monorepo.

  After code generation, ensure that you have installed Python >=3.6 and Docker, and then:

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



  Tests depend on a running ganache instance and with the 0x contracts deployed in it. For convenience, a docker container is provided that has ganache-cli and a snapshot containing the necessary contracts. A shortcut is provided to run that docker container: `./setup.py ganache`. With that running, the tests can be run with `./setup.py test`.



  `./setup.py clean --all`



  `./setup.py lint`



  `./setup.py build_sphinx`



  See `./setup.py --help-commands` for more info.


pkgId: 16e479c06b503c2de54cf420c749b8140ef6b0df3a7f11620f0c358f1020ed08
name: python-0x-json-schemas
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: JSON schemas for 0x applications
url: https://github.com/0xProject/0x-monorepo/tree/development/python-packages/json_schemas
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0x-json-schemas-2.1.0-1.src.rpm
checksum_type: sha256
description:
  0x JSON schemas for those developing on top of 0x protocol.

  Read the [documentation](http://0x-json-schemas-py.s3-website-us-east-1.amazonaws.com/)



  ```bash
  pip install 0x-json-schemas
  ```



  We welcome improvements and fixes from the wider community! To report bugs within this package, please create an issue in this repository.

  Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.



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



  `./setup.py test`.



  `./setup.py clean --all`



  `./setup.py lint`



  `./setup.py build_sphinx`



  See `./setup.py --help-commands` for more info.


pkgId: 66fa31eed311b61735450e473c977688520617eb334fe9088475fae2255ca922
name: python-0x-middlewares
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Web3 middlewares for 0x applications
url: https://github.com/0xproject/0x-monorepo/tree/development/python-packages/middlewares
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0x-middlewares-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Web3 middlewares for 0x applications.

  Read the [documentation](http://0x-middlewares-py.s3-website-us-east-1.amazonaws.com/)



  ```bash
  pip install 0x-middlewares
  ```



  We welcome improvements and fixes from the wider community! To report bugs within this package, please create an issue in this repository.

  Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.



  Ensure that you have installed Python >=3.6 and Docker. Then:

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



  Tests depend on running a local ethereum JSON-RPC server. For convenience, a docker container is provided that has ganache-cli.
  A shortcut is provided to run that docker container: `./setup.py ganache`. With that running, the tests can be run with `./setup.py test`.



  `./setup.py clean --all`



  `./setup.py lint`



  `./setup.py build_sphinx`



  See `./setup.py --help-commands` for more info.


pkgId: df616695ac8ef2f49a1b31caa528c6eb9182e2fcd4fbab690d8b929da8a8487f
name: python-0x-order-utils
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Order utilities for 0x applications
url: https://github.com/0xProject/0x-monorepo/tree/development/python-packages/order_utils
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0x-order-utils-4.0.1-1.src.rpm
checksum_type: sha256
description:
  0x order-related utilities for those developing on top of 0x protocol.

  Read the [documentation](http://0x-order-utils-py.s3-website-us-east-1.amazonaws.com/)



  ```bash
  pip install 0x-order-utils
  ```



  We welcome improvements and fixes from the wider community! To report bugs within this package, please create an issue in this repository.

  Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started.



  Ensure that you have installed Python >=3.6 and Docker. Then:

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



  Tests depend on a running ganache instance with the 0x contracts deployed in it. For convenience, a docker container is provided that has ganache-cli and a snapshot containing the necessary contracts. A shortcut is provided to run that docker container: `./setup.py ganache`. With that running, the tests can be run with `./setup.py test`.



  `./setup.py clean --all`



  `./setup.py lint`



  `./setup.py build_sphinx`



  See `./setup.py --help-commands` for more info.


pkgId: 1353e19b2cc29a2fcd025c758081b7c6a435c7c3e2e1bb555fce82e88717c6ac
name: python-0x-python
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: 0x python wrapper
url: https://github.com/skeetzo/0x-python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0x-python-1.0.16-1.src.rpm
checksum_type: sha256
description:
  Can be found here: https://0x.org/docs/api



  Install test dependencies: `python3 setup.py install -e [.dev]`
  Run some tests: `python3 -m unittest tests.test_0x`
  Run all tests: `python3 -m unittest discover -s ./tests`


pkgId: 29e07d3898395667e8aed2287f0555ca96ea6b2a44fd0f3c14996979b579dbdb
name: python-0x-web3
arch: src
version: 4.8.2.1
epoch: 0
release: 1
summary: Web3.py
url: https://github.com/ethereum/web3.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0x-web3-4.8.2.1-1.src.rpm
checksum_type: sha256
description:
  0x-web3 is a temporary fork of web3. It adds primitive support for ABI tuples, which is needed in order to facilitate calling the 0x smart contracts. The fork’s changes to web3.py are visible in an open PR, and when that PR (or something analogous) is merged, this package will be taken down.

  [![Join the chat at https://gitter.im/ethereum/web3.py](https://badges.gitter.im/ethereum/web3.py.svg)](https://gitter.im/ethereum/web3.py?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

  [![Build Status](https://circleci.com/gh/ethereum/web3.py.svg?style=shield)](https://circleci.com/gh/ethereum/web3.py.svg?style=shield)


  A Python implementation of [web3.js](https://github.com/ethereum/web3.js)

  * Python 3.5+ support

  Read more in the [documentation on ReadTheDocs](http://web3py.readthedocs.io/). [View the change log on Github](docs/releases.rst).



  ```python
  import json
  import web3

  from web3 import Web3, HTTPProvider, TestRPCProvider
  from solc import compile_source
  from web3.contract import ConciseContract


  contract_source_code = '''
  pragma solidity ^0.4.0;

  contract Greeter {
      string public greeting;

      function Greeter() {
          greeting = 'Hello';
      }

      function setGreeting(string _greeting) public {
          greeting = _greeting;
      }

      function greet() constant returns (string) {
          return greeting;
      }
  }
  '''

  compiled_sol = compile_source(contract_source_code) # Compiled source code
  contract_interface = compiled_sol['<stdin>:Greeter']


  w3 = Web3(TestRPCProvider())


  contract = w3.eth.contract(abi=contract_interface['abi'], bytecode=contract_interface['bin'])


  tx_hash = contract.deploy(transaction={'from': w3.eth.accounts[0], 'gas': 410000})


  tx_receipt = w3.eth.getTransactionReceipt(tx_hash)
  contract_address = tx_receipt['contractAddress']


  abi = contract_interface['abi']
  contract_instance = w3.eth.contract(address=contract_address, abi=abi,ContractFactoryClass=ConciseContract)


  print('Contract value: {}'.format(contract_instance.greet()))
  contract_instance.setGreeting('Nihao', transact={'from': w3.eth.accounts[0]})
  print('Setting value to: Nihao')
  print('Contract value: {}'.format(contract_instance.greet()))
  ```



  ```sh
  git clone git@github.com:ethereum/web3.py.git
  cd web3.py
  ```

  Please see OS-specific instructions for:

  - [Linux](docs/README-linux.md#Developer-Setup)
  - [Mac](docs/README-osx.md#Developer-Setup)
  - [Windows](docs/README-windows.md#Developer-Setup)
  - [FreeBSD](docs/README-freebsd.md#Developer-Setup)

  Then run these install commands:

  ```sh
  virtualenv venv
  . venv/bin/activate
  pip install -e .[dev]
  ```

  For different environments, you can set up multiple `virtualenv`. For example, if you want to create a `venvdocs`, then you do the following:

  ```sh
  virtualenv venvdocs
  . venvdocs/bin/activate
  pip install -e .[docs]
  pip install -e .
  ```



  If you would like to develop and test inside a Docker environment, use the *sandbox* container provided in the **docker-compose.yml** file.

  To start up the test environment, run:

  ```
  docker-compose up -d
  ```

  This will build a Docker container set up with an environment to run the Python test code.

  **Note: This container does not have `go-ethereum` installed, so you cannot run the go-ethereum test suite.**

  To run the Python tests from your local machine:

  ```
  docker-compose exec sandbox bash -c 'pytest -n 4 -f -k "not goethereum"'
  ```

  You can run arbitrary commands inside the Docker container by using the `bash -c` prefix.

  ```
  docker-compose exec sandbox bash -c ''
  ```

  Or, if you would like to just open a session to the container, run:

  ```
  docker-compose exec sandbox bash
  ```



  During development, you might like to have tests run on every file save.

  Show flake8 errors on file change:

  ```sh

  when-changed -v -s -r -1 web3/ tests/ ens/ -c "clear; flake8 web3 tests ens && echo 'flake8 success' || echo 'error'"
  ```

  You can use `pytest-watch`, running one for every Python environment:

  ```sh
  pip install pytest-watch

  cd venv
  ptw --onfail "notify-send -t 5000 'Test failure ⚠⚠⚠⚠⚠' 'python 3 test on web3.py failed'" ../tests ../web3
  ```

  Or, you can run multi-process tests in one command, but without color:

  ```sh

  pytest --numprocesses=4 --looponfail --maxfail=1

  pytest -n 4 -f --maxfail=1
  ```



  1. [Setup your development environment](https://github.com/ethereum/web3.py/#developer-setup).

  2. Execute `tox` for the tests

  There are multiple [components](https://github.com/ethereum/web3.py/blob/master/.travis.yml#L53) of the tests. You can run test to against specific component. For example:

  ```sh

  tox -e py35-core


  tox -e py36-core
  ```

  If for some reason it is not working, add `--recreate` params.

  `tox` is good for testing against the full set of build targets. But if you want to run the tests individually, `py.test` is better for development workflow. For example, to run only the tests in one file:

  ```sh
  py.test tests/core/gas-strategies/test_time_based_gas_price_strategy.py
  ```



  For Debian-like systems:
  ```
  apt install pandoc
  ```

  To release a new version:

  ```sh
  make release bump=$$VERSION_PART_TO_BUMP$$
  ```



  The version format for this repo is `{major}.{minor}.{patch}` for stable, and
  `{major}.{minor}.{patch}-{stage}.{devnum}` for unstable (`stage` can be alpha or beta).

  To issue the next version in line, specify which part to bump,
  like `make release bump=minor` or `make release bump=devnum`.

  If you are in a beta version, `make release bump=stage` will switch to a stable.

  To issue an unstable version when the current version is stable, specify the
  new version explicitly, like `make release bump="--new-version 4.0.0-alpha.1 devnum"`


pkgId: ba12a629da706bc095566719d7cde5a51912deefcefa737e47360042f10412e1
name: python-0xdirsan
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://pypi.org/project/0xdirsan/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0xdirsan-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  0xdirsan is a simple program designed to search for directories within the file system using brute-force with a given list of words.

description:
  [![made-with-Python](https://img.shields.io/badge/made%20with-Python-pink.svg)](https://www.python.org/)
  [![license](https://img.shields.io/badge/license-MIT-pink.svg)](LICENSE)
  [![issues](https://img.shields.io/github/issues/X-Projetion/0xdirsan?color=pink)](https://github.com/X-Projetion/0xdirsan/issues)

  <p align="center">
      <img src="https://raw.githubusercontent.com/X-Projetion/0xdirsan/main/0xdirsan.png" alt="0xdirsan" width="60%">
  </p>
  <h4 align="center">0xdirsan is a simple program designed to search for directories in the file system</h4>


  0xdirsan is a simple program designed to search for directories within the file system using brute-force with a given list of words.


  - [Feature](#feature)
  - [Installation](#installation)
  - [Pypi](#Pypi)
  - [Usage](#usage)
  - [Help](#help)
  - [Disclaimer](#Disclaimer)



  - Uses multiple threads to speed up the search process.
  - Displays HTTP code status and related information for each request.
  - Support for custom word lists and configurable number of threads.



  Follow these steps to install 0xdirsan :

  1. **Clone repositori**:
     ```sh
      git clone https://github.com/X-Projetion/0xdirsan.git
      cd 0xdirsan

  2. **Clone repositori**:
     ```sh
     pip install -r requirements.txt
      ```



  - pip install 0xdirsan



  - python 0xdirsan.py -u <TARGET_URL>


  ```bash
  usage: main.py [-h] [-w WORDLIST] -u URL [-t THREADS]

  0xdirsan is a simple program designed to search for directories in a file system

  optional arguments:
    -h, --help            show this help message and exit
    -w WORDLIST, --wordlist WORDLIST
                          Path to wordlist file
    -u URL, --url URL     Target URL use http / https
    -t THREADS, --threads THREADS
                          Number of threads (default 30)
  ```


  - **Website:** [X-Projetion.org](https://x-projetion.org/)
  - **Pypi:** [0xdirsan](https://pypi.org/project/0xdirsan/)
  - **Instagram:** [@lutfifakee](https://www.instagram.com/lutfifakee/)


  Please note that 0xdirsan is provided for educational purposes only. Use of this program for unethical or illegal activities is not recommended. The developer is not responsible for any actions taken by users.

  <br>
  <p>0xdirsan was developed by X-Projetion, a software developer with a focus on security and penetration testing. You can visit the website <a href="https://x-projetion.org/">X-Projetion.org</a> for more information or follow <a href="https://www.instagram. com/lutfifakee/">Instagram</a> X-Projetion for the latest updates.</p>


pkgId: a16d48de99ea1db11cad67414e3b295a62c7af0f4620e6647637ab453ae40b46
name: python-0xf0f-codenode
arch: src
version: 1.0
epoch: 0
release: 1
summary: a simple framework for code generation
url: https://github.com/0xf0f/codenode
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-0xf0f-codenode-1.0-1.src.rpm
checksum_type: sha256
description:
  > ```python
  > def dump(node, stream, *, indentation='    ', newline='\n', depth=0, debug=False): ...
  > ````
  >
  > Process and write out a node tree to a stream.
  >
  >
  > #### Parameters
  > * > ***node:***
  >   > Base node of node tree.
  > * > ***stream:***
  >   > An object with a 'write' method.
  > * > ***indentation:***
  >   > String used for indents in the output.
  > * > ***newline:***
  >   > String used for newlines in the output.
  > * > ***depth:***
  >   > Base depth (i.e. number of indents) to start at.
  > * > ***debug:***
  >   > If True, will print out extra info when an error


pkgId: 1ae31820145bcfc9ef6a8ff7fbee46542edef67a028a160915467744faa5eff9
name: python-101703383-python-package2
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: This is my second package in python.
url: https://github.com/pypa/sampleproject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-101703383-python-package2-0.0.3-1.src.rpm
checksum_type: sha256
description:
  One of my exposures to python made me understand that Python is one of the powerful languages we have.


pkgId: eef7b3e61c28d64af3a5f41beba61575459c70aabdcb95dc41a5cff442ecfc09
name: python-102003712
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: A Topsis Package
url: https://pypi.org/project/102003712/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-102003712-0.0.6-1.src.rpm
checksum_type: sha256
description:
  It takes 4 arguments :</br>
  1.Data.csv file</br>
  2.Weights</br>
  3.Impacts</br>
  4.Result file</br></br>

  Return file with Ranks and Topsis Score</br>


  Open terminal and type topsis data file name weights impacts result file name</br></br>
  ex: topsis data.csv 1,1,1,1 +,+,-,+ resullt.csv


pkgId: 8661483ef3a88de94daa95cc9c337c9f9372984a0a9b6020980906894da8f76f
name: python-102053005-Aditya-Topsis
arch: src
version: 0.11
epoch: 0
release: 1
summary: This is a package for implementing Topsis
url: https://github.com/Adityakalhan/102053005-Aditya-Topsis
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-102053005-Aditya-Topsis-0.11-1.src.rpm
checksum_type: sha256
description:
  Roll Number : 102053005
  Subgroup : 3COE18
  It takes a csv file, weights (seperated by comma) , impacts (+ or -) and outputs a result file.

  TOPSIS is based on the fundamental premise that the best solution has the shortest distance from the positive-ideal solution, and the longest distance from the negative-ideal one.<br>
  Selecting an appropriate Multiple Attribute Decision Making (MADM) method for a given MADM problem is always a challenging task.<br>
  Within the MADM domain, the Technique for Order Preference by Similarity to Ideal Solution (TOPSIS) is highly regarded, applied and adopted MADM method due to its simplicity and underlying concept that the best solution is the one closest to the positive ideal solution and furthest from the negative ideal solution.<br>



  Use pip installer <br>
  ``` pip install 102053005-Aditya-Topsis ```


  Open terminal and type <br>
  ``` 102053005 sample.csv "1,1,1,1" "+,+,-,+" result.csv ```


  | Model | Storage Space | Camera | Price | Looks |
  |-----------|:-----------:|-----------:|-----------:|-----------:|
  | M1 | 16 | 12 | 250 | 5 |
  | M2 | 16 | 8 | 200 | 3 |
  | M3 | 32 | 16 | 300 | 4 |
  | M4 | 32 | 8 | 275 | 4 |
  | M5 | 16 | 16 | 225 | 2 |

  weights = [1,1,1,1] <br>
  impact = ["+","+","-","+"]



  | Model | Storage Space | Camera | Price | Looks | Topsis Score | Rank |
  |-----------|:-----------:|-----------:|-----------:|-----------:|-----------:|-----------:|
  | M1 | 16 | 12 | 250 | 5 |  0.534269 | 3 |~
  | M2 | 16 | 8 | 200 | 3 |  0.308314 | 5 |
  | M3 | 32 | 16 | 300 | 4 |  0.691686 | 1 |
  | M4 | 32 | 8 | 275 | 4 |  0.534807 | 2 |
  | M5 | 16 | 16 | 225 | 2 |  0.401222 | 4 |

  Output will be saved in a CSV file whose name will be provided in the command line.
  It will have all the columns along with the Topsis Score and Ranks.<br><br>


pkgId: 79f03f626edf54e3e0b353cdba1ff950d6cf919c4b08409756d5686da8253dd6
name: python-102116078-topsis-py
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Implementation of Topsis in Python
url: https://pypi.org/project/102116078-topsis-py/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-102116078-topsis-py-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Implementation of Topsis in Python by rno. 102116078



  ```bash
  pip install topsis-py
  ```


  ```bash
  topsis <InputDataFile> <Weights> <Impacts> <ResultFileName>
  ```

  Where
  ```
  <InputDataFile>: Path to the input CSV file.

  <Weights>: Comma-separated weights for each criterion.

  <Impacts>: Comma-separated impacts ('+' for maximization, '-' for minimization).

  <ResultFileName>: Name of the file to save the results.
  ```


  ```bash
  python topsis input.csv '1,1,2,1' '+,+,-,+' results.csv
  ```


pkgId: 0c62f5133cb37a14d23966900aa8fdce6feceaa6fc9152d26ed652e001790798
name: python-115wangpan
arch: src
version: 0.7.6
epoch: 0
release: 1
summary: Unofficial Python API wrapper for 115.com
url: https://github.com/shichao-an/115wangpan
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-115wangpan-0.7.6-1.src.rpm
checksum_type: sha256
description:
  |Build| |PyPI version|
  115 Wangpan (115网盘 or 115云) is an unofficial Python API and SDK for 115.com. Supported Python verisons are 2.6, 2.7, 3.3, 3.4.
  * Documentation: http://115wangpan.readthedocs.org
  * GitHub: https://github.com/shichao-an/115wangpan
  * PyPI: https://pypi.python.org/pypi/115wangpan/


pkgId: 521b7aff470a5affdfd00da31957e439d06679753a5e8f8e88365eee5de009de
name: python-123tv-iptv
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: 123TV Free IPTV
url: https://github.com/interlark/123tv-iptv
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-123tv-iptv-0.1.3-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
      <h1>
          <a href="#">
              <img alt="123TV-IPTV Logo" width="50%" src="https://user-images.githubusercontent.com/20641837/188281506-11413220-3c65-4e26-a0d1-ed3f248ea564.svg"/>
          </a>
      </h1>
  </div>


  <div align="center">
      <a href="https://github.com/interlark/123tv-tvguide/actions/workflows/tvguide.yml"><img alt="TV Guide status" src="https://github.com/interlark/123tv-tvguide/actions/workflows/tvguide.yml/badge.svg"/></a>
      <a href="https://pypi.org/project/123tv-iptv"><img alt="PyPi version" src="https://badgen.net/pypi/v/123tv-iptv"/></a>
      <a href="https://pypi.org/project/123tv-iptv"><img alt="Supported platforms" src="https://badgen.net/badge/platform/Linux,macOS,Windows?list=|"/></a>
  </div><br>

  **123TV-IPTV** is an app that allows you to watch **free IPTV**.

  It **extracts stream URLs** from [123tv.live](http://123tv.live/) website, **generates master playlist** with available TV channels for IPTV players and **proxies the traffic** between your IPTV players and streaming backends.

  > **Note**: This is a port of [ustvgo-iptv app](https://github.com/interlark/ustvgo-iptv) for 123TV service.


  - 🔑 Auto auth-key rotation
    > As server proxies the traffic it can detect if your auth key is expired and refresh it on the fly.
  - 📺 Available [TV Guide](https://github.com/interlark/123tv-tvguide)
    > [TV Guide](https://github.com/interlark/123tv-tvguide) repo generates EPG XML for upcoming programs of all the channels once an hour.
  - [![](https://user-images.githubusercontent.com/20641837/173175879-aed31bd4-b188-4681-89df-5ffc3ea05a82.svg)](https://github.com/interlark/123tv-tvguide/tree/master/images/icons/channels)
  Two iconsets for IPTV players with light and dark backgrounds
    > There are 2 channel iconsets adapted for apps with light and dark UI themes.
  - 🗔 Cross-platform GUI
    > GUI is available for Windows, Linux and MacOS for people who are not that much into CLI.



  - **CLI**
    ```bash
    pip install 123tv-iptv
    ```
  - **GUI**

    You can download GUI app from [Releases](https://github.com/interlark/123tv-iptv/releases/latest) for your OS.
  - **Docker**
    ```bash
    docker run -d --name=123tv-iptv -p 6464:6464 --restart unless-stopped ghcr.io/interlark/123tv-iptv:latest
    ```
    > For dark icons append following argument: `--icons-for-light-bg`



    You can run the app without any arguments.
    ```
    123tv-iptv
    ```

    <img alt="123TV-IPTV CLI screencast" width="666" src="https://user-images.githubusercontent.com/20641837/192028421-592d8b27-bfa0-4444-aa20-e7b1ea1f05da.gif"/>


  | Optional argument                  | Description |
  | :---                      |    :----   |
  | --icons-for-light-bg      | Switch to dark iconset for players with light UI.       |
  | --access-logs             | Enable access logs for tracking requests activity.        |
  | --port 6464               | Server port. By default, the port is **6464**.           |
  | --parallel 10             | Number of parallel parsing requests. Default is **10**.          |
  | --use-uncompressed-tvguide| By default, master playlist has a link to **compressed** version of TV Guide:<br/>`url-tvg="http://127.0.0.1:6464/tvguide.xml.gz"`<br/>With this argument you can switch it to uncompressed:<br/>`url-tvg="http://127.0.0.1:6464/tvguide.xml"`           |
  | --keep-all-channels       | Do not filter out not working channels.

  <br />

  **Linux** users can install **systemd service** that automatically runs 123tv-iptv on start-ups ⏰.

  ```bash

  sudo -E env "PATH=$PATH" 123tv-iptv install-service


  sudo -E env "PATH=$PATH" 123tv-iptv --port 1234 --access-logs install-service


  sudo -E env "PATH=$PATH" 123tv-iptv uninstall-service
  ```


    <img alt="123TV-IPTV GUI screenshot" width="614" src="https://user-images.githubusercontent.com/20641837/192025393-c5b089e6-8311-4f57-af78-8f125cce71cc.png"/>

    If you don't like command line stuff, you can run GUI app and click "Start", simple as that.

    GUI uses **config file** on following path:

    * **Linux**: ~/.config/123tv-iptv/settings.cfg
    * **Mac**: ~/Library/Application Support/123tv-iptv/settings.cfg
    * **Windows**: C:\Users\\%USERPROFILE%\AppData\Local\123tv-iptv\settings.cfg


  To play and enjoy your free IPTV you need 2 URLs that this app provides:
  1) Your generated **master playlist**: 🔗 http://127.0.0.1:6464/123tv.m3u8
  2) **TV Guide** (content updates once an hour): 🔗 http://127.0.0.1:6464/tvguide.xml


    Here is a **list** of popular IPTV players.

    **123TV**'s channels have **EIA-608** embedded subtitles. In case if you're not a native speaker and use *TV*, *Cartoons*, *Movies* and *Shows* to learn English and Spanish languages I would recommend you following free open-source cross-platform IPTV players that can handle EIA-608 subtitles:
    - **[VLC](https://github.com/videolan/vlc)**

        This old beast could play **any subtitles**. Unfortunately it **doesn't support TV Guide**.

        - **Play**
          ```bash
          vlc http://127.0.0.1:6464/123tv.m3u8
          ```
    - **[MPV](https://github.com/mpv-player/mpv)**

        Fast and extensible player. It **supports subtitles**, but not that good as VLC, sometimes you could encounter troubles playing roll-up subtitles. Unfortunately it **doesn't suppport TV Guide**.

        - **Play**
          ```bash
          mpv http://127.0.0.1:6464/123tv.m3u8
          ```
    - **[Jellyfin Media Player](https://github.com/jellyfin/jellyfin-media-player)**

      <img alt="Jellyfin Media Player screenshot" width="49%" src="https://user-images.githubusercontent.com/20641837/173175969-cbfe5adc-1dc8-4e3b-946c-fa4e295d8b8c.jpg"/>
      <img alt="Jellyfin Media Player screenshot" width="49%" src="https://user-images.githubusercontent.com/20641837/173175973-8acb076c-e1ac-4d06-96a8-b10a72b2f7d7.jpg"/>

      Comfortable, handy, extensible with smooth UI player. **Supports TV Guide**, has **mpv** as a backend.

      **Supports subtitles**, but there is no option to enable them via user interface. If you want to enable IPTV subtitles you have to use following "Mute" hack.

      - **Enable IPTV subtitles**

        I found a quick hack to force play embedded IPTV subtitles, all you need is to create one file:

        > Linux: `~/.local/share/jellyfinmediaplayer/scripts/subtitles.lua`

        > Linux(Flatpak): `~/.var/app/com.github.iwalton3.jellyfin-media-player/data/jellyfinmediaplayer/scripts/subtitles.lua`

        > MacOS: `~/Library/Application Support/Jellyfin Media Player/scripts/subtitles.lua`

        > Windows: `%LOCALAPPDATA%\JellyfinMediaPlayer\scripts\subtitles.lua`

        And paste following text in there:

        ```lua
        -- File: subtitles.lua
        function on_mute_change(name, value)
            if value then
                local subs_id = mp.get_property("sid")
                if subs_id == "1" then
                    mp.osd_message("Subtitles off")
                    mp.set_property("sid", "0")
                else
                    mp.osd_message("Subtitles on")
                    mp.set_property("sid", "1")
                end
            end
        end

        mp.observe_property("mute", "bool", on_mute_change)
        ```
        After that every time you mute a video *(🅼 key pressed)*, you toggle subtitles on/off as a side effect.

      - **Play**
        ```
        1) Settings -> Dashboard -> Live TV -> Tuner Devices -> Add -> M3U Tuner -> URL -> http://127.0.0.1:6464/123tv.m3u8
        2) Settings -> Dashboard -> Live TV -> TV Guide Data Providers -> Add -> XMLTV -> URL -> http://127.0.0.1:6464/tvguide.xml
        3) Settings -> Dashboard -> Scheduled Tasks -> Live TV -> Refresh Guide -> Task Triggers -> "Every 30 minutes"
        ```
      - **Note**
        ```
        Some versions does not support compressed (*.xml.gz) TV Guides.
        ```

    - **[IPTVnator](https://github.com/4gray/iptvnator)**

      <img alt="IPTVnator screenshot" width="666" src="https://user-images.githubusercontent.com/20641837/173176009-a2e86f74-46ef-464a-bbdf-9137f1d48201.jpg"/>

      Player built with [Electron](https://github.com/electron/electron) so you can run it even in browser, has light and dark themes.

      **Support subtitles and TV Guide.**

      - **Play**
        ```
        1) Add via URL -> http://127.0.0.1:6464/123tv.m3u8
        2) Settings -> EPG Url -> http://127.0.0.1:6464/tvguide.xml.gz
        ```


  - [123tv.live](http://123tv.live/) is wonderful project which can offer you a free IPTV, please support these guys buying VPN with their referral link.

  - Also I would highly appreciate your support on this project ⠀<a href="https://www.buymeacoffee.com/interlark" target="_blank"><img alt="Buy Me A Coffee" src="https://cdn.buymeacoffee.com/buttons/default-orange.png" width="178" height="41"></a>


pkgId: ee2cd20494d0462a1afe89090135240ae977acef080801a3d747a36afea711da
name: python-12factor-configclasses
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Like dataclasses but for config.
url: https://github.com/kingoodie/configclasses
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-12factor-configclasses-2.0.1-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/12factor-configclasses)
  [![codecov](https://codecov.io/gh/headsrooms/configclasses/branch/master/graph/badge.svg?token=U0bxsmAUoe)](https://codecov.io/gh/headsrooms/configclasses)
  <a href="https://codeclimate.com/github/kingoodie/configclasses/maintainability"><img src="https://api.codeclimate.com/v1/badges/9094f65f5caef64fb993/maintainability" /></a>
  [![Downloads](https://pepy.tech/badge/12factor-configclasses)](https://pepy.tech/project/12factor-configclasses)
  [![Downloads](https://pepy.tech/badge/12factor-configclasses/month)](https://pepy.tech/project/12factor-configclasses)


  Like dataclasses but for config.

  Specify your config with a class and load it with your env vars or env files.

  ```.env

  HOST=0.0.0.0
  PORT=8000
  ...
  ```


  ```python
  import httpx
  from configclasses import configclass


  @configclass
  class ClientConfig:
      host: str
      port: int


  class UserAPIClient(httpx.AsyncClient):
      def __init__(self, config: ClientConfig, *args, **kwargs):
          self.config = config
          ...


  config = ClientConfig.from_path(".env")
  async with UserAPIClient(config) as client:
      ...
  ```



  - Fill your configclasses with existent env vars.
  - Define default values in case these variables have no value at all.
  - Load your config files in env vars following [12factor apps](https://12factor.net) recommendations.
  - Support for _.env_, _yaml_, _toml_, _ini_ and _json_.
  - Convert your env vars with specified type in configclass: `int`, `float`, `str` or `bool`.
  - Use nested configclasses to more complex configurations.
  - Specify a prefix with `@configclass(prefix="<PREFIX>")` to append this prefix to your configclass'  attribute names.
  - Config groups (__TODO__): https://cli.dev/docs/tutorial/config_groups/



  Python 3.8+




  Depending on your chosen config file format you can install:

  - .env  ->   ```pip install 12factor-configclasses[dotenv]```
  - .yaml ->   ```pip install 12factor-configclasses[yaml]```
  - .toml ->   ```pip install 12factor-configclasses[toml]```
  - .ini  ->   ```pip install 12factor-configclasses```
  - .json ->   ```pip install 12factor-configclasses```

  Or install all supported formats with:

      pip install 12factor-configclasses[full]



  There are three ways to use it.



  ```.env

  HOST=0.0.0.0
  PORT=8000
  DB_URL=sqlite://:memory:
  GENERATE_SCHEMAS=True
  DEBUG=True
  HTTPS_ONLY=False
  GZIP=True
  SENTRY=False
  ```

  ```python

  from configclasses import configclass


  @configclass
  class DB:
      user: str
      password: str
      url: str


  @configclass
  class AppConfig:
      host: str
      port: int
      db: DB
      generate_schemas: bool
      debug: bool
      https_only: bool
      gzip: bool
      sentry: bool
  ```

  ```python

  from api.config import AppConfig

  app_config = AppConfig.from_path(".env")
  app = Starlette(debug=app_config.debug)

  if app_config.https_only:
      app.add_middleware(
          HTTPSRedirectMiddleware)
  if app_config.gzip:
      app.add_middleware(GZipMiddleware)
  if app_config.sentry:
      app.add_middleware(SentryAsgiMiddleware)

  ...

  register_tortoise(
      app,
      db_url=app_config.db.url,
      modules={"models": ["api.models"]},
      generate_schemas=app_config.generate_schemas,
  )

  if __name__ == "__main__":
      uvicorn.run(app, host=app_config.host, port=app_config.port)
  ```




  The same than before, but instead of:

      app_config = AppConfig.from_path(".env")

  You will do:

      app_config = AppConfig.from_environ()



  ```python
  test_env = """HOST=0.0.0.0
  PORT=8000
  DB_URL=sqlite://:memory:
  GENERATE_SCHEMAS=True
  DEBUG=True
  HTTPS_ONLY=False
  GZIP=True
  SENTRY=False"""
  app_config = AppConfig.from_string(test_env, ".env")
  ```


pkgId: c466baa212f7fb40372ebd026d8259219b6baf49baeac72432d2cbbb58db7fb4
name: python-1337x
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: Unofficial API of 1337x.to
url: https://github.com/hemantapkh/1337x
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-1337x-1.2.6-1.src.rpm
checksum_type: sha256
description:
  torrents.search(query)  | Search for torrents | self,<br>query: `Keyword to search for`,<br>page (Defaults to 1): `Page to view`,<br>category (optional): [category](#available-categories),<br>sortBy (optional): [Sort by](#available-sorting-methods),<br>Order (optional): [order](#available-sorting-order)
  torrents.trending()     | Get trending torrents | self,<br>category (optional): [category](#available-categories),<br>week (Defaults to False): `True for weekely, False for daily`
  torrents.top()          | Get top torrents      | self,<br>category (optional): [category](#available-categories)
  torrents.popular(category)          | Get popular torrents      | self,<br>category: [category](#available-categories),<br>week (Defaults to False): `True for weekely, False for daily`
  torrents.browse(category)          | Browse browse of certain category      | self,<br>category: [category](#available-categories),<br>page (Defaults to 1): `Page to view`
  torrents&#46;info(link or torrentId)          | Get information of a torrent      | self,<br>link: `Link of a torrent` or<br>torrentId: `ID of a torrent`

   - `'movies'`
   - `'tv'`
   - `'games'`
   - `'music'`
   - `'apps'`
   - `'anime'`
   - `'documentaries'`
   - `'xxx'`
   - `'others'`

  - `'time'`
  - `'size'`
  - `'seeders'`
  - `'leechers'`

  - `'desc'` (for descending order)
  - `'asc'` (for ascending order)

  Any contributions you make are **greatly appreciated**.
  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request
  *Thanks to every [contributors](https://github.com/hemantapkh/1337x/graphs/contributors) who have contributed in this project.*

  * [Torrent Hunt](https://github.com/hemantapkh/torrenthunt) - Telegram bot to search torrents.
  Want to list your project here? Just make a pull request.


pkgId: 4190202bb765447f8caa95316579e63b43070704e89ce52f7e22b27124d3ee61
name: python-153957-theme
arch: src
version: 5.0
epoch: 0
release: 1
summary: Theme for sigal generated photo albums
url: https://pypi.org/project/153957-theme/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-153957-theme-5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/153957-theme)](https://pypi.org/project/153957-theme/)
  [![License](https://img.shields.io/github/license/153957/153957-theme)](LICENSE)
  [![Build](https://github.com/153957/153957-theme/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/153957/153957-theme/actions)

  [View demo album here](https://153957.github.io/153957-theme/)




  Web photo gallery templates adapted to my personal preferences.




  This section describes how to install and use this theme.




  Install the `153597-theme` package:

      $ pip install 153957-theme




  In `sigal.conf.py` configuration for an album the `theme` setting should be
  a path to a theme directory. However, since this theme is provided as a Python
  package its location might be harder to get. Two options are available for
  configuration:

  The theme can be configured as a plugin or you can get the path by importing
  the package. By setting is as plugin the theme is automatically set.

  Set `theme` to an empty string and add the theme and menu plugins:

      theme = ''
      plugins = ['theme_153957.theme', 'theme_153957.full_menu', …]

  The alternative:

      from theme_153957 import theme
      theme = theme.get_path()
      plugins = ['theme_153957.full_menu', …]




  Use the settings `head`, `body_prefix`, and `body_suffix` to add additional
  code to the templates. The value of `head` is appended to the `head` element,
  the `body` settings are placed just after the body opening tag (`prefix`) and
  just before the closing body tag (`suffix`). This allows embedding the album
  in your own website.


pkgId: 8fcd6b8eba2c5ae0d2612e276f0651b1605c2a7eae1bc9b66dff4c6f5bc8266b
name: python-1NeuronPerceptron-Pypi-mdnazmulislam0087
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: its an implimentation of Perceptron
url: https://github.com/mdnazmulislam0087/1NeuronPerceptron_Pypi
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-1NeuronPerceptron-Pypi-mdnazmulislam0087-0.0.4-1.src.rpm
checksum_type: sha256
description:
   1Neuron|Perceptron|_Pypi

   """
  author: Nazmul
  email: md.nazmul.islam0087@gmail.com
  """






  ```bash

  pip install 1NeuronPerceptron-Pypi-mdnazmulislam0087==0.0.4

  ```


  ```python





  from oneNeuronPerceptron.perceptron import Perceptron
  from oneNeuronPerceptron.all_utils import prepare_data, save_model, save_plot


  import pandas as pd
  import numpy as np
  import logging
  import os

  logging_str = "[s: s: s] s"
  logging.basicConfig(level=logging.INFO, format=logging_str)



  def main(data, eta, epochs, modelfilename,plotfilename):
      df = pd.DataFrame(data)
      logging.info(f"The dataframe is : {df}")
      X,y = prepare_data(df)
      model = Perceptron(eta=eta, epochs=epochs)
      model.fit(X, y)

      _ = model.total_loss()

      save_model(model, filename=modelfilename)
      save_plot(df, file_name=plotfilename, model=model)

  if __name__=="__main__": # << entry point <<
      OR = {
          "x1": [0,0,1,1],
          "x2": [0,1,0,1],
          "y": [0,1,1,1],
      }

      ETA = 0.3 # 0 and 1
      EPOCHS = 10




      try:
          logging.info(">>>>> starting training >>>>>")
          main(data=OR, eta=ETA, epochs=EPOCHS, modelfilename="or.model", plotfilename="or.png")
          logging.info("<<<<< training done successfully<<<<<\n")
      except Exception as e:
          logging.exception(e)
          raise e
  ```

  1. matplotlib
  2. numpy
  3. pandas
  4. joblib
  5. tqdm


  Using one Neuron Perceptron, We cant make decision boundary for XOR GATe, In summary XOR Gate classification is not possible using one Neuron Perceptron

   
  [official python docs](https://packaging.python.org/tutorials/packaging-projects/)

  [github docs for github actions](https://docs.github.com/en/actions/guides/building-and-testing-python#publishing-to-package-registries)

  [Read me editor](https://readme.so/editor)


  [1Neuron Perceptron](https://github.com/mdnazmulislam0087/1NeuronPerceptron)


pkgId: d897a86d7534ae4cd3d3006257b89bdd5f690348939076683934c46807919dcf
name: python-1Password-Utility
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://github.com/tuklu/1Password_Utility.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-1Password-Utility-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  1Password_Utility is a Python package providing utility functions for interacting with 1Password via the command-line interface (CLI). It simplifies the process of retrieving credentials from 1Password vaults within your Python scripts, making it easier to automate tasks and securely manage sensitive information.

description:
  A collection of utility functions for interacting with 1Password via the command-line interface (CLI).



  - Retrieve credentials (username and password) from 1Password vaults securely within your Python scripts. 🔒
  - Simplifies the process of automating tasks and managing sensitive information. 🤖



  - **1Password:** You need to have 1Password installed and set up on your system.
  - **1Password CLI (`op`):**  Install the 1Password CLI by following the instructions on the [1Password Developer website](https://developer.1password.com/docs/cli/get-started). 🛠️



  ```bash
  pip install 1Password-Utility
  ```


  ```python
  onepassword = __import__('1Password-Utility')


  item_uuid = "your_item_uuid"  # Replace with the actual UUID of your 1Password item
  username, password = onepassword_utils.get_credentials_from_1password(item_uuid)

  if username and password:
      print(f"Username: {username}")
      print(f"Password: {password}")
      
  else:
      print("Failed to retrieve credentials.") 😕
  ```


  Make sure you have the 1Password CLI (op) installed and configured correctly before using this package.
  Handle the retrieved credentials securely within your scripts. Avoid printing them to the console or storing them in plain text. 🛡️


  Contributions are welcome! Please feel free to submit pull requests or open issues if you find any bugs or have suggestions for improvements.


  This project is licensed under the MIT License - see the LICENSE file for details.  


  **Key points:**

  - **Clear sections:** The README is organized into clear sections with headings to make it easy to navigate.
  - **Prerequisites:** The prerequisites section explicitly mentions the need for 1Password and the 1Password CLI.
  - **Installation:** Provides the `pip install` command for easy installation.
  - **Usage:** Includes a concise code example demonstrating how to use the `get_credentials_from_1password` function.
  - **Important notes:** Highlights important considerations for security and setup.
  - **Contributing and License:** Encourages contributions and specifies the license under which the project is released.

  Remember to replace placeholders like `your_item_uuid` and `your-username` with your actual values.

  You can further enhance the README by adding more detailed explanations, additional usage examples, or information about any other functions you might include in your `onepassword_utils` package in the future.

  Let me know if you have any other questions or need help with further refinements!


pkgId: f1c4653728301694d73caf3408f33e9eca0c3656974da96f5ec88211a8d06fe1
name: python-1d3-checkout-sdk
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/dev1d3/checkoutpage-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-1d3-checkout-sdk-1.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a set of libraries in the Python language to ease integration of your service
  with the 1D3 Checkout Page.

  Please note that for correct SDK operating you must have at least Python 3.5.



  ![Payment flow](flow.png)



  Install with pip
  ```bash
  pip install 1d3-checkout-sdk
  ```



  ```python
  from checkout_page_sdk.gate import Gate
  from checkout_page_sdk.payment import Payment

  gate = Gate('secret')
  payment = Payment('402')
  payment.payment_id = 'some payment id'
  payment.payment_amount = 1001
  payment.payment_currency = 'USD'
  payment_url = gate.get_purchase_checkout_page_url(payment)
  ```

  `payment_url` here is the signed URL.



  You'll need to autoload this code in order to handle notifications:

  ```python
  from checkout_page_sdk.gate import Gate

  gate = Gate('secret')
  callback = gate.handle_callback(data)
  ```

  `data` is the JSON data received from payment system;

  `callback` is the Callback object describing properties received from payment system;
  `callback` implements these methods:
  1. `callback.get_payment_status()`
      Get payment status.
  2. `callback.get_payment()`
      Get all payment data.
  3. `callback.get_payment_id()`
      Get payment ID in your system.


pkgId: 2339bd15ea33cf2a637fcd0e066394dba2d59f117c9086fa028e59645a72d495
name: python-1inch.py
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: a Python wrapper for the 1inch API
url: https://github.com/RichardAtCT/1inch_wrapper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-1inch.py-2.0.3-1.src.rpm
checksum_type: sha256
description:
  ![1inch.py](https://raw.githubusercontent.com/RichardAtCT/1inch_wrapper/master/1inchpy.png)

  1inch.py is a wrapper around the 1inch API and price Oracle. It has full coverage of the swap API endpoint and All chains support by 1inch are included in the OneInchSwap and OneInchOracle methods.
  Package also includes a helper method to ease the submission of transactions to the network. Limited chains currently supported.


  The full 1inch swap API docs can be found at https://docs.1inch.io/


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

  ```bash
  pip install 1inch.py
  ```



  A quick note on decimals. The wrapper is designed for ease of use, and as such accepts amounts in "Ether" or whole units.
  If you prefer, you can use decimal=0 and specify amounts in wei. This will also help with any potential floating point errors.


  ```python
  from oneinch_py import OneInchSwap, TransactionHelper, OneInchOracle

  rpc_url = "yourRPCURL.com"
  binance_rpc = "adifferentRPCurl.com"
  public_key = "yourWalletAddress"
  private_key = "yourPrivateKey" #remember to protect your private key. Using environmental variables is recommended.
  api_key = "" # 1 Inch API key

  exchange = OneInchSwap(api_key, public_key)
  bsc_exchange = OneInchSwap(api_key, public_key, chain='binance')
  helper = TransactionHelper(api_key, rpc_url, public_key, private_key)
  bsc_helper = TransactionHelper(api_key, binance_rpc, public_key, private_key, chain='binance')
  oracle = OneInchOracle(rpc_url, chain='ethereum')



  helper.chains




  result = exchange.get_swap("USDT", "ETH", 10, 0.5) # get the swap transaction
  result = helper.build_tx(result) # prepare the transaction for signing, gas price defaults to fast.
  result = helper.sign_tx(result) # sign the transaction using your private key
  result = helper.broadcast_tx(result) #broadcast the transaction to the network and wait for the receipt.


  result = exchange.get_swap("0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9", "0x43dfc4159d86f3a37a5a4b3d4580b888ad7d4ddd", 10, 0.5)



  oracle.get_rate_to_ETH("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", src_token_decimal=6)


  oracle.get_rate(src_token="0x6B175474E89094C44Da98b954EedeAC495271d0F", dst_token="0x111111111117dC0aa78b770fA6A738034120C302")

  exchange.health_check()



  exchange.get_spender()


  exchange.get_approve("USDT")
  exchange.get_approve("0xdAC17F958D2ee523a2206206994597C13D831ec7", amount=100)


  exchange.get_allowance("USDT")
  exchange.get_allowance("0xdAC17F958D2ee523a2206206994597C13D831ec7", send_address="0x12345")


  exchange.tokens



















  exchange.get_quote(from_token_symbol='ETH', to_token_symbol='USDT', amount=1)


























  exchange.get_swap(from_token_symbol='ETH', to_token_symbol='USDT', amount=1, slippage=0.5)































  ```


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

  Thanks to @Makbeta for all of their work in migrating the wrapper to the new 1inch api system.



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


pkgId: e2339899b6fc323ad9c572a3f43dc5ef3b5b5454c20c51715ca4050676193f16
name: python-2023-assignment1-viewscounter
arch: src
version: 0.0.8
epoch: 0
release: 1
url: https://pypi.org/project/2023-assignment1-viewscounter/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2023-assignment1-viewscounter-0.0.8-1.src.rpm
checksum_type: sha256
summary:
  Questo assignment si concentra sulla creazione di un'applicazione che conta e monitora le visualizzazioni degli utenti

description:
  https://gitlab.com/bicoccaprojects/2023_assignment1_viewscounter


  - Ficara Damiano (919386)
  - Ricci Claudio (918956)
  - Toli Emilio (920337)


  Questo README ha lo scopo di fornire una documentazione completa delle decisioni prese durante lo sviluppo della pipeline, spaziando attraverso tutte le sue fasi: Build, Verify, Unit-test, Integration-test, Package, Release e Docs.

  Inoltre, verranno fornite giustificazioni e commenti approfonditi per ciascuna di queste scelte.


  Il primo Assignment del corso di Processo e Sviluppo del Software 2023/2024 si pone come obiettivo la realizzazione di una Pipeline CI/CD che automatizzi il processo di manutenzione di un'applicazione seguendo l'insieme di pratiche DEVOPS, mirando ad abbreviare il ciclo di vita di sviluppo di un sistema e soprattutto fornendo una consegna continua di software qualitativamente elevato.

  La decisione di sviluppare l'applicazione in Python è stata presa con l'obiettivo di semplificare lo sviluppo della pipeline CI/CD. Rispetto ad altri linguaggi, come Java, Python offre un'esperienza di sviluppo più agevole in questo contesto. Ad esemppio, Java richiederebbe l'utilizzo di strumenti e librerie specifiche per la gestione dei processi di CI/CD, mentre Python offre una serie di vantaggi che consentono di implementare e gestire la pipeline in modo più diretto ed efficiente.


  L'obiettivo principale dell'assignment non è l'implementazione dell'applicazione in sé. Pertanto, è stata scelta la realizzazione di un sistema estremamente semplice denominato "**Views Counter**". Questo sistema fa uso del database _Firebase_ per tenere traccia del numero di visualizzazioni effettuate da ciascun utente all'interno del sistema.

  All'avvio dell'applicazione, agli utenti viene richiesto di specificare il proprio nome e, in seguito, l'applicazione verifica se tale nome è già presente nel database:

  - in caso di risposta affermativa, il sistema incrementa il conteggio delle visualizzazioni associate a quell'utente e restituisce il valore aggiornato.

  - se, invece, si tratta della prima volta in cui quel nome viene inserito, il sistema restituisce un valore iniziale di 1.


  Di seguito vengono elencate le fasi che sono state implementate per lo svolgimento dell'assignment:

  - Build
  - Verify
  - Unit-test
  - Integration-test
  - Package
  - Release
  - Docs


  In questa sezione, vengono spiegati alcuni prerequisiti che vengono eseguiti prima dell'avvio dello script con le fasi elencate in precedenza:

  - La pipeline utilizza l'immagine Docker Python più recente come base, definita come segue: `image: python:latest`.\
  L'immagine Docker Python assicura che tutte le fasi della pipeline utilizzino un ambiente coerente, eliminando problemi di compatibilità tra ambienti di sviluppo e produzione. Inoltre, le immagini Docker Python sono in genere rapide da avviare, ottimizzando i tempi di build e test all'interno della pipeline.

  - Viene definita una variabile globale denominata `PIP_CACHE_DIR`, il cui percorso è impostato su `"$CI_PROJECT_DIR/.cache/pip"`.\
  L'utilizzo della cache in una pipeline riveste un ruolo fondamentale nel migliorare l'efficienza, la velocità e la coerenza del processo di sviluppo del software. Tale pratica consente di ottimizzare l'uso delle risorse e garantisce un flusso di lavoro più agevole.
  - Inoltre, viene eseguito uno stage di "before_script" che si occupa di effettuare alcune azioni necessarie a far eseguire con successo gli stages successivi:
      - `pip --version` seguito da `pip install --upgrade pip` che si occupano di verificare e aggiornare la versione di `pip`;
      - Viene creato e poi attivato un ambiente virtuale per isolare tutte le operazioni Python all'interno del progetto con `python -m venv venv` e `source venv/bin/activate`. L'ambiente virtuale consente di installare e gestire le dipendenze specifiche per il progetto senza interferire con il sistema globale.


  Alcuni stages contengono un comando che indica che lo stage in questione, e quindi la pipeline, deve essere eseguita solo quando ci si trova sul branch `main`. In questo modo ci siamo assicurati di non far partire la pipeline, e quindi di perdere minuti di utilizzo, durante l'esecuzione di modifiche su branch diversi dal principale.


  La compilazione del progetto viene eseguita attraverso il seguente comando: `pip install -r requirements.txt`.

  Questa scelta è motivata da diverse ragioni che contribuiscono alla semplificazione del processo di installazione delle librerie esterne necessarie per l'esecuzione dell'applicazione. In questo modo, la specifica delle librerie e delle relative versioni richieste è concentrata in un file esterno denominato "requirements.txt". Questo approccio centralizzato semplifica notevolmente la gestione delle dipendenze, consentendo di elencare in modo chiaro e ordinato tutte le librerie necessarie per l'applicazione. Inoltre, l'utilizzo di un file di requisiti esterno permette di aggiungere o modificare librerie senza la necessità di apportare modifiche alla pipeline stessa. In altre parole, se si desidera inserire una nuova libreria o aggiornare una versione, è sufficiente aggiornare il file "requirements.txt". Questo aumenta l'agilità nello sviluppo, poiché non è richiesta alcuna modifica al processo di build della pipeline.

  In definitiva, l'uso del file "requirements.txt" per la gestione delle dipendenze promuove l'efficienza, l'agilità, la tracciabilità e la riduzione degli errori nel processo di CI/CD, offrendo un approccio robusto per gestire le librerie necessarie all'esecuzione dell'applicazione.


  La fase di "verify" nella pipeline di sviluppo, come da specifiche dell'assignment, utilizza due comandi per eseguire controlli di qualità del codice e identificare possibili problematiche di sicurezza prima di procedere ulteriormente nello sviluppo dell'applicazione.

  Dato che questi due comandi sono indipendenti l'uno dall'altro, si è scelto di scrivere lo scritp di questo stage in modo che esegua due jobs in parallelo per migliorarne le prestazioni. I due jobs eseguono `prospector` e `bandit`, in particolare:
  - "prospector", esegue l'analisi statica del codice alla ricerca di possibili problemi di stile, conformità alle linee guida di codifica, e altre metriche di qualità del codice. In sostanza, garantisce la conformità alle migliori pratiche di sviluppo, assicurando che il codice sia di alta qualità, privo di errori e pronto per il rilascio, migliorando significativamente l'efficienza e la qualità.
  - "bandit" esegue due analisi separate della sicurezza del codice Python per due diverse parti del progetto: "application" (frontend) e "database" (gestione del database). Questa analisi include l'esecuzione del comando `bandit` due volte, una per ciascuna parte del progetto. Utilizzando l'opzione `-r`, Bandit esegue l'analisi in modalità ricorsiva, esaminando tutto il contenuto delle directory specificate, inclusi tutti i file Python presenti al loro interno.


  Un test di unità ha lo scopo di verificare il corretto funzionamento di una singola unità di codice, come un metodo, una funzione o una classe, in modo indipendente dal resto del sistema.\
  In questo contesto, è stato creato un file denominato *test_unit.py* contenente una funzione di test. Questa funzione verifica il collegamento al database, restituendo `True` se la connessione è attiva.

  Per eseguire il test di unità all'interno della pipeline, è stato utilizzato il seguente comando: `pytest tests/test_unit.py`.\
  Questo comando fa uso della libreria di testing _pytest_ per eseguire il test specifico contenuto nel file *test_unit.py*.

  `pytest` è un framework di testing per Python che abbiamo utilizzato per la scrittura e l'esecuzione dei test unitari e dei test di integrazione. Questo framework è in grado di rilevare automaticamente i file di test all'interno del progetto. I file di test sono stati denominati secondo una convenzione di denominazione specifica, devono iniziare con "test_", così che `pytest` li identificherà e li eseguirà quando richiamto.

  Il risultato dell'esecuzione fornirà un responso sul corretto funzionamento del collegamento al database. Se il test restituisce `True`, indica che il collegamento è attivo, confermando il successo del test e la validità della connessione al database.


  Un integration test è una fase necessaria per avere la garanzia che le componenti di un'applicazione non generino problemi nel momento in cui vengono integrate assieme, garantendo che le componenti siano in grado di comunicare tra loro in maniera corretta.\
  Inserendo questo stage nella pipeline i test vengono eseguiti ad ogni modifica del codice sorgente, in modo da garantire la qualità del software.

  Entrando nel contesto della pipeline, l'integration test viene eseguito tramite il seguente comando: `pytest tests/test_integration.py`. Questo test esegue due principali controlli:

  - Dopo aver inizializzato _Firebase_, ottiene il valore dell'utente di prova e verifica se esso sia uguale ad un valore predefinito, ossia 10 ed in tal caso il test passerà correttamente.

  - Il secondo test, sempre dopo aver inizializzato l'istanza di _Firebase_, imposta il valore del contatore dell'utente "damiano" con il valore '5' verificando, poi, che l'incremento funzioni correttamente richiamando la funzione `firebase.increment_counter('damiano')` che restituisce `true` in caso di riuscita dell'operazione.

  L'ultima operazione di questo test consiste nel verificare che il contatore sia stato incrementato correttamente e che quindi abbia valore '6'.


  Durante la fase di Package, il codice sorgente viene trasformato in pacchetti, agevolando così la distribuzione di applicazioni e librerie. I pacchetti sono archivi che includono il codice sorgente e i file necessari all'installazione del software su vari sistemi e ambienti. Questo processo è fondamentale per semplificare la distribuzione e garantire che il software funzioni su diverse piattaforme.

  Nella pipeline questo stage è uno dei più critici ed esegue diverse operazioni per preparare il codice alla distribuzione. Per comprendere meglio questo stage, dividiamo (a fini esplicativi) queste azioni in gruppi.

  1. **Generazione dei Pacchetti**: `python setup.py sdist bdist_wheel` utilizziamo il file `setup.py` per creare pacchetti sorgente e pacchetti `bdist_wheel`. Questo file di configurazione definisce le informazioni relative al progetto Python, come il nome, la versione, l'autore, la descrizione e le dipendenze. Questo file è utilizzato insieme al framework `setuptools`.

  - `sdist` rappresenta il pacchetto sorgente, contenente il codice sorgente e altri file necessari per l'installazione.

  - `bdist_wheel` è un formato di pacchetto binario ottimizzato per la distribuzione su PyPI, che semplifica l'installazione su diverse piattaforme. La pubblicazione su PyPI (pypi.org/) mette a disposizione del pubblico il software Python, facilitando la condivisione e la collaborazione tra sviluppatori.

  2. **Operazioni Preliminari**: prima di poter eseguire il comando appena descritto è necessario effettuare i seguenti comandi:

  - `git config user.email $GIT_EMAIL` e `git config user.name $GIT_NAME` che configurano l'utente Git con l'indirizzo email e il nome specificati nelle variabili d'ambiente `$GIT_EMAIL` e `$GIT_NAME`.

  - `git remote add gitlab_origin $GITLAB_REMOTE_URL` che aggiunge un'origine Git denominata "gitlab_origin" con l'URL specificato nella variabile `$GITLAB_REMOTE_URL`. Di particolare rilevanza è la creazione di un ACCESS_TOKEN con permessi API e di lettura/scrittura per automatizzare il processo di push delle modifiche al repository. Questo access token agisce come una chiave di autenticazione, consentendo di comunicare con il repository in modo sicuro. Questa pratica non solo semplifica il processo di aggiornamento del codice, ma garantisce anche la sicurezza delle operazioni, poiché limita l'accesso solo alle azioni autorizzate

  - `python increment_version.py patch` che esegue lo scritp del file _increment_version_ che si occupa di aggiornare il numero di versione del progetto nel file _setup.py_. E per questo, successivamente, è necessario eseguire `git add setup.py` per aggiungere questo file alle modifiche su cui si eseguirà il comando di _commit_.

  - `git commit -m "incremento versione"` per eseguire il _commit_.

  - `git push gitlab_origin HEAD:main -o ci.skip` che esegue il push delle modifiche al repository remoto e utilizza l'opzione `-o ci.skip` per impedire l'attivazione di una pipeline CI/CD in risposta a questo push.

  3. **Archiviazione dei pacchetti**: l'esecuzione di questo stage produrrà dei pacchetti (artifacts) che vengono archiviati nella directory "dist/".

  **Scelte architetturali**\
  In questo stage della pipeline (e anche in quello successivo), si è scelto di di adottare una pratica sicura utilizzando variabili d'ambiente per nascondere informazioni sensibili, come l'indirizzo email e il nome dell'utente, che sono necessarie per l'esecuzione dei comandi. Questo approccio migliora la sicurezza complessiva del progetto, evitando l'inclusione diretta di dati sensibili nel codice sorgente. Inoltre, l'uso delle variabili d'ambiente facilita la gestione delle configurazioni specifiche per ambienti diversi e garantisce che tali informazioni siano facilmente configurabili senza dover modificare il codice sorgente direttamente.

  **Problemi riscontrati in questo stage**\
  Durante questa fase, è importante prestare attenzione a un aspetto chiave. Il file `setup.py` contiene la versione dell'applicazione, e ogni volta che eseguiamo la pipeline, è necessario aggiornare la versione prima di consentire una seconda esecuzione. Questo passo è fondamentale poiché l'obiettivo è pubblicare l'applicazione su PyPI. Pertanto, per garantire una corretta esecuzione di questa fase, è essenziale verificare che non esista già un'applicazione con lo stesso nome su PyPI e che la versione sia aggiornata ad ogni esecuzione. A questo fine, si è deciso di creare uno scritp _increment_version.py_ che si occupa di aggiornare in modo automatico la versione del progetto.

  **Funzionamento di _increment_version.py_**\
  Nel nostro approccio allo sviluppo dello script _increment_version.py, abbiamo adottato una serie di scelte architetturali mirate per garantire l'efficacia e l'usabilità del programma.\
  La decisione di creare uno script dedicato all'incremento della versione all'interno del file `setup.py` è stata guidata dalla necessità di automatizzare un processo comune in modo semplice ed efficiente. Questo rende più agevole per gli sviluppatori la gestione delle versioni del proprio software e riduce il rischio di errori umani.\
  L'uso di un parametro specifico, come `major`, `minor`, o `patch`, è stato implementato per consentire agli utenti di personalizzare l'azione di incremento. Questa scelta offre flessibilità e controllo, permettendo di adattare l'incremento della versione alle esigenze specifiche del progetto.\
  Ad esempio, se desideriamo introdurre modifiche significative o nuove funzionalità, possiamo utilizzare il parametro `major` per indicare una "versione principale" del software; il parametro `minor` può essere utile per segnalare modifiche minori o aggiunte, mentre `patch` è ideale per correzioni di bug e aggiustamenti minori.\
  Il codice utilizza in modo intelligente le espressioni regolari (regex) per individuare e catturare la versione corrente all'interno del file _setup.py_. Questo approccio garantisce una maggiore precisione nell'estrazione dei dati, consentendo al programma di funzionare in modo affidabile anche in situazioni complesse.


  Questa fase della pipeline è strettamente correlata alla fase precedente di "Package" in quanto, se nella fase di "Package" abbiamo preparato i pacchetti dell'applicazione, in questa fase li pubblichiamo su PyPI.\
  I passi eseguiti da questo stage sono i seguenti:

  - `echo "[pypi]" > ~/.pypirc`, in questo passaggio viene creato un file di configurazione necessario per l'interazione con PyPI. Questo file conterrà le informazioni di autenticazione richieste per l'upload dei pacchetti Python su PyPI.

  - `echo "username = $TWINE_USERNAME" >> ~/.pypirc`, qui, all'interno del file _.pypirc_, specificiamo che lo username per l'autenticazione su PyPI.

  - `echo "password = $TWINE_TOKEN" >> ~/.pypirc`, inseriamo il valore del token API come password nel file _.pypirc_. Il valore del token è recuperato da una variabile globale, $TWINE_TOKEN, definita nelle impostazioni di GitLab. Questo indica che l'autenticazione avviene tramite un token API anziché un nome utente e una password tradizionali.

  - `twine upload dist/*`, questa istruzione permette di caricare su PyPI i pacchetti generati nella fase di "Package" nella directory `dist/`. Viene utilizzato "Twine", che è uno strumento di Python per facilitare l'upload di pacchetti verso repository di pacchetti come PyPI

  **Scelte architetturali**\
  Per eseguire questa fase, è stato necessario creare un account su PyPI. Al fine di rendere la pipeline più professionale e garantire la sicurezza dell'autenticazione, abbiamo optato per una configurazione basata su token API. PyPI consente a ciascun utente di generare un token API personale, eliminando la necessità di condividere le proprie informazioni di account. Questo approccio migliora la sicurezza e semplifica il processo di pubblicazione sul repository PyPI.


  Un progetto di sviluppo di software non è completo senza una documentazione adeguata. La documentazione fornisce agli sviluppatori, agli utenti e agli altri membri del team tutte le informazioni necessarie per comprendere, utilizzare ed estendere il software. Questa fase è dedicata a garantire che la documentazione sia sempre allineata con il codice sorgente e pronta per essere distribuita.

  Questa fase della pipeline è dedicata alla generazione della documentazione e alla sua pubblicazione.\
  Per farlo sono necessarie diverse azioni che dividiamo in tre gruppi.

  1. **Generazione della Documentazione**: `mkdocs build --clean` è il comando principale utilizzato per generare la documentazione del progetto. `mkdocs` è uno strumento di generazione della documentazione che elabora i file Markdown presenti nel repository e crea una versione formattata della documentazione pronta per la distribuzione. L'opzione `--clean` assicura che la cartella di output sia ripulita da vecchi file inutili, garantendo che la nuova documentazione sia fresca e aggiornata.

  2. **Preparazione dei file generati**: `mkdir .public` crea una directory chiamata ".public". in cui successivamente con `cp -r public/* .public` viene copiato ricorsivamente (`-r`) tutto il contenuto della directory "public". Questo passaggio serve a preparare i file della documentazione generata.

  3. **Archiviazione degli Artefatti**: nella sezione degli artifacts, vengono specificati i file o le directory che devono essere conservati per un uso futuro. Viene specificato di conservare il file _mkdocs.yaml_, che è il file di configurazione principale di MkDocs contenente le impostazioni e le informazioni necessarie per generare la documentazione. E anche la directory "public" contenente la documentazione appena generata.

  Una volta finita l'esecuzione di questo stage, la documentazione aggiornata è consultabile al seguente link:\
  https://prova-bicoccaprojects-41fbc084054de9fcac016aa766e308b22287d4b35.gitlab.io/


pkgId: ca0be32294544ae6f202775a4904f618e6655e1718e610cb6ba224c4231c55c7
name: python-2024-assignment2-gruppoBLVG-Matteo
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: 2024_assignment2_gruppoBLVG_
url: https://pypi.org/project/2024-assignment2-gruppoBLVG-Matteo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2024-assignment2-gruppoBLVG-Matteo-0.0.1-1.src.rpm
checksum_type: sha256
description:
  To make it easy for you to get started with GitLab, here's a list of recommended next steps.

  Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!



  - [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
  - [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:

  ```
  cd existing_repo
  git remote add origin https://gitlab.com/gruppo-blvg/2024_assignment2_gruppo_blvg.git
  git branch -M main
  git push -uf origin main
  ```



  - [ ] [Set up project integrations](https://gitlab.com/gruppo-blvg/2024_assignment2_gruppo_blvg/-/settings/integrations)



  - [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
  - [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
  - [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
  - [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
  - [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)



  Use the built-in continuous integration in GitLab.

  - [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
  - [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
  - [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
  - [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
  - [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)

  ***



  When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.



  Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.


  Choose a self-explaining name for your project.


  Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.


  On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.


  Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.


  Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.


  Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.


  Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.


  If you have ideas for releases in the future, it is a good idea to list them in the README.


  State if you are open to contributions and what your requirements are for accepting them.

  For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.

  You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.


  Show your appreciation to those who have contributed to the project.


  For open source projects, say how it is licensed.


  If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.


pkgId: f9724987c2b4f02be6cf9be599c3428e3ff9adf5e30e69f308067442610faebd
name: python-2048
arch: src
version: 0.3.3
epoch: 0
release: 1
url: https://github.com/quantum5/2048
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2048-0.3.3-1.src.rpm
checksum_type: sha256
summary:
  Quantum's version of the 2048 game, with multi-instance support,restored from an old high school project.

description:
  My version of 2048 game, with multi-instance support, restored from
  an old high school project.

  ![2048 Preview](https://guanzhong.ca/assets/projects/2048-2fd91615603e0f5fed0299df4524c4494968c7b1d762cbb0209354cfa2215639.png)



  Run `pip install 2048`.

  Run `2048` to play the game. Enjoy.

  On Windows, you can run `2048w` to run without the console window.



  If for some reason, the data files get corrupted or you want to clear the high score...

  * On Windows, delete `C:\Users\<yourname>\AppData\Roaming\Quantum\2048`.
  * On macOS, delete `/Users/<yourname>/Library/Application Support/2048`.
  * On Linux, delete `/home/<yourname>/.local/share/2048`.


pkgId: 8a5f67c13583c1d78536cbf1dc691c8728acc8d825df12e6a440d7b2f7bb5893
name: python-2048-py
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: 2048 written in Python by the Ladue High School Computer Science Club
url: https://github.com/Ta180m/2048
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2048-py-0.1.6-1.src.rpm
checksum_type: sha256
description:
  It's 2048, written in Python by the Ladue High School Computer Science Club. It's still in its early stages, so expect bugs!







  Download or clone this repo, then run `python3 main.py`.

  If Python complains about `termcolor`, install it with `pip install termcolor`.




  Run it online on [Repl.it](https://repl.it/@Ta180m/2048#main.py).




  Install with `pip install 2048-py`.

  Run `2048-py` to play the game.




  On Arch Linux, get the `2048-py` package from the AUR.

  Run `2048-py` to play the game.


pkgId: 51b97d9fcc48b0bc0e96dadddcf54e12b1afa6c2859b1de20713db2141bd52ce
name: python-20XX
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: =?utf-8?b?MjBYWCBpcyBhIFBldHRpbmdab28tYmFzZWQgbGlicmFyeSBmb3IgTWVsZWUuICjijJDilqBf4pagKQ==?=
url: https://github.com/WillDudley/20XX
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-20XX-0.1.2-1.src.rpm
checksum_type: sha256
description:
  `from melee_20XX import Melee_v0`
  20XX is a PettingZoo-based library for Melee. (⌐■_■)

  ```python
  import os.path
  import melee
  from melee_20XX import Melee_v0
  from melee_20XX.agents.basic import CPUFox, RandomFox
  players = [RandomFox(), CPUFox()]
  env = Melee_v0.env(players, os.path.expanduser('~/.melee/SSBM.ciso'), fast_forward=True)
  max_episodes = 10
  if __name__ == "__main__":
      env.start_emulator()
      for episode in range(max_episodes):
          observation, infos = env.reset(melee.enums.Stage.FOUNTAIN_OF_DREAMS)
          gamestate = infos["gamestate"]
          terminated = False
          while not terminated:
              actions = []
              for player in players:
                  if player.agent_type == "CPU":  # CPU actions are handled internally
                      action = None
                  else:
                      action = player.act(gamestate)
                  actions.append(action)
              observation, reward, terminated, truncated, infos = env.step(actions=actions)
              gamestate = infos["gamestate"]
  ```

  This library requires Slippi, which in turn requires an SSBM 1.02 NTSC/PAL ISO. This library does not and will not distribute this. You must acquire this on your own!

  `pip install 20XX`
  `pip install git+https://github.com/WillDudley/libmelee.git`  (fixes some menu handling issues)

  - Heavily relies on [libmelee](https://github.com/altf4/libmelee),
  - uses [PettingZoo](https://pettingzoo.farama.org),
  - originally forked from [melee-env](https://github.com/davidtjones/melee-env).


pkgId: 72fe89b80b36b500e172d7f62bc0717a8e84f4275fcc3b34f4b5fa46548b2b91
name: python-23andme-to-vcf
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A simple script to convert 23andMe raw data files to VCF format.
url: https://github.com/david-wb/23andme_to_vcf
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-23andme-to-vcf-0.0.3-1.src.rpm
checksum_type: sha256
description:
  A simple command-line tool to convert 23andMe raw data files to VCF format.


  ```
  pip install 23andme-to-vcf
  ```



  ```
  23andme-to-vcf --input in.txt --fasta GRCh37.fa --fai GRCh37.fa.fai --output out.vcf
  ```


pkgId: 4b60b8b0b929e8841aa659abc1303835d0aac1027ce3e772fe468eff0bb22278
name: python-2404-segmentation-pipeline
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/2404-Organ-Segmentation/segmentation-pipeline
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2404-segmentation-pipeline-1.0.0-1.src.rpm
checksum_type: sha256
description:
  This package implements a machine learning pipeline for semantic segmentation on medical images. The package is a wrapper on monai and supports training and inference for UNETR and Swin-UNETR on arbitrary dataset. Development focused on BTCV(abdomen), MSD, and BRaTs datasets.


  1. Install segmentation pipeline package using
      ```
      pip install 2404-segmentation-pipeline
      ```
  2. Install pytorch.
     - If on windows
      ```
      pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
      ```
     - If on Linux
      ```
      pip3 install torch torchvision torchaudio
      ```
  3. (Optional) When working with BtCV dataset, the Swin-UNETR architecture offers self-supervised pretrained model on the dataset. When using pre-trained model before training, it allows the model to converge faster. Download the pretrained self-supervised model [here](https://github.com/Project-MONAI/MONAI-extra-test-data/releases/download/0.8.1/model_swinvit.pt)



  Documention is provided [here](https://raw.githack.com/2404-Organ-Segmentation/segmentation-pipeline/main/docs/html/pipeline.html#pipeline.Pipeline)


  ```
  from pipeline Import Pipeline
  from monai.transforms import (
      AsDiscrete,
      EnsureChannelFirstd,
      Compose,
      CropForegroundd,
      LoadImaged,
      Orientationd,
      RandFlipd,
      RandCropByPosNegLabeld,
      RandShiftIntensityd,
      ScaleIntensityRanged,
      Spacingd,
      RandRotate90d,
      ResizeWithPadOrCropd,
      )


  pipeline = Pipeline(model_type="UNETR", modality=1, num_of_labels=14,
                         model_path="", debug=True)


  train_transforms = Compose(
      [
          LoadImaged(keys=["image", "label"]),
          EnsureChannelFirstd(keys=["image", "label"]),
          Orientationd(keys=["image", "label"], axcodes="RAS"),
          Spacingd(
              keys=["image", "label"],
              pixdim=(1.5, 1.5, 2.0),
              mode=("bilinear", "nearest"),
          ),
          ScaleIntensityRanged(
              keys=["image"],
              a_min=-175,
              a_max=250,
              b_min=0.0,
              b_max=1.0,
              clip=True,
          ),
          CropForegroundd(keys=["image", "label"], source_key="image"),
          RandCropByPosNegLabeld(
              keys=["image", "label"],
              label_key="label",
              
              spatial_size=(96, 96, -1),
              pos=1,
              neg=1,
              num_samples=4,
              image_key="image",
              image_threshold=0,
          ),
          ResizeWithPadOrCropd(keys=["image", "label"],
              spatial_size=(96, 96, 96),
              mode='constant'
          ),
          RandFlipd(
              keys=["image", "label"],
              spatial_axis=[0],
              prob=0.10,
          ),
          RandFlipd(
              keys=["image", "label"],
              spatial_axis=[1],
              prob=0.10,
          ),
          RandFlipd(
              keys=["image", "label"],
              spatial_axis=[2],
              prob=0.10,
          ),
          RandRotate90d(
              keys=["image", "label"],
              prob=0.10,
              max_k=3,
          ),
          RandShiftIntensityd(
              keys=["image"],
              offsets=0.10,
              prob=0.50,
          ),
      ]
  )


  val_transforms = Compose(
      [
          LoadImaged(keys=["image", "label"]),
          EnsureChannelFirstd(keys=["image", "label"]),
          Orientationd(keys=["image", "label"], axcodes="RAS"),
          Spacingd(
              keys=["image", "label"],
              pixdim=(1.5, 1.5, 2.0),
              mode=("bilinear", "nearest"),
          ),
          ScaleIntensityRanged(keys=["image"], a_min=-175, a_max=250, b_min=0.0, b_max=1.0, clip=True),
          CropForegroundd(keys=["image", "label"], source_key="image"),
      ]
  )


  trainer.train(150,10)


  inf_transforms = Compose(
      [
          LoadImaged(keys=["image"]),
          EnsureChannelFirstd(keys=["image"]),
          Orientationd(keys=["image"], axcodes="RAS"),
          Spacingd(
              keys=["image"],
              pixdim=(1.5, 1.5, 2.0),
              mode="bilinear",
          ),
          ScaleIntensityRanged(keys=["image"], a_min=-175, a_max=250, b_min=0.0, b_max=1.0, clip=True),
          CropForegroundd(keys=["image"], source_key="image"),
      ]
  )


  trainer.inference(data_folder = 'path/to/inference/data/folder', output_folder="path/to/output/folder", transforms=inf_transforms)
  ```


pkgId: 6d1cd46f82409fff2dd805393b8c73830aa934f854c2dc6e0375ca3e62563e47
name: python-24p
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: 24Point
url: https://github.com/lingjf/24p
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-24p-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] * 4

  总共有91390种组合,其中79936种有解,有解率87.47%

  去重后715种组合,其中566种有解,有解率79.16%



  ```Python
  [1, 2, 7, 7]   24=(7*7-1)/2
  [3, 8, 8, 10]   24=(8*10-8)/3
  [4, 4, 10, 10]   24=(10*10-4)/4
  ```


  ```Python
  [6, 9, 9, 10]   24=9*10/6+9
  ```


  ```Python
  [1, 3, 4, 6]   24=6/(1-3/4)
  [1, 4, 5, 6]   24=6/(5/4-1)
  [1, 6, 6, 8]   24=6/(1-6/8)
  [3, 3, 8, 8]   23=8/(3-8/3)
  ```


  ```Python
  [1, 5, 5, 5]   24=(5-1/5)*5
  [2, 2, 7, 10]   24=(10/2+7)*2
  [2, 4, 10, 10]   24=(4/10+2)*10
  [2, 7, 7, 10]   24=(10/7+2)*7
  [3, 3, 7, 7]   24=(3/7+3)*7
  [4, 4, 7, 7]   24=(4-4/7)*7
  ```


  ```Python
  [2, 5, 5, 10]   24=(5-2/10)*5
  ```


  ```Python
  [1, 5, 6, 6]   24=5*6-1*6
  [2, 3, 3, 10]   24=3*10-2*3
  [2, 5, 8, 8]   24=5*8-2*8
  [5, 6, 6, 9]   24=6*9-5*6
  [6, 6, 6, 10]   24=6*10-6*6
  [6, 8, 8, 9]   24=8*9-6*8
  [7, 8, 8, 10]   24=8*10-7*8
  ```


  ```Python
  2*12=24
  3*8=24
  4*6=24
  12+12=24
  14+10=24
  15+9=24
  16+8=24
  17+7=24
  18+6=24
  20+4=24
  21+3=24
  25-1=24
  28-4=24
  30-6=24
  32-8=24
  35-11=24
  36-12=24
  40-16=24

  7+8+9=24
  8+8+8=24
  2*8+8=24
  4*8-8=24

  ```


pkgId: 245768769584f6a66a7add7dffa7218107bf53e269684bb661e09166d58d713b
name: python-24ur-api
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Unofficial 24ur API
url: https://github.com/amadejkastelic/24ur-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-24ur-api-0.1.5-1.src.rpm
checksum_type: sha256
description:
  ```bash
  pip install 24ur-api
  ```
  - With video download support
  ```bash
  pip install 24ur-api[video]
  ```



  ```python
  from api_24ur import client

  cl = client.Client()


  article = await cl.get_article_by_url(url='<article_url>', num_comments=10)


  await cl.download_video(stream_url=article.videos[0].url, download_path='.', max_bitrate=2000000)

  await cl.download_video_bytes(stream_url=article.videos[0].url, max_bitrate=2000000)
  ```


pkgId: 2bdab3b3484deb30f190fd2f4aa717ae29de1b7dc7e0ada9bfa9a4144888bba3
name: python-24ur-api
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Unofficial 24ur API
url: https://github.com/amadejkastelic/24ur-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-24ur-api-0.1.6-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/license-MIT-C06524)](https://github.com/amadejkastelic/24ur-api/blob/main/LICENSE)
  [![PyPI - Version](https://img.shields.io/pypi/v/24ur-api.svg)](https://pypi.org/project/24ur-api/)
  [![Downloads](https://static.pepy.tech/badge/24ur-api)](https://pepy.tech/project/24ur-api)



  ```bash
  pip install 24ur-api
  ```
  - With video download support
  ```bash
  pip install 24ur-api[video]
  ```



  ```python
  from api_24ur import client

  cl = client.Client()


  article = await cl.get_article_by_url(url='<article_url>', num_comments=10)


  await cl.download_video(stream_url=article.videos[0].url, download_path='.', max_bitrate=2000000)

  await cl.download_video_bytes(stream_url=article.videos[0].url, max_bitrate=2000000)
  ```


pkgId: 7c42139e3b1f3d57c765f078b2e105613a76baf6d351d3c10dc26900b752d568
name: python-2Keys
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A easy to setup second keyboard, designed for everyone.
url: https://github.com/Gum-Joe/2Keys
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2Keys-0.5.1-1.src.rpm
checksum_type: sha256
description:
  A easy to setup second keyboard, designed for everyone.

  For a full setup guide, see [here](https://github.com/Gum-Joe/2Keys/blob/master/docs/SETUP.md)

  For keyboard mappings, see [here](https://github.com/Gum-Joe/2Keys/blob/master/docs/MAPPINGS.md)


  Windows is supported only as the server (where the hotkeys will run) and a raspberry pi is required to run the detector.


  This will download a copy of [AutoHotkey_H](https://hotkeyit.github.io/v2/), a DLL version of [AutoHotkey](http://autohotkey.com/)


  To build the server, where hotkeys are run:
  ```
  $ cd server
  $ yarn
  ```

  To build the detector:
  ```
  $ cd detector
  $ pip3 install -r required.txt
  ```


  **Server**: The device running the hotkeys sever, i.e. where the hot keys will be run

  **Detecter**: Device that handles detection of key presses & which keyboard it is and sends this to the server



  Inspired by LTT editor Taran's second keyboard project: [https://github.com/TaranVH/2nd-keyboard](https://github.com/TaranVH/2nd-keyboard)

  2Keys uses AutoHotkey_H (a DLL version of AutoHotkey): [https://hotkeyit.github.io/v2/](https://hotkeyit.github.io/v2/)


  Copyright 2018 Kishan Sambhi

  2Keys is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  2Keys 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with 2Keys.  If not, see <https://www.gnu.org/licenses/>.


pkgId: f7c4ddc391fb062296b4159aa648417ee92b7d94134da9b46b3d4dbba1b59f6e
name: python-2b2t
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A 2b2t toolbox.
url: https://github.com/keuin/2b2t
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2b2t-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This is a simple commandline utility which polls *2b2t*'s server status and print it.



  - Install Python (>=3.7).
  - Execute `pip install 2b2t`.
  - Run `2b2t`.


pkgId: 8fa2c5e66dac5aa4f4f155ff5be5c858e2dd87bc9250de882d653fa038f5035d
name: python-2captcha-python
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Python module for easy integration with 2Captcha API
url: https://github.com/2captcha/2captcha-python/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2captcha-python-1.5.0-1.src.rpm
checksum_type: sha256
description:
  <a href="https://github.com/2captcha/2captcha-python"><img src="https://github.com/user-attachments/assets/a737d428-5233-4605-9d09-211fa213d069" width="82" height="30"></a>
  <a href="https://github.com/2captcha/2captcha-javascript"><img src="https://github.com/user-attachments/assets/4d3b4541-34b2-4ed2-a687-d694ce67e5a6" width="36" height="30"></a>
  <a href="https://github.com/2captcha/2captcha-go"><img src="https://github.com/user-attachments/assets/ab22182e-6cb2-41fa-91f4-d5e89c6d7c6f" width="63" height="30"></a>
  <a href="https://github.com/2captcha/2captcha-ruby"><img src="https://github.com/user-attachments/assets/0270d56f-79b0-4c95-9b09-4de89579914b" width="75" height="30"></a>
  <a href="https://github.com/2captcha/2captcha-cpp"><img src="https://github.com/user-attachments/assets/36de8512-acfd-44fb-bb1f-b7c793a3f926" width="45" height="30"></a>
  <a href="https://github.com/2captcha/2captcha-php"><img src="https://github.com/user-attachments/assets/e8797843-3f61-4fa9-a155-ab0b21fb3858" width="52" height="30"></a>
  <a href="https://github.com/2captcha/2captcha-java"><img src="https://github.com/user-attachments/assets/a3d923f6-4fec-4c07-ac50-e20da6370911" width="50" height="30"></a>
  <a href="https://github.com/2captcha/2captcha-csharp"><img src="https://github.com/user-attachments/assets/f4d449de-780b-49ed-bb0a-b70c82ec4b32" width="38" height="30"></a>



  The easiest way to quickly integrate the [2Captcha] captcha-solving service into your code and automate the solving of any type of captcha.
  Examples of API requests for different captcha types are available on the [Python captcha solver](https://2captcha.com/lang/python) page.

  - [Python Module for 2Captcha API (captcha solver)](#python-module-for-2captcha-api-captcha-solver)
    - [Installation](#installation)
    - [Configuration](#configuration)
      - [TwoCaptcha instance options](#twocaptcha-instance-options)
    - [Solve captcha](#solve-captcha)
      - [Captcha options](#captcha-options)
      - [Normal Captcha](#normal-captcha)
      - [Audio Captcha](#audio-captcha)
      - [Text Captcha](#text-captcha)
      - [reCAPTCHA v2](#recaptcha-v2)
      - [reCAPTCHA v3](#recaptcha-v3)
      - [FunCaptcha](#funcaptcha)
      - [GeeTest](#geetest)
      - [GeeTest v4](#geetest-v4)
      - [hCaptcha](#hcaptcha)
      - [Lemin Cropped Captcha](#lemin-cropped-captcha)
      - [Cloudflare Turnstile](#cloudflare-turnstile)
      - [Amazon WAF](#amazon-waf)
      - [KeyCaptcha](#keycaptcha)
      - [atbCAPTCHA](#atbcaptcha)
      - [Capy](#capy)
      - [Grid](#grid)
      - [Canvas](#canvas)
      - [ClickCaptcha](#clickcaptcha)
      - [Rotate](#rotate)
      - [MTCaptcha](#mtcaptcha)
      - [Friendly Captcha](#friendly-captcha)
      - [Cutcaptcha](#cutcaptcha)
      - [Tencent](#tencent)
      - [Datadome](#datadome)
      - [CyberSiARA](#cybersiara)
    - [Other methods](#other-methods)
      - [send / get\_result](#send--get_result)
      - [balance](#balance)
      - [report](#report)
    - [Error handling](#error-handling)
    - [Proxies](#proxies)
    - [Async calls](#async-calls)
    - [Examples](#examples)
    - [Examples using Selenium](#examples-using-selenium)
    - [Useful articles](#useful-articles)
    - [Get in touch](#get-in-touch)
    - [Join the team 👪](#join-the-team-)
    - [License](#license)
      - [Graphics and Trademarks](#graphics-and-trademarks)



  This package can be installed with Pip:

  ```bash
  pip3 install 2captcha-python
  ```




  TwoCaptcha instance can be created like this:

  ```python
  from twocaptcha import TwoCaptcha

  solver = TwoCaptcha('YOUR_API_KEY')
  ```
  Also, there are a few options that can be configured:

  ```python
  config = {
              'server':           '2captcha.com',
              'apiKey':           'YOUR_API_KEY',
              'softId':            123,
              'callback':         'https://your.site/result-receiver',
              'defaultTimeout':    120,
              'recaptchaTimeout':  600,
              'pollingInterval':   10,
          }
  solver = TwoCaptcha(**config)
  ```



  | Option           | Default value  | Description                                                                                                                                            |
  | ---------------- | -------------- |--------------------------------------------------------------------------------------------------------------------------------------------------------|
  | server           | `2captcha.com` | API server. You can set it to `rucaptcha.com` if your account is registered there                                                                      |
  | softId           | 4580           | your software ID obtained after publishing in [2captcha software catalog]                                                                              |
  | callback         | -              | URL of your web server that receives the captcha recognition result. The URL should be first registered in [pingback settings] of your account         |
  | defaultTimeout   | 120            | Polling timeout in seconds for all captcha types except reCAPTCHA. Defines how long the module tries to get the answer from the `res.php` API endpoint |
  | recaptchaTimeout | 600            | Polling timeout for reCAPTCHA in seconds. Defines how long the module tries to get the answer from the `res.php` API endpoint                          |
  | pollingInterval  | 10             | Interval in seconds between requests to the `res.php` API endpoint. Setting values less than 5 seconds is not recommended                              |
  | extendedResponse | None           | Set to `True` to get the response with additional fields or in more practical format (enables `JSON` response from `res.php` API endpoint). Suitable for [hCaptcha](#hcaptcha), [ClickCaptcha](#clickcaptcha), [Canvas](#canvas) |


  > [!IMPORTANT]
  > Once `callback` is defined for the `TwoCaptcha` instance, all methods return only the captcha ID and DO NOT poll the API to get the result. The result will be sent to the callback URL.

  To get the answer manually use [get_result method](#send--get_result)


  When you submit any image-based CAPTCHA, you can provide additional options to help 2captcha workers solve it properly.


  | Option        | Default Value | Description                                                                                        |
  | ------------- | ------------- | -------------------------------------------------------------------------------------------------- |
  | numeric       | 0             | Defines if the captcha contains numeric or other symbols [see more info in the API docs][post options] |
  | minLen        | 0             | minimal answer length                                                                              |
  | maxLen        | 0             | maximum answer length                                                                              |
  | phrase        | 0             | defines if the answer contains multiple words or not                                               |
  | caseSensitive | 0             | defines if the answer is case sensitive                                                            |
  | calc          | 0             | defines captcha requires calculation                                                               |
  | lang          | -             | defines the captcha language; see the [list of supported languages]                                |
  | hintImg       | -             | an image with a hint shown to workers with the captcha                                               |
  | hintText      | -             | hint or task text shown to workers with the captcha                                                |

  Below, you can find basic examples for every captcha type. Check out [examples directory] for more examples with all available options.



  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_normal_captcha)</sup>

  To bypass a normal captcha (distorted text on an image) use the following method. This method can also be used to recognize any text in an image.

  ```python
  result = solver.normal('path/to/captcha.jpg', param1=..., ...)

  result = solver.normal('https://site-with-captcha.com/path/to/captcha.jpg', param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#audio)</sup>

  Use the following method to bypass an audio captcha (mp3 formats only).
  You must provide the language as `lang = 'en'`. Supported languages are "en", "ru", "de", "el", "pt", "fr".

  ```python
  result = solver.audio('path/to/captcha.mp3', lang = 'lang', param1=..., ...)

  result = solver.audio('https://site-with-captcha.com/path/to/captcha.mp3', lang = 'lang', param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_text_captcha)</sup>

  This method can be used to bypass a captcha that requires answering a question provided in clear text.
  ```python
  result = solver.text('If tomorrow is Saturday, what day is today?', param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_recaptchav2_new)</sup>

  Use the following method to solve reCAPTCHA V2 and obtain a token to bypass the protection.

  ```python
  result = solver.recaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
                            url='https://mysite.com/page/with/recaptcha',
                            param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_recaptchav3)</sup>

  This method provides a reCAPTCHA V3 solver and returns a token.
  ```python
  result = solver.recaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
                              url='https://mysite.com/page/with/recaptcha',
                              version='v3',
                              param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_funcaptcha_new)</sup>

  FunCaptcha (Arkoselabs) solving method. Returns a token.
  ```python
  result = solver.funcaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
                              url='https://mysite.com/page/with/funcaptcha',
                              param1=..., ...)

  ```




  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_geetest)</sup>

  Method to solve GeeTest puzzle captcha. Returns a set of tokens as JSON.
  ```python
  result = solver.geetest(gt='f1ab2cdefa3456789012345b6c78d90e',
                          challenge='12345678abc90123d45678ef90123a456b',
                          url='https://www.site.com/page/',
                          param1=..., ...)

  ```




  <sup>[API method description.](https://2captcha.com/2captcha-api#geetest-v4)</sup>

  Use this method to solve GeeTest v4. Returns the response in JSON.
  ```python
  result = solver.geetest_v4(captcha_id='e392e1d7fd421dc63325744d5a2b9c73',
                              url='https://www.site.com/page/',
                              param1=..., ...)

  ```




  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_hcaptcha)</sup>

  Use this method to solve the hCaptcha challenge. Returns a token to bypass the captcha.
  ```python
  result = solver.hcaptcha(sitekey='10000000-ffff-ffff-ffff-000000000001',
                              url='https://www.site.com/page/',
                              param1=..., ...)

  ```




  <sup>[API method description.](https://2captcha.com/2captcha-api#lemin)</sup>

  Use this method to solve the Lemin captcha. Returns JSON with an answer containing the following values: answer, challenge_id.
  ```python
  result = solver.lemin(captcha_id='CROPPED_1abcd2f_a1234b567c890d12ef3a456bc78d901d',
                              div_id='lemin-cropped-captcha',
                              url='https://www.site.com/page/',
                              param1=..., ...)

  ```




  <sup>[API method description.](https://2captcha.com/2captcha-api#turnstile)</sup>

  Use this method to solve Cloudflare Turnstile. Returns JSON with the token.
  ```python
  result = solver.turnstile(sitekey='0x1AAAAAAAAkg0s2VIOD34y5',
                              url='http://mysite.com/',
                              data='foo',
                              pagedata='bar',
                              action='challenge',
                              useragent='Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36')
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#amazon-waf)</sup>

  Use this method to solve Amazon WAF Captcha also known as AWS WAF Captcha is a part of Intelligent threat mitigation for Amazon AWS. Returns JSON with the token.
  ```python
  result = solver.amazon_waf(sitekey='0x1AAAAAAAAkg0s2VIOD34y5',
                              iv='CgAHbCe2GgAAAAAj',
                              context='9BUgmlm48F92WUoqv97a49ZuEJJ50TCk9MVr3C7WMtQ0X6flVbufM4n8mjFLmbLVAPgaQ1Jydeaja94iAS49ljb+sUNLoukWedAQZKrlY4RdbOOzvcFqmD/ZepQFS9N5w15Exr4VwnVq+HIxTsDJwRviElWCdzKDebN/mk8/eX2n7qJi5G3Riq0tdQw9+C4diFZU5E97RSeahejOAAJTDqduqW6uLw9NsjJBkDRBlRjxjn5CaMMo5pYOxYbGrM8Un1JH5DMOLeXbq1xWbC17YSEoM1cRFfTgOoc+VpCe36Ai9Kc='
                              url='https://non-existent-example.execute-api.us-east-1.amazonaws.com/latest'
                              param1=..., ...)

  ```




  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_keycaptcha)</sup>

  Token-based method to solve KeyCaptcha.
  ```python
  result = solver.keycaptcha(s_s_c_user_id=10,
      				   s_s_c_session_id='493e52c37c10c2bcdf4a00cbc9ccd1e8',
      				   s_s_c_web_server_sign='9006dc725760858e4c0715b835472f22-pz-',
      				   s_s_c_web_server_sign2='2ca3abe86d90c6142d5571db98af6714',
      				   url='https://www.keycaptcha.ru/demo-magnetic/',
      				   param1=..., ...)

  ```




  <sup>[API method description.](https://2captcha.com/2captcha-api#atb-captcha)</sup>

  Use this method to solve atbCaptcha challenge. Returns a token to bypass the captcha.
  ```python
  result = solver.atb_captcha(app_id='af25e409b33d722a95e56a230ff8771c',
                              api_server='https://cap.aisecurius.com',
                              url='http://mysite.com/',
                              param1=..., ...)

  ```




  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_capy)</sup>

  Token-based method to bypass Capy puzzle captcha.
  ```python
  result = solver.capy(sitekey='PUZZLE_Abc1dEFghIJKLM2no34P56q7rStu8v',
                       url='http://mysite.com/',
                       api_server='https://jp.api.capy.me/',
                       param1=..., ...)
  ```


  <sup>[API method description.](https://2captcha.com/2captcha-api#grid)</sup>

  The grid method was originally called the Old reCAPTCHA V2 method. The method can be used to bypass any type of captcha where you can apply a grid on an image and click specific grid boxes. Returns numbers of boxes.

  ```python
  result = solver.grid('path/to/captcha.jpg', param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#canvas)</sup>

  The canvas method can be used when you need to draw a line around an object on an image. Returns a set of points' coordinates to draw a polygon.

  ```python
  result = solver.canvas('path/to/captcha.jpg', param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#coordinates)</sup>

  The ClickCaptcha method returns the coordinates of points on the captcha image. It can be used if you need to click on particular points in the image.

  ```python
  result = solver.coordinates('path/to/captcha.jpg', param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#solving_rotatecaptcha)</sup>

  This method can be used to solve a captcha that asks to rotate an object. It is mostly used to bypass FunCaptcha. Returns the rotation angle.

  ```python
  result = solver.rotate('path/to/captcha.jpg', param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#mtcaptcha)</sup>

  Use this method to solve MTCaptcha and obtain a token to bypass the protection.
  ```python
  result = solver.mtcaptcha(sitekey='MTPublic-KzqLY1cKH',
                            url='https://2captcha.com/demo/mtcaptcha',
                            param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#friendly-captcha)</sup>

  Friendly Captcha solving method. Returns a token.

  > [!IMPORTANT]
  > To successfully use the received token, the captcha widget must not be loaded on the page. To do this, you need to abort request to `/friendlycaptcha/...module.min.js` on the page. When the captcha widget is already loaded on the page, there is a high probability that the received token will not work.

  ```python
  result = solver.friendly_captcha(sitekey='FCMGEMUD2KTDSQ5H',
                                   url='https://friendlycaptcha.com/demo',
                                   param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#cutcaptcha)</sup>

  Use this method to solve Cutcaptcha. Returns the response in JSON.
  ```python
  result = solver.cutcaptcha(misery_key='ad52c87af17e2ec09b8d918c9f00416b1cb8c320',
                             apikey='SAs61IAI',
                             url='https://mysite.com/page/with/cutcaptcha',
                             param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#tencent)</sup>

  Use this method to solve Cutcaptcha. Returns a token.
  ```python
  result = solver.tencent(app_id="197326679",
                          url="https://mysite.com/page/with/tencent",
                          param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#datadome)</sup>

  Use this method to solve DataDome captcha.

  > [!IMPORTANT]
  > To solve the DataDome captcha, you must use a proxy. It is recommended to use [residential proxies].

  ```python
  result = solver.datadome(captcha_url="https://geo.captcha-delivery.com/captcha/?initialCid=...",
                           pageurl="https://mysite.com/page/with/datadome",
                           userAgent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
                           proxy={
                              'type': 'HTTP',
                              'uri': 'login:password@IP_address:PORT'
                           },
                           param1=..., ...)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#cybersiara)</sup>

  Use this method to solve CyberSiARA. Returns a token.
  ```python
  result = solver.cybersiara(master_url_id='tpjOCKjjpdzv3d8Ub2E9COEWKt1vl1Mv',
                             pageurl='https://demo.mycybersiara.com/',
                             userAgent='Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36',
                             param1=..., ...)
  ```




  These methods can be used for manual captcha submission and answer polling. The `send()` method supports sending any captcha
  type, to specify the captcha type you must send value `method` manually, for example `method='hcaptcha'` for solving hCapthca.
  You can find the value of the `method` parameter in the [API documentation](https://2captcha.com/2captcha-api).

  Example for solving Normal captcha manually:
  ```python
  import time
  . . . . .


  id = solver.send(file='path/to/captcha.jpg')
  time.sleep(20)

  code = solver.get_result(id)
  ```
  Example for solving hCaptcha manually:
  ```python
  import time
  . . . . .
  id = solver.send(sitekey='41b778e7-8f20-45cc-a804-1f1ebb45c579',
                   url='https://2captcha.com/demo/hcaptcha?difficulty=easy',
                   method='hcaptcha')
  print(id)
  time.sleep(20)
  code = solver.get_result(id)
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#additional-methods)</sup>

  Use this method to get your account's balance
  ```python
  balance = solver.balance()
  ```



  <sup>[API method description.](https://2captcha.com/2captcha-api#complain)</sup>

  Use this method to report good or bad captcha answers.
  ```python
  solver.report(id, True) # captcha solved correctly
  solver.report(id, False) # captcha solved incorrectly
  ```


  In case of an error, the captcha solver throws an exception. It's important to properly handle these cases. We recommend using `try except` to handle exceptions.
  The list of all errors can be found in the  [API documentation](https://2captcha.com/2captcha-api#list-of-inphp-errors).
  ```python
  try:
      result = solver.text('If tomorrow is Saturday, what day is today?')
  except ValidationException as e:
      
  	print(e)
  except NetworkException as e:
  	
  	print(e)
  except ApiException as e:
      
  	print(e)
  except TimeoutException as e:
      
  	print(e)
  ```




  You can pass your proxy as an additional argument for the following methods: recaptcha, funcaptcha, geetest, geetest v4, hcaptcha,
  keycaptcha, capy puzzle, lemin, atbcaptcha, turnstile, amazon waf, mtcaptcha, friendly captcha, cutcaptcha, Tencent, DataDome, cybersiara.


  The proxy will be forwarded to the API to solve the captcha.

  We have our own proxies that we can offer you. [Buy residential proxies] to avoid restrictions and blocks. [Quick start].

  ```python
  proxy={
      'type': 'HTTPS',
      'uri': 'login:password@IP_address:PORT'
  }
  ```


  You can also make async calls with [asyncio], for example:

  ```python
  import asyncio
  import concurrent.futures
  from twocaptcha import TwoCaptcha

  API_KEY = "YOUR_API_KEY"
  image = "data:image/png;base64,iVBORw0KGgoA..."

  async def captchaSolver(image):
      loop = asyncio.get_running_loop()
      with concurrent.futures.ThreadPoolExecutor() as pool:
          result = await loop.run_in_executor(pool, lambda: TwoCaptcha(API_KEY).normal(image))
          return result

  captcha_result = asyncio.run(captchaSolver(image))
  ```

  Examples of solving all supported captcha types are located in the [examples] directory.


  Also we have a [separate repository](https://github.com/2captcha/captcha-solver-selenium-python-examples) you can find examples of captcha solving using [Selenium](https://pypi.org/project/selenium/) library. At the moment we have implemented examples of bypassing [reCAPTCHA](https://github.com/2captcha/captcha-solver-selenium-python-examples/tree/main/examples/reCAPTCHA), [hCaptcha](https://github.com/2captcha/captcha-solver-selenium-python-examples/tree/main/examples/hCaptcha), [normal captcha](https://github.com/2captcha/captcha-solver-selenium-python-examples/tree/main/examples/normal_captcha) (image captcha) and [text captcha](https://github.com/2captcha/captcha-solver-selenium-python-examples/tree/main/examples/text_captcha) using Selenium.



  - Amazon captcha solver: Code example for bypassing the [Amazon captcha](https://2captcha.com/blog/amazon-captcha-solving)
  - [Captcha bypass in Selenium](https://2captcha.com/blog/captcha-bypass-in-selenium)



  <a href="mailto:support@2captcha.com"><img src="https://github.com/user-attachments/assets/539df209-7c85-4fa5-84b4-fc22ab93fac7" width="80" height="30"></a>
  <a href="https://2captcha.com/support/tickets/new"><img src="https://github.com/user-attachments/assets/be044db5-2e67-46c6-8c81-04b78bd99650" width="81" height="30"></a>



  There are many ways to contribute, of which development is only one! Find your next job. Open positions: AI experts, scrapers, developers, technical support, and much more! 😍

  <a href="mailto:job@2captcha.com"><img src="https://github.com/user-attachments/assets/36d23ef5-7866-4841-8e17-261cc8a4e033" width="80" height="30"></a>




  The code in this repository is licensed under the MIT License. See the [LICENSE](./LICENSE) file for more details.



  The graphics and trademarks included in this repository are not covered by the MIT License. Please contact <a href="mailto:support@2captcha.com">support</a> for permissions regarding the use of these materials.


  <!-- Shared links for README.md -->
  [2Captcha]: https://2captcha.com/
  [2captcha software catalog]: https://2captcha.com/software
  [pingback settings]: https://2captcha.com/setting/pingback
  [post options]: https://2captcha.com/2captcha-api#normal_post
  [list of supported languages]: https://2captcha.com/2captcha-api#language
  [examples directory]: /examples
  [asyncio]: https://docs.python.org/3/library/asyncio.html
  [Buy residential proxies]: https://2captcha.com/proxy/residential-proxies
  [Quick start]: https://2captcha.com/proxy?openAddTrafficModal=true
  [examples]: ./examples
  [residential proxies]: https://2captcha.com/proxy/residential-proxies


pkgId: 2a519354adf6d643d7f1afde7ab02a3a632afd32dc6532bbf5313f65788e1a4e
name: python-2dxPlay
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Play a .2dx file.
url: https://github.com/camprevail/2dxPlay
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2dxPlay-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Play konami 2dx files from the command line.


  Install with pip and run it from anywhere.
  `pip install 2dxPlay`


  ```
  2dxplay infile.2dx
  ```
  If the file contains more than one wav, it will play all tracks sequentially.
  Press Ctrl+C to pause and enter a track number to jump to, or `q` to quit.


  Right click on a 2dx file, choose Open With > Look for another app on this PC.
  Navigate to your python installation where 2dxPlay.exe is installed. (I use python 3.7, so pip
  installed it in `%appdata%\Local\Programs\Python\Python37\Scripts`).
  Check the "Always use this app" box and profit.

  ![img.png](img.png)


pkgId: 1a0c96ab174e302dcc27eb316adb2c8b1f41acf6c658d2e78688ae29518e35f4
name: python-2xh-leet
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Library of Eclectic Experiments by Tenchi
url: https://github.com/Tenchi2xh/leet
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-2xh-leet-1.0.1-1.src.rpm
checksum_type: sha256
description:
  <!-- MarkdownTOC autolink=true -->
  - [Logging](#logging)
      - [Progress bars](#progress-bars)
      - [Images](#images)
  <!-- /MarkdownTOC -->

  Module that provides a fancy-looking theme for Python loggers.
  (TODO: Screenshot)
  To enable, `import leet.logging` from anywhere (maybe the main `__init__.py` of your project). You will then have a global logger `log` function that you can use from anywhere:
  ```py
  log.info("Hello")
  log.warn("World")
  ```
  If using MyPy (or if you don't like monkeypatching) you can import the logger explicitly in each module as needed:
  ```py
  from leet.logging import log
  log.info("Explicit import")
  ```

  Also provides a progress bar (from [WoLpH/python-progressbar](https://github.com/WoLpH/python-progressbar)) that fits in the theme:
  ```py
  from time import sleep
  from leet.logging import log_progress
  for i in log_progress.debug(range(10)):
      sleep(1)
      log.info("Working on %d..." % i)
  ```

  Also supports outputing images via [imgcat](https://iterm2.com/utilities/imgcat) if using [iTerm2](https://iterm2.com/) (support for other tools pending):
  ```py
  log.warn("Image is too big:", extras={"img": "path/to/image.png"})
  ```


pkgId: ac695455d513099351ea2bd0005f457f3eca7301aaf17ab92f9cf423dea4b11a
name: python-3
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: Hey
url: https://abranhe.com
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-3-0.0.0-1.src.rpm
checksum_type: sha256
description:
  |[![Carlos Abraham Logo](https://avatars3.githubusercontent.com/u/21347264?s=50&v=4)](https://19cah.com)|
  | :-: |
  | [Carlos Abraham](https://github.com/abranhe) |


pkgId: debc8bbcfd592ed713759fe6dd8c64f0ed1f3600602783e5fb66c3b0eda0efe0
name: python-3-py
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: `.gitignore`-aware tree tool written in Python
url: https://github.com/excitoon/3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-3-py-1.1.6-1.src.rpm
checksum_type: sha256
description:
  `.gitignore`-aware tree tool written in Python.

  Example:

  ```
  3
  ```

  Output:

  ![](examples/3.png)



  ```
  pip3 install 3-py
  ```



  If you are on Windows, install `colorama` in order to watch some colors.


pkgId: 8332cfe3d8668d94b77e43900a6ead46a18be94db7fde7718f4258955fb588f4
name: python-31
arch: src
version: 2.2
epoch: 0
release: 1
summary: Runs code in a specified environment in the background and notifies you when it is done.
url: https://github.com/kavigupta/31
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-31-2.2-1.src.rpm
checksum_type: sha256
description:
  31 is a simple tool you can use to run code in the background on a server.

  For example

  ```
  31 c 'sleep 100; echo 2'
  ```

  runs the command `sleep 100; echo 2` in a screen session then sends you an email with the output of the command once it is complete.



  Install 31 by running

  ```
  pip install 31
  ```

  Then set up your email address by running

  ```
  31 config email youremail@example.com
  ```



  On ubuntu you can run

  ```
  sudo apt install screen mailutils
  ```

  to quickly set up the dependencies needed.





  By default, `31` searches for a mail program to use from the following list. You
  can also force it to use one of the programs by using the command

  ```
  31 config mail_program <mail program name>
  ```

  - `gnu_mail`. To install on ubuntu you can run
  ```
  sudo apt install mailutils
  ```
  - `mutt`. To install on ubuntu you can run
  ```
  sudo apt install mutt
  ```



  Currently 31 only supports `screen`. To install screen on ubuntu run
  ```
  sudo apt install screen
  ```



  See `31 -h` for a full list of options. This section covers only some of the more complicated ones



  This option allows you to run multiple commands with text substitution. As a basic usage example, the code

  ```sh
  31 c -f %x 1,2,3 'touch %x.txt'
  ```

  Creates each of the files `1.txt`, `2.txt`, and `3.txt`. The variable substitution is managed via direct text-substitution,
  and thus your variables do not need to begin with %, this works equally well (though is far less readable)

  ```sh
  31 c -f 2 1,2,3 'touch 2.txt'
  ```

  You can also modify two variables in tandem like this:

  ```sh
  31 c -f2 %x %ext 1,2,3 txt,png,py 'touch %x.%ext'
  ```

  This creates the files `1.txt`, `2.png`, `3.py`. If you instead want to create all combinations, you can run:

  ```sh
  31 c -f %x 1,2,3 -f %ext txt,png,py 'touch %x.%ext'
  ```

  This creates the files `1.txt`, `1.png`, `1.py`, `2.txt`, `2.png`, `2.py`, `3.txt`, `3.png`, `3.py`.

  The values field is in comma-separated-value form, which means you can use `"` as a CSV escape, as such:

  ```sh
  31 -c -f %x '",",2' `touch %x.txt`
  ```

  which creates the files `,.txt` and `2.txt`.


pkgId: 438cc9d3d751f20728d4139196d4dac133a98094ade3373bfd20c6635fe07449
name: python-310-notebook
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A JupyterLab extension.
url: https://github.com/pooriyapfn/jupyterlab_extension.git
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-310-notebook-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Github Actions Status](https://github.com/pooriyapfn/jupyterlab_extension.git/workflows/Build/badge.svg)](https://github.com/pooriyapfn/jupyterlab_extension.git/actions/workflows/build.yml)
  A JupyterLab extension.



  - JupyterLab >= 3.0



  To install the extension, execute:

  ```bash
  pip install 310_notebook
  ```



  To remove the extension, execute:

  ```bash
  pip uninstall 310_notebook
  ```





  Note: You will need NodeJS to build the extension package.

  The `jlpm` command is JupyterLab's pinned version of
  [yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use
  `yarn` or `npm` in lieu of `jlpm` below.

  ```bash



  pip install -e .

  jupyter labextension develop . --overwrite

  jlpm build
  ```

  You can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.

  ```bash

  jlpm watch

  jupyter lab
  ```

  With the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).

  By default, the `jlpm build` command generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:

  ```bash
  jupyter lab build --minimize=False
  ```



  ```bash
  pip uninstall 310_notebook
  ```

  In development mode, you will also need to remove the symlink created by `jupyter labextension develop`
  command. To find its location, you can run `jupyter labextension list` to figure out where the `labextensions`
  folder is located. Then you can remove the symlink named `310_notebook` within that folder.





  This extension is using [Jest](https://jestjs.io/) for JavaScript code testing.

  To execute them, execute:

  ```sh
  jlpm
  jlpm test
  ```



  This extension uses [Playwright](https://playwright.dev/docs/intro/) for the integration tests (aka user level tests).
  More precisely, the JupyterLab helper [Galata](https://github.com/jupyterlab/jupyterlab/tree/master/galata) is used to handle testing the extension in JupyterLab.

  More information are provided within the [ui-tests](./ui-tests/README.md) README.



  See [RELEASE](RELEASE.md)


pkgId: 26ddd703f2d98aa70d39439083b5c33227ab4bfc46390f8cd7a11f15dec15fd5
name: python-32blit
arch: src
version: 0.7.4
epoch: 0
release: 1
summary: 32Blit asset preparation and upload tools
url: https://32blit.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-32blit-0.7.4-1.src.rpm
checksum_type: sha256
description:
  * Fix bug when deleting from flash - thanks @ali1234
  * Fix serial port in error message - thanks @ali1234
  * Fix image encoding - thanks @Daft-Freak


pkgId: 3f6460da44d4996d59d96b5a74594dcc1dc1db6b5e10c45dda54a6dec3f09b03
name: python-360monitoringcli
arch: src
version: 1.0.19
epoch: 0
release: 1
summary: 360 Monitoring CLI
url: https://github.com/plesk/360monitoring-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-360monitoringcli-1.0.19-1.src.rpm
checksum_type: sha256
description:
  This repository contains a CLI script for 360 Monitoring that allows you to connect to your 360 Monitoring (https://360monitoring.com) account and list monitoring data, add, update or remove server or website monitors.



  You can find the full documentation including the feature complete REST API at [docs.360monitoring.com](https://docs.360monitoring.com/docs) and [docs.360monitoring.com/docs/api](https://docs.360monitoring.com/docs/api).



   * Make sure to have an account at https://360monitoring.com or https://platform360.io
   * 360 Monitoring CLI requires a Python version of 3.* or above



      $ pip install 360monitoringcli



  First you need to connect your CLI to your existing 360 Monitoring account via your API KEY. If you don't have a 360 Monitoring account yet, please register for free at https://360monitoring.com. To create an API KEY you'll need to upgrade at least to a Pro plan to be able to create your API KEY.

      $ 360monitoring config save --api-key KEY     configure API KEY to connect to 360 Monitoring account





  You can easily test and run 360 Monitoring CLI for production by running the pre-configured docker image

      $ docker build -t 360monitoringcli .
      $ docker run -it --rm 360monitoringcli /bin/bash



   To test a package from staging you can simply deploy a docker container:

      $ docker run -it --rm ubuntu /bin/bash
      $ apt-get update && apt-get install -y python3 && apt-get install -y pip
      $ pip install -i https://test.pypi.org/simple/ --force-reinstall -v "360monitoringcli==1.0.19"



   To test the code locally, install the Python modules "requests", "configparser", "argparse" and "prettytable".
   Use "pip install -e ." to use "360monitoring" command with latest dev build locally based on local code.

      $ pip install requests
      $ pip install configparser
      $ pip install argparse
      $ pip install prettytable
      $ pip install -e .



  Test the code:

      $ ./test_cli.sh



      $ 360monitoring --help                        display general help
      $ 360monitoring signup                        open the sign up page to get your 360 Monitoring account
      $ 360monitoring config save --api-key KEY     configure API KEY to connect to 360 Monitoring account (only for paid plans)
      $ 360monitoring statistics                    display all assets of your account
      $ 360monitoring servers list                  display all monitored servers
      $ 360monitoring servers list --issues         display monitored servers with issues only
      $ 360monitoring servers list --tag cpanel     display only servers with tag "cpanel"
      $ 360monitoring sites list                    display all monitored sites
      $ 360monitoring sites list --issues           display monitored sites with issues only
      $ 360monitoring sites list --sort 6 --limit 5 display worst 5 monitored sites by uptime
      $ 360monitoring contacts list                 display all contacts
      $ 360monitoring usertokens list               display user tokens
      $ 360monitoring config print                  display your current settings and where those are stored
      $ 360monitoring recommendations               display upgrade recommendations for servers that exceed their limits
      $ 360monitoring magiclinks                    create and open a readonly dashboard for a single server only via magic link
      $ 360monitoring wptoolkit                     display statistics of WP Toolkit if installed

      $ 360monitoring sites add --url domain.tld    start monitoring a new website
      $ 360monitoring servers update --name cpanel123.hoster.com --tag production   tag a specific server

      $ 360monitoring contacts --help               display specific help for a sub command
      $ 360monitoring dashboard                     open 360 Monitoring in your Web Browser


  You can update the 360monitoringcli package to the latest version using the following command:

      $ pip install 360monitoringcli --upgrade


pkgId: c1b751ce438bfa7cf7ccd39588ce598ddc2eb0582e896f987707c6df0d3de914
name: python-365scores
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: 365scores
url: https://github.com/kkristof200/py_365scores
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-365scores-1.0.7-1.src.rpm
checksum_type: sha256
description:
  ![python_version](https://img.shields.io/static/v1?label=Python&message=3.5%20|%203.6%20|%203.7&color=blue) [![PyPI downloads/month](https://img.shields.io/pypi/dm/365scores?logo=pypi&logoColor=white)](https://pypi.python.org/pypi/365scores)





  ~~~~bash
  pip install 365scores

  pip3 install 365scores
  ~~~~


pkgId: 5a05abd3848105950575af679a4610dbf133da1a3e5a8a0fdd600b24626f1c4e
name: python-3D-registration
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Some scripts to register images in space and time
url: https://github.com/GuignardLab/registration-tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-3D-registration-0.5.2-1.src.rpm
checksum_type: sha256
description:
  __Before everything else, the current status of the whole thing here is that it only works on UNIX systems (eg Linux & MacOs) that have reasonnable chips (eg not M1 chips for example).__


  This repository is about two scripts to do spatial and temporal registration of 3D microscopy images.
  It was initially developed to help friends with their ever moving embryos living under a microscope.
  I found that actually quite a few people were interested so I made a  version of it that is somewhat easier to use.

  In theory, the main difficulty to make the whole thing work is to install the different libraries.


  The whole thing is just a wrapping of the amazing blockmatching algorithm developed by [S. Ourselin et al.] and currently maintained Grégoire Malandin et al.@[Team Morphem - inria] (if I am not mistaking).



  [conda] and [pip] are required to install `registration-tools`

  We recommand to install the registration tools in a specific environement (like [conda]). For example the following way:

      conda create -n registration python=3.10
  You can then activate the environement the following way:

      conda activate registration

  For here onward we assume that you are running the commands from the `registration` [conda] environement.

  Then, to install the whole thing, it is necessary to first install blockmatching. To do so you can run the following command:

      conda install vt -c morpheme -c trcabel

  Then, you can install the 3D-registration library either directly via pip:

      pip install 3D-registration

  Or, if you want the latest version, by specifying the git repository:

      pip install git+https://github.com/GuignardLab/registration-tools.git


  - Windows:

      If you are trying to run the script on Windows you might need to install `pthreadvse2.dll`.

      It can be found there: https://www.pconlife.com/viewfileinfo/pthreadvse2-dll/ . Make sure to download the version that matches your operating system (32 or 64 bits, most likely 64).

  - MacOs:

      As there are no M1 binaries available yet, please use rosetta or install an intel version of conda.



  Most of the description on how to use the two scripts is described in the [manual] (Note that the installation part is quite outdated, the remaining is ok).

  That being said, once installed, one can run either of the scripts from anywhere in a terminal by typing:

      time-registration

  or

      spatial-registration

  The location of the json files or folder containing the json files will be prompted and when provided the registration will start.

  It is also possible to run the registration from a script/notebook the following way:
  ```python
  from registrationtools import TimeRegistration
  tr = TimeRegistration('path/to/param.json')
  tr.run_trsf()
  ```

  or

  ```python
  from registrationtools import TimeRegistration
  tr = TimeRegistration('path/to/folder/with/jsonfiles/')
  tr.run_trsf()
  ```

  or

  ```python
  from registrationtools import TimeRegistration
  tr = TimeRegistration()
  tr.run_trsf()
  ```

  and a path will be asked to be inputed.



  Few example json files are provided to help the potential users. You can find informations about what they do in the [manual].

  [S. Ourselin et al.]: http://www-sop.inria.fr/asclepios/Publications/Gregoire.Malandain/ourselin-miccai-2000.pdf
  [Team Morphem - inria]: https://team.inria.fr/morpheme/
  [conda]: https://conda.io/projects/conda/en/latest/user-guide/install/index.html
  [pip]: https://pypi.org/project/pip/
  [manual]: https://github.com/GuignardLab/registration-tools/blob/master/User-manual/user-manual.pdf


pkgId: fd99014730bab273ffa9751ddabd51309998d3fcc03afbcf4d6c8af16db356ab
name: python-3DeeCellTracker
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A package for tracking cells in 3D time lapse images in deforming organs or moving animals
url: https://github.com/WenChentao/3DeeCellTracker
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-3DeeCellTracker-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/3DeeCellTracker)](https://pypi.org/project/3DeeCellTracker/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/3DeeCellTracker)](https://pypi.org/project/3DeeCellTracker/) [![GitHub](https://img.shields.io/github/license/WenChentao/3DeeCellTracker)](https://github.com/WenChentao/3DeeCellTracker/blob/master/LICENSE)
  [![Youtube](https://img.shields.io/badge/YouTube-Demo-red)](https://www.youtube.com/watch?v=ctt6o3DY2bA&list=PLGY0oNQomrHERP08iEj-MsluFW8xQJujP)

  **3DeeCellTracker** is a deep-learning based pipeline for tracking cells in 3D time-lapse images of deforming/moving organs ([eLife, 2021](https://elifesciences.org/articles/59187)).


  **3DeeCellTracker v1.0.0 has been released**
  - Fixed some bugs in v0.5



  To install 3DeeCellTracker, please follow the instructions below:

  > Note: We have tested the installation and the tracking programs in two environments:
  > 1. (Local) Ubuntu 20.04; NVIDIA GeForce RTX 3080Ti; Tensorflow 2.5.0
  > 2. (Google Colab) Tensorflow 2.12.0 (You need to upload your data for tracking)


  - A computer with an NVIDIA GPU that supports CUDA.
  - [Anaconda](https://www.anaconda.com/products/individual) or [Miniconda](https://conda.io/miniconda.html) installed.
  - TensorFlow 2.x installed.


  1. Create a new conda environment and activate it by running the following commands in your terminal:

     ```console
     $ conda create -n track python=3.8 pip
     $ conda activate track
     ```

  2. Install TensorFlow 2.x by following the instructions provided in the [TensorFlow installation guide](https://www.tensorflow.org/install).

  3. Install the 3DeeCellTracker package by running the following command in your terminal:

     ```console
     $ pip install 3DeeCellTracker==1.0.0
     ```
  4. Once the installation is complete, you can start using 3DeeCellTracker for your 3D cell tracking tasks within the Jupyter notebooks provided in the GitHub repository.

  If you encounter any issues or have any questions, please refer to the project's documentation or raise an issue in the GitHub repository.


  To learn how to track cells using 3DeeCellTracker, please refer to the following notebooks for examples. We recommend using StarDist for segmentation, as we have optimized the StarDist-based tracking programs for more convenient and quick cell tracking. Users can also use the old way with 3D U-Net.
  1. Train a custom deep neural network for segmenting cells in new optical conditions:
      - [**Train 3D StarDist (notebook with results)**](Examples/use_stardist/train_stardist.ipynb)
      - [**Train 3D U-Net (clear notebook)**](Examples/use_unet/3D_U_Net_training-clear.ipynb)
      - [**Train 3D U-Net (results)**](https://wenchentao.github.io//3DeeCellTracker/Examples/use_unet/3D_U_Net_training.html)

  2. Track cells in deforming organs:
      - [**Single mode + StarDist (notebook with results)**](Examples/use_stardist/track_stardist_single_mode.ipynb)
      - [**Single mode + UNet (clear notebook)**](Examples/use_unet/single_mode_worm1-clear.ipynb)
      - [**single mode + UNet (results)**](https://wenchentao.github.io//3DeeCellTracker/Examples/use_unet/single_mode_worm1.html)

  3. Track cells in freely moving animals:
      - [**Ensemble mode + StarDist (notebook with results)**](Examples/use_stardist/track_stardist_ensemble_mode.ipynb)
      - [**Ensemble mode + UNet (clear notebook)**](Examples/use_unet/ensemble_mode_worm4-clear.ipynb)
      - [**Ensemble mode + UNet (results)**](https://wenchentao.github.io//3DeeCellTracker/Examples/use_unet/ensemble_mode_worm4.html)

  4. (Optional) Train FFN with custom data:
      - [**Use coordinates in a .csv file (notebook with results)**](Examples/use_stardist/train_ffn_with_coordinates_csv.ipynb)
      - [**Use manually corrected segmentation saved as label images (notebook with results)**](Examples/use_stardist/train_ffn_with_label_image.ipynb)

  The data and model files for demonstrating above notebooks can be downloaded here:
  - [**Data for StarDist-based notebooks**](https://osf.io/pgr95/).
  - [**Data for UNet-based notebooks**](https://osf.io/dt76c/).




  Multiple users have reported encountering a `ValueError` of shape mismatch when running the `tracker.match()` function.
  After investigation, it was found that the issue resulted from an incorrect setting of `siz_xyz`,
  which should be set to the dimensions of the 3D image as (height, width, depth).



  We have made tutorials explaining how to use our software. See links below (videos in Youtube):

  [Tutorial 1: Install 3DeeCellTracker and train the 3D U-Net](https://www.youtube.com/watch?v=ctt6o3DY2bA)

  [Tutorial 2: Tracking cells by 3DeeCellTracker](https://www.youtube.com/watch?v=KZ03Y8u8UK0)

  [Tutorial 3: Annotate cells for training 3D U-Net](https://www.youtube.com/watch?v=ONSOLJQaq28)

  [Tutorial 4: Manually correct the cell segmentation](https://www.youtube.com/watch?v=e7xWaccH63o)


  We have written a tutorial explaining how to install and use 3DeeCellTracker. See [Bio-protocol, 2022](https://bio-protocol.org/e4319)


  We designed this pipeline for segmenting and tracking cells in 3D + T images in deforming organs. The methods have been explained in [Wen et al. bioRxiv 2018]( https://doi.org/10.1101/385567) and in [Wen et al. eLife, 2021](https://elifesciences.org/articles/59187).
  The original programs used in eLife 2021 was contained in the "[**Deprecated_programs**](Deprecated_programs)" folder.

  **Overall procedures of our method** ([Wen et al. eLife, 2021–Figure 1](https://elifesciences.org/articles/59187/figures#content))

  <img src="https://iiif.elifesciences.org/lax:59187%2Felife-59187-fig1-v1.tif/full/1500,/0/default.jpg" width="400">

  **Examples of tracking results** ([Wen et al. eLife, 2021–Videos](https://elifesciences.org/articles/59187/figures#content))

  | [Neurons in a ‘straightened’ <br />freely moving worm](https://static-movie-usa.glencoesoftware.com/mp4/10.7554/5/4ce9eaa4a84bf7847c99c81a13ccafd797b40218/elife-59187-fig6-video1.mp4)| [Cardiac cells in a zebrafish larva](https://static-movie-usa.glencoesoftware.com/mp4/10.7554/5/4ce9eaa4a84bf7847c99c81a13ccafd797b40218/elife-59187-fig7-video2.mp4) | [Cells in a 3D tumor spheriod](https://static-movie-usa.glencoesoftware.com/mp4/10.7554/5/4ce9eaa4a84bf7847c99c81a13ccafd797b40218/elife-59187-fig8-video2.mp4) |
  | ------------- | ------------- | ------------- |
  | <img src="https://user-images.githubusercontent.com/27986173/115169952-63b4e600-a0fa-11eb-9b85-91292bc9d419.gif" width="340">| <img src="https://user-images.githubusercontent.com/27986173/115170418-90b5c880-a0fb-11eb-9382-13690c3375dc.gif" width="400">| <img src="https://user-images.githubusercontent.com/27986173/115170434-9ad7c700-a0fb-11eb-9004-2e4cff86f7ab.gif" width="200">|




  If you used this package in your research, please cite our paper:

  - Chentao Wen, Takuya Miura, Venkatakaushik Voleti, Kazushi Yamaguchi, Motosuke Tsutsumi, Kei Yamamoto, Kohei Otomo, Yukako Fujie, Takayuki Teramoto, Takeshi Ishihara, Kazuhiro Aoki, Tomomi Nemoto, Elizabeth MC Hillman, Koutarou D Kimura (2021) 3DeeCellTracker, a deep learning-based pipeline for segmenting and tracking cells in 3D time lapse images eLife 10:e59187

  Depending on the segmentation method you used (StarDist3D or U-Net3D), you may also cite either of
  following papers:
  - Martin Weigert, Uwe Schmidt, Robert Haase, Ko Sugawara, and Gene Myers.
  Star-convex Polyhedra for 3D Object Detection and Segmentation in Microscopy.
  The IEEE Winter Conference on Applications of Computer Vision (WACV), Snowmass Village, Colorado, March 2020

  - Çiçek, Ö., Abdulkadir, A., Lienkamp, S.S., Brox, T., Ronneberger, O. (2016). 3D U-Net: Learning Dense Volumetric Segmentation from Sparse Annotation. In: Ourselin, S., Joskowicz, L., Sabuncu, M., Unal, G., Wells, W. (eds) Medical Image Computing and Computer-Assisted Intervention – MICCAI 2016. MICCAI 2016. Lecture Notes in Computer Science(), vol 9901. Springer, Cham.


  We wish to thank **JetBrains** for supporting this project
  with free open source **Pycharm** license.

  [![Pycharm Logo](pictures/jetbrains_small.png)](https://www.jetbrains.com/)
  [![Pycharm Logo](pictures/icon-pycharm_small.png)](https://www.jetbrains.com/pycharm/)


pkgId: 1ef03d4b9d29a98fabaaa9b2e9fc20e31023c3c43c1b5a7b5145b0e00400a608
name: python-3d
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: 3D makes 3D game design easy
url: https://pypi.org/project/3d/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-3d-0.1.1-1.src.rpm
checksum_type: sha256
description:
  3D is a project designed to make programming 3D games as easy as possible.
  3D gives developers an easy way to build great games and 3D renders using nothing but Python.

  > **Note**: 3D is imported using `import g`, not `import 3d`!


pkgId: 9b7abcb74a2953e653b5d6dd66734186ea8b982e567b3c9862eec28e1d174d86
name: python-3d-video-converter
arch: src
version: 0.0.4
epoch: 0
release: 1
url: https://github.com/evoth/3d-video-converter
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-3d-video-converter-0.0.4-1.src.rpm
checksum_type: sha256
summary:
  FFMPEG-based tool for converting either two separate stereo videos or an existing 3D video into a wide range of 3D video formats.

description:
  A simple FFMPEG-based script for converting either two separate stereo videos or an existing 3D video into a wide range of 3D video formats.





  From PyPI:

  ```bash
  pip install 3d-video-converter
  ```

  Or from the source on GitHub:

  ```bash
  pip install "3d-video-converter @ git+https://github.com/evoth/3d-video-converter"
  ```

  The package will be installed with the module name `video_converter_3d`.



  This package depends on [ffmpeg-python](https://github.com/kkroening/ffmpeg-python), which means that [FFmpeg](https://ffmpeg.org/) must be installed and accessible via the `$PATH` environment variable. Please follow appropriate installation instructions for your platform.

  To check if FFmpeg is installed, run the `ffmpeg` command from the terminal. If it is installed correctly, you should see version and build information.



  Convert a full-width parallel view video to full color red/cyan anaglyph:

  ```python
  from video_converter_3d import convert_3d

  convert_3d("video_parallel.mp4", "sbsl", "video_anaglyph.mp4", "arcc")
  ```

  Combine two separate stereo videos into a full-width parallel view video, only keeping audio from the left video:

  ```python
  from video_converter_3d import convert_2d_to_3d

  convert_2d_to_3d(
      "video_left.mp4",
      "video_right.mp4",
      True,
      False,
      "video_parallel.mp4",
      "sbsl"
  )
  ```


pkgId: 4335b058455f0269df8734304e8b066b6b24a3e4260829d5cfb2f0e4f878e6cb
name: python-3way
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Freeway for network pentesting
url: https://github.com/FLOCK4H/Freeway
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-3way-1.4.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="https://github.com/FLOCK4H/Freeway/assets/161654571/85eb939d-0154-4767-8aab-c3a5e29b1d6f" alt="Freeway logo" />

    **Freeway for Network Pentesting**

  </div>

  <div align="center">


  Read the article about Freeway, now on
  <a href="https://medium.com/@flytechoriginal/freeway-for-network-pentesting-e97e69e481fc">Medium</a>
  </div>
  <br />

  > [!NOTE]
  > User will not be prompted to accept EULA anymore!<br />Therefore, by downloading the software, user automatically agrees to follow every guideline specified in EULA section below.

  <h2><strong>1. Overview</strong></h2>

  **Freeway** is a Python scapy-based tool for WiFi penetration that aim to help ethical hackers and pentesters develop their skills and knowledge in auditing and securing home or enterprise networks.

  <h2><strong>2. Features</strong></h2>

  - IEEE 802.11 Packet Monitoring
  - Deauthentication Attack
  - Beacon Flood
  - Packet Fuzzer
  - Network Audit
  - Channel Hopper
  - Evil Twin
  - Packet Crafter

  <sub>Description of the features can be found in Section 6</sub>

  <h2><strong>3. Preparation</strong></h2>

  It is **necessary** to have:
  - A network adapter supporting monitor mode and frame injection.
  - An operating system running a Linux distribution.
  - Python 3+ installed.

  <sub>Optionally, install Scapy and Rich packages for Python if not installing via pip (see Section 4)</sub>

  <h2><strong>4. Setup</strong></h2>

  **Option A**: Install via PyPi (**RECOMMENDED**)

  ```
    $ sudo pip install 3way
  ```

  **Option B**: Install or run manually

  First, clone the repository:

      git clone https://github.com/FLOCK4H/Freeway

  Navigate to the cloned repository:

      cd Freeway

  <strong>Option 1:</strong> Install dependencies, folders, and Freeway. (RECOMMENDED)

  <sub>This will allow to launch the tool from anywhere</sub>

      sudo pip install .

  <strong>Option 2:</strong> Run without installation using Python.

  <sub>Must be called from the /Freeway directory</sub>

      sudo pip install scapy rich
      sudo python Freeway

  <h2><strong>5. Usage</strong></h2>

  This tool comes with its own **command line interface (CLI)** and can be run without specifying any additional arguments.

  <details>
  <summary><strong>Click to expand the CLI usage</strong></summary>
  <br />

      sudo Freeway

  Follow the prompt to select the network adapter (see Section 3):

  ![image](https://github.com/FLOCK4H/Freeway/assets/161654571/653c9304-3256-4444-8f3f-0677134c8af8)

  Select the feature and parameter(s):

  ![image](https://github.com/FLOCK4H/Freeway/assets/161654571/2444922e-6f1b-4958-99ea-df7463b912cb)
  ![image](https://github.com/FLOCK4H/Freeway/assets/161654571/757b5d77-be12-4dda-a957-3c305789bba7)

  </details>
  <br />

  And with the **additional arguments**, to skip the CLI partially or completely.

  <details>
  <summary><strong>Click to expand the arguments usage</strong></summary>
  <br />

      sudo Freeway -i wlan2 -a monitor -p 1,2,a

  <sub>'-p' is not required with '-a', e.g., this will prompt for parameters to specify in the CLI:</sub>

      sudo Freeway -i wlan2 -a deauth

  **All arguments, actions, and parameters:**

  <div>
  <pre>
    Arguments:
    -h, --help     Show the help message. <br />
    -i, --inf      Specify the WLAN interface (e.g., wlan0, wlan1). <br />
    -a, --action   Action number or alias (e.g., 1 or monitor). <br />
    -p, --params   Parameter identifiers (e.g., 1,2,a or 3rtv, depends on action). <br />

    Actions:
    1 or monitor,
    2 or deauth,
    3 or beacon_spam,
    4 or fuzzer,
    5 or audit,
    6 or hopper,
    7 or eviltwin
    8 or packet_crafter

    Parameters must be provided in the same format as in the CLI, specific for every action.
    To list all parameters for a given action, just provide -a argument without -p.
  </pre>
  </div>
  </details>

  <h2><strong>6. Details</strong></h2>

  - **Packet Monitor** - Sniffs the WiFi packets in the air, analyze them and return the result onto the python's curses display. Catches SSIDs, MACs, Clients, Uptime, Channel, Signal (dBm), Encryption and resolves manufacturer. Catches PMKIDs in hashcat crackable format, and 4-way Handshakes, as well as other EAPOL packets. Logs the captured session to the **/caps** folder or every captured packet if _Save output_ was selected.
  - **Deauthentication Attack (Deauthing)** - Disconnects a device from the network by sending a packet containing AP<sup>1</sup> address, device address (or broadcast for _Mass Deauthing_) and the deauthentication frame with a reason of kicking the client(s). In case where a device address is a broadcast address, the AP will in most cases disconnect all clients at once. Freeway creates separate thread for every AP or client found in order to make deauthing maximally efficient.
  - **Beacon Flood Attack** - Floods the nearby WiFi scanners with fake or malformed APs. It can cause the devices looking for WiFi to behave abnormally (e.g. crash, freeze, drain the battery or run slower) and disrupt the nearby network traffic. User is able to specify his own ssid list, use the default one and generate correct (but random) or malformed beacon packets.
  - **Packet Fuzzer** - Fuzzing is a technique of network vulnerability assesment by sending a wide array of malformed or semi-random data to network interfaces and observing the responses. Freeway covers: **Replay captured packets (RX&TX<sup>2</sup>)**, **Spam CTS/RTS or Probe requests** and **Flood an AP with Authentication or Association Frames**. Devices that will capture fuzzed packets will behave differently depending on vulnerability level of receiver (!USE WITH CAUTION!).
  - **Network Audit** - Gathers all possible information about specific network and returns them onto the curses view. Tracks all clients signal and last activity, as well as resolve the manufacturer.
  - **Channel Hopper** - Changes the current channel of the network adapter. Helpful in making specific attacks more successful.
  - **Evil Twin** - Hosts a legitimate Access Point with Captive Portal, this 'legitimate' AP asks user for login/ bank credentials, or to download malware. First, there's a normal AP created, most times with an ESSID and MAC of existing network. Then, we host our captive portal (e.g., login website), so a normal web server, that reroutes users to our `index.html` trying to associate with the network we spoof.
  - **Packet Crafter** - Allows to construct proper .11 frames, modify them with custom values, and send in the air using multiple interfaces on a custom number of threads. Useful for quick packet delivery, educational activities, or threaded/ multi-node penetration. All encapsulated in a user-friendly interface with prompt-after-prompt typing.

  <sup>1<sup>**Access Points**</sup></sup>

  <sup>2<sup>**Transceive and receive at the same time**</sup></sup>

  <h2><strong>7. Uninstall</strong></h2>

  In case where Freeway doesn't meet the expectations and was installed via pip, the removal process is as easy:

      sudo pip uninstall 3way

  <h1>EULA</h1>

  **1)** Users must strictly adhere to local legal guidelines

  **2)** Users must not disrupt, introduce chaos, cause damage to others, or to other devices in any circumstances

  **3)** Redistribution of this software must comply with MIT license standards

  **4)** The author disclaims all liability for any damage caused by the use of this software

  **5)** In the event of an investigation, the author will not provide assistance to any parties

  **Remember, the purpose of Freeway is to identify vulnerabilities, not to exploit them!**

  <h2>TODO</h2>

  ✅ Evil Twin attack

  ✅ Version & update checker

  ✅ PyPi Release

  ✅ Packet Crafter

  <h2>Changelog</h2>

  > 19.05
  > 1. Fixed rare RuntimeError in deauth.py caused by iterating on dynamicly changing size dictionary
  > 2. Further improvements of beacon packet formatting in beacon_spam.py

  > 27.05
  > 1. Added `updater.py`
  > 2. Added `evil_twin.py`
  > 3. Added `/templates` folder
  > 4. Added Evil Twin to actions list
  > 5. Updated README.md
  > 6. PyPi Release

  > 3.06
  > 1. Added `git_downloader.py`
  > 2. Updated `beacon_spam`
  > 3. Updated `evil_twin`

  > 27.06
  > 1. Removed `EULA` from script
  > 2. Added `EULA` to `README.md`
  > 3. Added `pkt_crafter.py`
  > 4. Modified `Freeway` script

  <h2>Known Issues</h2>

  > 1. Android filters out fake beacon frames (works for Android 5, doesn't on Android 11+, versions below Android 11  and above Android 5 were not tested.)
  > 2. EvilTwin needs a second adapter connected to the internet (not really an issue), to be able to reroute traffic

  <h2><strong>Legal Note</strong></h2>

  > [!IMPORTANT]
  > Any malicious use of such features should be considered a crime, <br />
  > always assert permission to perform the penetration testing.

  <h2><strong>License</strong></h2>

  The distribution of Freeway is regulated by the standard MIT license, users can feel free to use, share and contribute to the repository or report bugs.


pkgId: ecc56cccf5d6ee6eca69ddd2b376814bbee364a2d803660be024b34edfa0a2c0
name: python-42-taskmaster
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A process manager project for 42
url: https://pypi.org/project/42-taskmaster/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-42-taskmaster-1.0.2-1.src.rpm
checksum_type: sha256
description:
  <!-- PROJECT LOGO -->
  <br />
  <div align="center">
    <a href="https://github.com/PandeoF1/42-taskmaster">
      <img src="https://raw.githubusercontent.com/PandeoF1/42-taskmaster/main/images/logo.png" alt="Logo" width="80" height="80">
    </a>

  <h3 align="center">42 - Taskmaster</h3>

    <p align="center">
      Services management and monitoring tool
    </p>
  </div>




  Taskmaster is a job control manager project for 42 school.
  It allows its users to control a number of processes on operating systems.

  Inspired by the [Supervisor](https://github.com/Supervisor/supervisor)



  Create a virtual environment using the following command:

  * venv
    ```sh
    python3 -m venv venv && source venv/bin/activate
    ```

  * pip
    ```sh
    pip install -r requirements.txt
    ```

  or use the devcontainer provided in the repository.



  * [Python](https://www.python.org/)
  * [Cerberus](https://docs.python-cerberus.org/) # Provides data validation
  * [PyYAML](https://pypi.org/project/PyYAML/) # Provides YAML parsing and dumping



  * From pypi
    ```sh
    pip install 42-taskmaster
    ```

  * From source
    ```sh
    pip install .
    ```



  * Without arguments (load taskmaster.yml from current directory)
      ```sh
      taskmaster
      ```
  * With arguments
      ```sh
      taskmaster -f /path/to/config.yml
      ```
  * Without install
      ```sh
      python -m taskmaster.taskmaster
      ```



  ```yaml
  email:  # Optionnal
   to: ""
   smtp_email: ""
   smtp_password: ""
   smtp_server: "smtp.gmail.com"
   smtp_port: 465

  services:
    - name: sleep
      cmd: "sleep 100"
      numprocs: 8 # min 1 max 32
      umask: 077
      workingdir: /tmp
      autostart: true
      autorestart: unexpected # always, never unexpected
      exitcodes:
        - 0
        - 2
      startretries: 3
      starttime: 5
      stopsignal: USR1
      stoptime: 10
      env: # Optionnal
        test: "test"
      stdout: ./taskmaster.yml # Optionnal (if not present don't log)
      stderr: /workspaces/42-taskmaster/logs/taskmaster.log # Optionnal
      
  ```


  <!-- CONTRIBUTING -->


  Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.

  If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
  Don't forget to give the project a star! Thanks again!

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request





  Nard Théo - GUI / Configuration

  Lafay Timothée - Services management


pkgId: dd4dcfdcde56d0dbdb159b294de3eb092c81b679f54b6b4ac25917a7c8f1039a
name: python-42Points
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: Python implementation of the fourty-two points game.
url: https://github.com/T0nyX1ang/42-Points-Game
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-42Points-1.2.7-1.src.rpm
checksum_type: sha256
description:
  ![42Points](https://github.com/T0nyX1ang/42-Points-Game/workflows/42Points/badge.svg)
  [![Maintainability](https://api.codeclimate.com/v1/badges/9502c3fcb954f16254cf/maintainability)](https://codeclimate.com/github/T0nyX1ang/42-Points-Game/maintainability)
  [![codecov](https://codecov.io/gh/T0nyX1ang/42-Points-Game/branch/master/graph/badge.svg)](https://codecov.io/gh/T0nyX1ang/42-Points-Game)
  ![PyPI](https://img.shields.io/pypi/v/42Points)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/42Points)
  ![PyPI - License](https://img.shields.io/pypi/l/42Points)

  Python implementation of the fourty-two points game.


  "42 Points" game is a variation based on the popular and long-lived "24 Points" game. The player should only use addition, subtraction, multiplication, division and parentheses and __five__ integers between 0 and 13 (inclusive) to get 42. It's really simple to understand, as the core of the game still relies on math calculations.


  This package is designed to __work as a core processing part__, providing:
  *   Problem database
  *   Problem generation (by user / in database)
  *   Start / stop the game
  *   Timer for solutions
  *   Player statistics
  *   Equivalent solution detection
  *   A bunch of APIs and exceptions

  This package is not designed to __fully implement everything__ with the game, so the formatting parts should be written by end-users. But don't worry, the API in this package is enough to create whatever you need.


  As equivalent detection is not a easy issue, we will make several changes to make sure it satisfies our need in the following upgrades. Please just kindly use the latest version.

  It's recommended to use `pip`:
  ```bash
      pip install --upgrade 42Points
  ```

  But building with `setup.py` will also work, as no other third-party dependencies are required for this package.

  After you have installed the package, you are almost done. If you want to try it out quickly, just open your IDLE (or something like that) and type:
  ```py
      from ftptsgame import FTPtsGame
      app = FTPtsGame() # initialize
      app.generate_problem(problem=[1, 2, 3, 4, 5]) # generate a problem beforehand
      app.start() # start the game
      app.get_current_problem() # show the problem
      app.solve('2 * 4 * 5 + 3 - 1') # put forward a valid solution
      app.get_current_solutions() # show all solutions
      app.get_remaining_solutions() # show remaining solutions
      app.stop() # stop the game
  ```

  Well, you can integrate this package into your projects by using just the same way, and you can format problems in all the ways you like.


  *   `PermissionError`: Raised during a status check, some methods must be used in the game, while other can't be used.
  *   `TypeError`: Raised when the problem type is not defined.
  *   `ValueError`: Raised when the parameter of generating a problem is invalid, or a user inputs unmatched numbers.
  *   `OverflowError`: Raised when a user input a too long expression. (greater than or equal to 30 characters after beautifying)
  *   `SyntaxError`: Raised when a user input an expression which can't be parsed.
  *   `ArithmeticError`: Raised when a user inputs a wrong answer.
  *   `LookupError`: Raised when a user inputs an equivalent answer.
  *   Other exceptions will be raised when an input fails built-in parameter checks.


  This package is licensed under the `MIT License`.


  Pull requests and issues are warmly welcomed.


pkgId: 4dcd7c1e9ac9748590c288b973cc4ad67e6922911b56baf12d0fdf83fbb17718
name: python-42cc-pystyle
arch: src
version: 0.0.17
epoch: 0
release: 1
summary: flake8 checks for 42 Coffee Cups style guide
url: https://github.com/akhavr/42cc-pystyle
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-42cc-pystyle-0.0.17-1.src.rpm
checksum_type: sha256
description:
  flake8 plugins for 42 Coffee Cups style checks

  - 0.0.7
  flake8 version bump to 3.8.3

  - 0.0.6
  fixed flake8 warnings :)

  - 0.0.5
  fixed package layout declaration

  - 0.0.4
  fixed nosetests

  - 0.0.3
  moved code to a subfolder

  - 0.0.2
  Added MANIFEST.in

  - 0.0.1
  Tests should have docstrings
  Tests for the module could be run via `nosetests` or `python setup.py nosetests`


pkgId: 63ac5b1f9110ba4f858ef5e7a992270767d87d75a93f1450df10a4bd3f2a8684
name: python-42towels
arch: src
version: 0.1.1011
epoch: 0
release: 1
summary: an essential item for any intergalactic hitchhiker
url: https://pypi.org/project/42towels/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-42towels-0.1.1011-1.src.rpm
checksum_type: sha256
description:
  the utility of "`thinker`" in all the cases above is **one single API** that would work for local models as well as non local models such as Claude, etc.

  while [this](#llm-libraries-and-frameworks-are-unnecessary) is still very true, an ability to express LLM communication in just functions vs. "raw prompt + HTTP call"s allows for breaking complex problems into smaller pieces, and converting what could otherwise be inconsistent, repetitive sequence of commands, into beautiful function compositions.
  let's work step by step to take a single Python function and "LLM enable" it, giving it some warmth by wrapping it in a @towel.
  this function expects a JSON formatted article that it will then convert to markdown format: i.e. a normal, every day, programming task:
  > _a full example lives in [docs/examples/wrap_it.py](docs/examples/wrap_it.py)._
  ```python
  def convert_json_to_markdown(article: str) -> str:
      parsed = json.loads(article)
      md = []
      md.append(f"# {article.get('title', 'Untitled')}")
      
      return '\n'.join(md)
  ```
  the problem is of course in corner cases, malformed JSON, adding / removing features, changing spelling, format, etc. as this function does not really generalize well for inputs it is unable to handle.
  let's add some warmth to it: wrap it in a @towel:
  ```python
  from towel import thinker, towel, tow, intel
  @towel(prompts={"to_markdown": "convert this JSON {article} to markdown"})
  def convert_json_to_markdown(article: str) -> str:
    llm, prompts, *_ = tow()
    thought = llm.think(prompts['to_markdown'].format(article=article))
    return thought.content[0].text
  ```
  now as this function is warm (wrapped in a @towel), let's give it a go:
  ```python
  llm = thinker.Ollama(model="llama3:latest")


  with intel(llm=llm):
      markdown = convert_json_to_markdown(json_article)
  print(markdown)
  ```
  and we see the exact same markdown that was produced by the first, non LLM, "cold" Python function.</br>
  an interesting aspect about this @towel function is that it _generalizes_: it can convert a lot more JSON formats, and handle a lot more corner cases.
  you can check out and run [docs/examples/wrap_it.py](docs/examples/wrap_it.py) to experiment with both.

  eeny, meeny, miny, moe..
  looking at the example above it might not be obvious what "`intel`" and "`tow`" are doing.
  "`intel`" is a function that sets up a thread local context for this "convert_json_to_markdown" function run</br>
  and, in this case, it sets it up with an extra variable: "`llm`"
  ```python
  with intel(llm=llm):
      markdown = convert_json_to_markdown(json_article)
  ```
  which is later available inside this function via "`tow()`":
  ```python
  @towel(prompts={"to_markdown": "convert this JSON {article} to markdown"})
  def convert_json_to_markdown(article: str) -> str:
    llm, prompts, *_ = tow()
    
  ```
  you can notice that "`tow()`" also makes "`prompts`" accessible.
  "`prompts`" are, of course, optional and can be created inside the function, passed in, etc.</br>
  at the end this is just a function, so anything Python goes.

  you can see a simple, but much more interesting example in [docs/examples/paper_summarizer.py](docs/examples/paper_summarizer.py)</br>
  where a single @towel takes a link to  white paper, pulls it down from the web and does these 3:
  ```python
  @towel(prompts={'main points': 'summarize the main points in this paper',
                  'eli5':        'explain this paper like I\'m 5 years old',
                  'issues':      'summarize issues that you can identify with ideas in this paper'})
  def summarize_paper(url):
    
  ```
  > [!NOTE]
  _more examples in [docs/examples](docs/examples)_

  * LLM communication with "`thinker`"</br>
  and
  * "`@towel`" function composition
  allow towel to empower an LLM, or a collection of LLMs, to _**plan**_ their activities given one or more problems to solve.

  a "plan" is a sequence of steps, routes and pins:

  a step is a single executable unit of a plan. it sounds more than it really is since it is just an arbitrary function, in most cases a @towel function.
  example:
  ```python
  from towel import step
  def find_meaning_of_life():
    return {"meaning_of_life": 42}
  >>> step(find_meaning_of_life)
  <towel.guide.Step object at 0x1083e93d0>
  ```
  by itself "`step`" is not very useful, but as a part of a "plan" it is essential.

  a pin is a marker, or a checkpoint in a plan. it does not do anything besides having an addressable _name_:
  ```python
  from towel import pin
  >>> pin("rock and roll")
  <towel.guide.Pin object at 0x1083cc7d0>
  ```
  it is later heavily used by "route", as well as it is really useful for debugging a plan flow.

  a route is a conditional unit of a plan. whenever plan flow gets to a route, it runs a condition (i.e. checks things) and depending on that check the flow can be routed to any "pin".
  in order to create a route, it needs to be given a function or lambda:
  ```python
  from towel import route
  >>> route(lambda result: 'conclude' if result['find_meaning_of_life']['confidence'] > 0.8 else 'test meaning')
  <towel.guide.Route object at 0x108696e90>
  ```
  which means:
  * go to a "conclude" pin (a pin with name "conclude") iff a result from the "find_meaning_of_life" has a "confidence" key with a value greater than "0.8"
  * otherwise go to "test meaning" (a pin with name "test meaning")

  let's look a the real plan that is a sequence of steps, pins and routes:
  > _a full example lives in [docs/examples/space_trip.py](docs/examples/space_trip.py)_
  ```python
  from towel import step, route, pin, plan
  space_trip = plan([
      step(pick_planet),
      pin('are_you_ready'),
      step(how_ready_are_you),
      route(lambda result: 'book' if result['how_ready_are_you']['score'] > 95 else 'train'),
      pin('train'),
      step(space_bootcamp),
      route(lambda x: 'are_you_ready'),
      pin('book'),
      step(reserve_spaceship)
  ])
  ```
  it starts out with "`step(pick_planet)`" which would call a function `pick_planet`:
  ```python
  @towel
  def pick_planet():
      
      return {'destination': planets[choice].name}
  ```
  notice that this function returns "`destination`". internally towel would hold on to the result from this function, and would make it available for all other functions via _arguments_.
  then the flow reaches "`pin('are_you_ready')`". it does nothing, as pins _do_ nothing.
  it then moves on to the "`step(how_ready_are_you)`" which calls a function `how_ready_are_you`:
  ```python
  @towel
  def how_ready_are_you(destination):
      
      return {'score': readiness.score}
  ```
  notice that nothing inside the plan definition is passing any arguments into `how_ready_are_you`, but it does take a "`destination`" argument.<br/>
  this destination argument will be passed (by name) from the internal plan context that _remembers all the return values from all the steps_ and makes them available as function arguments.
  the flow then looks at the route:
  ```python
  route(lambda result: 'book' if result['how_ready_are_you']['score'] > 95 else 'train')
  ```
  which would:
  * route the flow to the "`pin('book')`" iff the "`score`" value of the `how_ready_are_you` step is larger than `95`
  * otherwise it would route to the "`pin('train')`"
  the rest is of the flow uses the exact same concepts
  > [!TIP]
  > remember to return dictionaries from `@towel` functions that are part of the plan</br>
  > as the **_keys_** from those dictionaries then matched to other step function **_arguments_** </br>
  > and if it is a match values are bound / arguments are _passed_ by the flow

  as you can see in the example ([docs/examples/space_trip.py](docs/examples/space_trip.py)), a plan is executed by the "`thinker.plan()`" function:
  ```python
  llm = thinker.Ollama(model="llama3:latest")

  trip = thinker.plan(space_trip,
                      llm=llm)
  say("trip is booked:", f"{json.dumps(trip['reserve_spaceship'], indent=2)}")
  ```

  since plans have many steps, it might be needed to perform some steps with LLMs that are better suited for it.
  by default a plan would execute all the steps with an LLM that was provided to it:
  ```python
  blueprint = make_plan()
  thinker.plan(blueprint,
               llm=llama)
  ```
  in case some steps need to be done by different LLMs, a plan takes a "`mind_map`" argument:
  ```python
  thinker.plan(blueprint,
               llm=llama,
               mind_map={"review_stories": claude},
               start_with={"requirements": requirements})
  ```
  all the steps in this plan are going to be performed by a "llama" model, but a "review_stories" step will be done by "claude"
  you can look at the full example in [docs/examples/execute_da_plan.py](docs/examples/execute_da_plan.py)<br/>
  where a smaller "`llama3 8B`" takes requirements, creates user stories, but "`claude`" is the one who reviews these stories, and provides feedback:
  ```python
      return plan([
          step(create_stories),
          pin('review'),
          step(review_stories),   ## <<< this step will be done by Claude
          route(lambda result: 'revise' if result['review_stories']['quality_score'] < 0.8 else 'implement'),
          pin('revise'),
          step(revise_stories),
          route(lambda x: 'review'),
          pin('implement'),
          step(implement_code)
  ])
  ```

  plan is usually kicked off with initial data: a problem definition or a question
  this is done via a "`start_with`" plan argument:
  ```python
  thinker.plan(blueprint,
               llm=llama,
               start_with={"requirements": requirements})
  ```
  and "`requirements`" would most likely be a function argument name in the first step in this plan.

  plan's clear [vocabulary](#vocabulary) and the fact the plan itself is a data structure enables LLMs to take in a problem<br/>
  ```python
  from towel import towel, tow
  from towel.type import Plan
  from towel.prompt import make_plan
  @towel(prompts={'plan': """given this problem: {problem} {make_plan}"""})
  def make_da_plan(problem: str):
      llm, prompts, *_ = tow()
      plan = llm.think(prompts['plan'].format(problem=problem,
                                              make_plan=make_plan),
                       response_model=Plan)
      return plan
  ```
  this function takes a problem and creates a plan
  > full example is in [docs/examples/make_da_plan.py](docs/examples/make_da_plan.py)
  for example, here is a plan Claude created to..
  ```python
  llm = Claude(model="claude-3-haiku-20240307")
  with intel(llm=llm):
      plan = make_da_plan("make sure there are no wars")
  ```
  ```python
  [
    step(analyze_current_global_conflicts),
    step(identify_root_causes),
    step(assess_diplomatic_relations),
    route(lambda result: 'improve_diplomacy' if result['assess_diplomatic_relations']['status'] == 'poor' else 'address_economic_factors'),
    pin('improve_diplomacy'),
    step(organize_peace_talks),
    step(implement_conflict_resolution_strategies),
    route(lambda result: 'address_economic_factors' if result['implement_conflict_resolution_strategies']['success'] else 'reassess_diplomatic_approach'),
    pin('reassess_diplomatic_approach'),
    
    pin('promote_sustainable_development'),  step(implement_environmental_protection_measures),
    step(develop_renewable_energy_sources),
    pin('monitor_and_evaluate'),
    step(establish_global_peace_index),
    step(conduct_regular_peace_assessments),
    route(lambda result: 'analyze_current_global_conflicts' if result['conduct_regular_peace_assessments']['global_peace_score'] < 0.9 else 'maintain_peace'),
    pin('maintain_peace'),
    step(continue_peace_initiatives)
  ]
  ```

  this example [docs/examples/system_two/planer.py](docs/examples/system_two/planer.py) takes it one step further and:
  * given a problem
  * it follows a plan
  * to create a plan
  * to solve the problem
  this is an interesting area to improve on:
  * create functions of runtime created plans
  * _safely_ execute them
  * create more plans
  * and keep researching
  but even at its current state it is capable of creating and refining (with a stronger model) plans to provide solid approaches to solve complex problems
  the gist is:
  ```python
  def plan_maker(problem: str):
      blueprint = plan([
          step(research_problem),   ## as part of research, goes online to supplement LLM knowledge with fresh results
          step(restate_problem),
          step(divide_problem),
          step(create_plan),
          pin('review'),
          step(review_plan),
          route(lambda result: 'refine' if result['review_plan']['needs_refinement'] else 'end'),
          pin('refine'),
          step(refine_plan),
          route(lambda _: 'review'),
          
          
          
          pin('end')
      ])
      default_model = thinker.Ollama(model="llama3:70b")
      stronger_model = thinker.Claude(model="claude-3-5-sonnet-20240620")
      mind_map = {
          "review_plan": stronger_model
      }
      result = thinker.plan(blueprint,
                            llm=default_model,
                            mind_map=mind_map,
                            start_with={"problem": problem})
  ```

  Copyright © 2024 tolitius
  Distributed under the Eclipse Public License either version 1.0 or (at
  your option) any later version.


pkgId: 13b606d7641249db1515052f790e81a9c48295d5d1c0bcccaadf8b44d5173789
name: python-437-project
arch: src
version: 1.3
epoch: 0
release: 1
summary: Event management system
url: https://github.com/tianakk/437-project
rpm_license: Personal
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-437-project-1.3-1.src.rpm
checksum_type: sha256
description:
  Using this event management system, a user can create events or book tickets for an event as well as view all events and all tickets or get a summary of all tickets


pkgId: 856defba4cbb8c3f0113fe80b70b6fd946e050ad5ae66e61d9102b4ff8cbdcd6
name: python-4ch
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Python wrapper for the 4chan JSON API.
url: https://github.com/sysr-q/4ch
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-4ch-1.0.0-1.src.rpm
checksum_type: sha256
description:
  fourch (stylized as 4ch) is a wrapper to the 4chan JSON API, provided by moot. It allows you to interact with 4chan (in a READONLY way) easily through your scripts.
  Originally <strike>stolen</strike> forked from `e000/py-4chan <https://github.com/e000/py-4chan>`_, but then I moved repos and renamed stuff since I'm pretty bad about that.


pkgId: 73809389a16974bf617fe6b4da8a33203f15dd86e4ae81ac187c8d92a689bcdc
name: python-4scanner
arch: src
version: 1.6.3
epoch: 0
release: 1
summary: 4chan threads scanner
url: https://github.com/Lacsap-/4scanner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-4scanner-1.6.3-1.src.rpm
checksum_type: sha256
description:
  ![4scanner logo](logo/4scanner128.png)

  4scanner can search multiple imageboards threads for matching keywords then download all images to disk.


  - 4chan
  - lainchan
  - uboachan

  You can create an issue if you want to see other imageboards supported



  ` pip3 install 4scanner `

  (4scanner is ONLY compatible with python3+)

  For Arch Linux there is an [AUR package](https://aur.archlinux.org/packages/4scanner/)


  Create a config (detail below), name it config.json and drop it where you would like to download the images. Then run a container:

  `docker run -v /can/be/anywhere:/output -v /anywhere/else:/root/.4scanner lacsap/4scanner`

  `/can/be/anywhere` Can be anywhere on your computer, images will be downloaded there (This is the directory where you need to put the config.json)
  `/anywhere/else` Can be anywhere on your computer, it will contain the sqlite3 database 4scanner use to keep track of downloaded threads and duplicate



  the first thing you need to do is create a simple json file with the directories names
  you want, the boards you want to search and the keywords.
  (see the json file section for more details)

  After your json file is done you can start 4scanner with:

  ` 4scanner file.json `

  it will search all threads for the keywords defined in your json file and
  download all images/webms from threads where a keyword is found. (In the current directory unless you specify one with -o )



  The `4genconf` utility is now installed as of 4scanner 1.5.1. This utility will ask you simple questions about what you want to download and generate a configuration file for you!



  Creating the JSON file is easy, you can use the example.json file as a base.

  Your "Searches" are what 4scanner use to know which board to check for what keywords and the name of the folder where it needs to download the images, you can have as many "Searches" as you want.

  Here is an example of what the JSON file should look like:
  ```json
  {"searches":[
      {
        "imageboard": "IMAGEBOARD",
        "folder_name": "YOUR_FOLDER_NAME",
        "board": "BOARD_LETTER",
        "keywords": ["KEYWORD1", "KEYWORD2"]
      },

      {
        "imageboard": "4chan",
        "folder_name": "vidya",
        "board": "v",
        "keywords": ["tf2", "splatoon", "world of tank"]
      }
  ]}
  ```



  4scanner has a lot of options for downloading only the images you want. Such as downloading only images with a certain width or height, or only images with a certain extension.

  To see all available options with examples check out: [OPTIONS.md](OPTIONS.md)

  [Hydrus Network](https://hydrusnetwork.github.io/hydrus/) users: check out the `tag` [option](OPTIONS.md) to automatically tag your images on import

  - Example with all optional options
  ```json
  {"searches":[
      {
        "imageboard": "4chan",
        "folder_name": "vidya",
        "board": "v",
        "width": ">1000",
        "height": ">1000",
        "filename": "IMG_",
        "extension": [".jpg", ".png"],
        "tag": ["game"],
        "keywords": ["tf2", "splatoon", "world of tank"],
        "check_duplicate": true,
        "subject_only": false
      }
  ]}
  ```

  This will download images bigger than 1000x1000 which are .jpg or .png with a filename containing ``` IMG_ ```



  - the keywords search is case insensitive



  4downloader is also installed with 4scanner and can be use to download
  a single thread like this:
  ``` 4downloader http://boards.4chan.org/b/thread/373687492 ```

  It will download all images until the thread die.
  You can also download threads from imageboards other than 4chan with ```-i```


pkgId: cbd07a5627f32cef59be2775fa2ccf86ff643aa9971db0e69674d7a602a23dca
name: python-4th-ir-ai-models
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Access a collection of sophisticated AI models.
url: https://www.4th-ir.com/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-4th-ir-ai-models-0.5.3-1.src.rpm
checksum_type: sha256
description:
  <img src="https://drive.google.com/uc?export=view&id=1AKtpI2nYDZBaPwKc6mQJCY1M0iaT_VEo" align="right"
       alt="Logo" width="80" height="80">




  This package contains various methods for accessing AI models created by 4th-IR through an API.




  * [Text Classification - Facebook- Bart-large-mnli](https://text-classification-bart-large.icysmoke-f4846de1.switzerlandnorth.azurecontainerapps.io/docs)
  * [Text Classification - BART](https://text-classification-bart.agreeabledune-08a9cefb.switzerlandnorth.azurecontainerapps.io/docs)
  * [Text Classification - Valhalla- Distil-mnli-12](https://text-classification-disbart-mnli.calmground-e921d537.switzerlandnorth.azurecontainerapps.io/docs)



  * [Text Summarization - Bert2Bert Small](https://text-summarization.agreeabledune-08a9cefb.switzerlandnorth.azurecontainerapps.io/docs)




  * [Text Utility](https://text-utility.ai-sandbox.ch/docs)



  * [Name Entity Recognition Spacy](https://text-named-entity-recognition-spacy-ner.ai-sandbox.ch)




  * [Mistral](https://mistral.agreeabledune-08a9cefb.switzerlandnorth.azurecontainerapps.io/docs)




  * [Image Classification - CLIP ViT](https://image-class-openai-clip-vit.agreeabledune-08a9cefb.switzerlandnorth.azurecontainerapps.io/docs)

  * [Image Classification - Dit-base-finetuned-rvlcdip](https://image-c-document-finetuned.agreeabledune-08a9cefb.switzerlandnorth.azurecontainerapps.io/docs)

  * [Image Classification - EfficientNetB1](https://image-class-efficientnet.blackdune-63837cff.switzerlandnorth.azurecontainerapps.io/docs)

  * [Image Classification - Facebook Diet Distilled](https://image-class-fb-diet-small-dist.icysmoke-f4846de1.switzerlandnorth.azurecontainerapps.io/)

  * [Image Classification - Facebook Levit 128S](https://image-class-facebook-levit.blackdune-63837cff.switzerlandnorth.azurecontainerapps.io/docs)

  * [Image Classification - Microsoft Swin Base](https://image-class-microsoft-swin-base.blackdune-63837cff.switzerlandnorth.azurecontainerapps.io/docs)

  * [Image Classification - CLIP ViT (Patch)](https://image-classification-clip-vit.blackdune-63837cff.switzerlandnorth.azurecontainerapps.io/docs)

  * [Image Classification - Resnet 50](https://image-class-resnet.icysmoke-f4846de1.switzerlandnorth.azurecontainerapps.io/docs)



  * [Text Comparison - All-MPnet-Base-v2](https://text-comparison-mpnet.calmflower-186525cd.switzerlandnorth.azurecontainerapps.io/docs)

  * [Text Comparison - AllMiniLM](https://text-comparison-minilm.calmflower-186525cd.switzerlandnorth.azurecontainerapps.io)




  * [Text Translation - Transformers(English, French, Romanian, German)](https://text-translation-transformers.blackdune-63837cff.switzerlandnorth.azurecontainerapps.io/docs)




  * [Text Sentimental Analysis Bert Multilingual](https://text-sentiment-analysis.calmflower-186525cd.switzerlandnorth.azurecontainerapps.io/api/v1/classify)




  * [Question and Answering Intel DynamicTinybert](https://tqa-intel-dynamic-tinybert.agreeabledune-08a9cefb.switzerlandnorth.azurecontainerapps.io/docs)

  * [Question Answering Distilbert Base Cased Distilled Squad](https://tqa-distilbert-distilled-squad.blackdune-63837cff.switzerlandnorth.azurecontainerapps.io)




  * [Object Detection Circular Net](https://image-obje-detec-circularnet.icysmoke-f4846de1.switzerlandnorth.azurecontainerapps.io)
  * [Object Detection EfficientDet/d7](https://image-object-dec-effi-det.icysmoke-f4846de1.switzerlandnorth.azurecontainerapps.io)
  * [Inception Resnet v2/ Faster RCNN Object Detection](https://image-object-detect-inception-v2.icysmoke-f4846de1.switzerlandnorth.azurecontainerapps.io)
  * [Faster R-CNN with Inception Resnet v2](https://image-obj-detec-incep-resnet.icysmoke-f4846de1.switzerlandnorth.azurecontainerapps.io)




  * [Age Classification - Google Vit Base](https://image-vit-age-classifier.icysmoke-f4846de1.switzerlandnorth.azurecontainerapps.io/)



  * [Text to Speech Silero](https://audio-speech-to-text-silero.agreeabledune-08a9cefb.switzerlandnorth.azurecontainerapps.io/)

rpm_license:
  MIT License  Copyright (c) [2024] [4th-IR]  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: 9942a40a8defd8008f3814b08d851be8a38243c0e5eb26651c71b8099888b2ff
name: python-51job-autotest-framework
arch: src
version: 0.3.8
epoch: 0
release: 1
summary: Python Project For QA Test
url: https://gitee.com/jason024/python_project
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-51job-autotest-framework-0.3.8-1.src.rpm
checksum_type: sha256
description:
  {**以下是 Gitee 平台说明，您可以替换此简介**
  Gitee 是 OSCHINA 推出的基于 Git 的代码托管平台（同时支持 SVN）。专为开发者提供稳定、高效、安全的云端软件开发协作平台
  无论是个人、团队、或是企业，都能够用 Gitee 实现代码托管、项目管理、协作开发。企业项目请看 [https://gitee.com/enterprises](https://gitee.com/enterprises)}


  软件架构说明




  1.  xxxx
  2.  xxxx
  3.  xxxx



  1.  xxxx
  2.  xxxx
  3.  xxxx



  1.  JasonZheng



  1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
  2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
  3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
  4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
  5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
  6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)


pkgId: 60bfc78ae8ad470d24991b8915599728147e78fe3829dec6c71cf0881d992ae1
name: python-5g-core-common-schemas
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: Common Schemas used in 5G core
url: https://github.com/gruyaume/5g-core-common-schemas
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-5g-core-common-schemas-1.0.9-1.src.rpm
checksum_type: sha256
description:
  Common schemas used in 5G core network services.



  Install the package:
  ```bash
  pip install 5g-core-common-schemas
  ```

  Use the library in your project:
  ```python
  from fiveg_core_common_schemas.NfInstanceId import NfInstanceId

  my_instance = NfInstanceId("banana")
  ```


pkgId: e27db035b430986586840570f25cc72f94fcefeb507754ae18124719c8911f78
name: python-5gasp-cli
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: 5GASP CLI to create testing descriptors.
url: https://github.com/5gasp/5gasp-cli
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-5gasp-cli-0.4.0-1.src.rpm
checksum_type: sha256
description:
  You can find the code inside the */5gasp-cli/src/* directory.
  To list all CLI commands, run:

  ```
  5gasp-cli --help
  ```

  To list all parameters of a command, run:
  ```
  5gasp-cli COMMAND --help
  ```





  ```
  5gasp-cli list-testbeds
  ```



  ```
  5gasp-cli list-available-tests
  ```



  ```
  5gasp-cli create-testing-descriptor
  ```

  This command has the following options:

  * One or more NSDs (Network Service Descriptors) can be passed to infer connection point tags from, using the following command:

  ```
  5gasp-cli create-testing-descriptor --infer-tags-from-nsd <nsd_location>
  ```

  * The path of the generated descriptor can be passed using:

  ```
  5gasp-cli create-testing-descriptor --output-filepath <path_to_file>
  ```

  > **_NOTE:_** Both options can be used simultaneously
                      GNU GENERAL PUBLIC LICENSE
                         Version 3, 29 June 2007

   Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
   Everyone is permitted to copy and distribute verbatim copies
   of this license document, but changing it is not allowed.

                              Preamble

    The GNU General Public License is a free, copyleft license for
  software and other kinds of works.

    The licenses for most software and other practical works are designed
  to take away your freedom to share and change the works.  By contrast,
  the GNU General Public License is intended to guarantee your freedom to
  share and change all versions of a program--to make sure it remains free
  software for all its users.  We, the Free Software Foundation, use the
  GNU General Public License for most of our software; it applies also to
  any other work released this way by its authors.  You can apply it to
  your programs, too.

    When we speak of free software, we are referring to freedom, not
  price.  Our General Public Licenses are designed to make sure that you
  have the freedom to distribute copies of free software (and charge for
  them if you wish), that you receive source code or can get it if you
  want it, that you can change the software or use pieces of it in new
  free programs, and that you know you can do these things.

    To protect your rights, we need to prevent others from denying you
  these rights or asking you to surrender the rights.  Therefore, you have
  certain responsibilities if you distribute copies of the software, or if
  you modify it: responsibilities to respect the freedom of others.

    For example, if you distribute copies of such a program, whether
  gratis or for a fee, you must pass on to the recipients the same
  freedoms that you received.  You must make sure that they, too, receive
  or can get the source code.  And you must show them these terms so they
  know their rights.

    Developers that use the GNU GPL protect your rights with two steps:
  (1) assert copyright on the software, and (2) offer you this License
  giving you legal permission to copy, distribute and/or modify it.

    For the developers' and authors' protection, the GPL clearly explains
  that there is no warranty for this free software.  For both users' and
  authors' sake, the GPL requires that modified versions be marked as
  changed, so that their problems will not be attributed erroneously to
  authors of previous versions.

    Some devices are designed to deny users access to install or run
  modified versions of the software inside them, although the manufacturer
  can do so.  This is fundamentally incompatible with the aim of
  protecting users' freedom to change the software.  The systematic
  pattern of such abuse occurs in the area of products for individuals to
  use, which is precisely where it is most unacceptable.  Therefore, we
  have designed this version of the GPL to prohibit the practice for those
  products.  If such problems arise substantially in other domains, we
  stand ready to extend this provision to those domains in future versions
  of the GPL, as needed to protect the freedom of users.

    Finally, every program is threatened constantly by software patents.
  States should not allow patents to restrict development and use of
  software on general-purpose computers, but in those that do, we wish to
  avoid the special danger that patents applied to a free program could
  make it effectively proprietary.  To prevent this, the GPL assures that
  patents cannot be used to render the program non-free.

    The precise terms and conditions for copying, distribution and
  modification follow.

                         TERMS AND CONDITIONS

    0. Definitions.

    "This License" refers to version 3 of the GNU General Public License.

    "Copyright" also means copyright-like laws that apply to other kinds of
  works, such as semiconductor masks.

    "The Program" refers to any copyrightable work licensed under this
  License.  Each licensee is addressed as "you".  "Licensees" and
  "recipients" may be individuals or organizations.

    To "modify" a work means to copy from or adapt all or part of the work
  in a fashion requiring copyright permission, other than the making of an
  exact copy.  The resulting work is called a "modified version" of the
  earlier work or a work "based on" the earlier work.

    A "covered work" means either the unmodified Program or a work based
  on the Program.

    To "propagate" a work means to do anything with it that, without
  permission, would make you directly or secondarily liable for
  infringement under applicable copyright law, except executing it on a
  computer or modifying a private copy.  Propagation includes copying,
  distribution (with or without modification), making available to the
  public, and in some countries other activities as well.

    To "convey" a work means any kind of propagation that enables other
  parties to make or receive copies.  Mere interaction with a user through
  a computer network, with no transfer of a copy, is not conveying.

    An interactive user interface displays "Appropriate Legal Notices"
  to the extent that it includes a convenient and prominently visible
  feature that (1) displays an appropriate copyright notice, and (2)
  tells the user that there is no warranty for the work (except to the
  extent that warranties are provided), that licensees may convey the
  work under this License, and how to view a copy of this License.  If
  the interface presents a list of user commands or options, such as a
  menu, a prominent item in the list meets this criterion.

    1. Source Code.

    The "source code" for a work means the preferred form of the work
  for making modifications to it.  "Object code" means any non-source
  form of a work.

    A "Standard Interface" means an interface that either is an official
  standard defined by a recognized standards body, or, in the case of
  interfaces specified for a particular programming language, one that
  is widely used among developers working in that language.

    The "System Libraries" of an executable work include anything, other
  than the work as a whole, that (a) is included in the normal form of
  packaging a Major Component, but which is not part of that Major
  Component, and (b) serves only to enable use of the work with that
  Major Component, or to implement a Standard Interface for which an
  implementation is available to the public in source code form.  A
  "Major Component", in this context, means a major essential component
  (kernel, window system, and so on) of the specific operating system
  (if any) on which the executable work runs, or a compiler used to
  produce the work, or an object code interpreter used to run it.

    The "Corresponding Source" for a work in object code form means all
  the source code needed to generate, install, and (for an executable
  work) run the object code and to modify the work, including scripts to
  control those activities.  However, it does not include the work's
  System Libraries, or general-purpose tools or generally available free
  programs which are used unmodified in performing those activities but
  which are not part of the work.  For example, Corresponding Source
  includes interface definition files associated with source files for
  the work, and the source code for shared libraries and dynamically
  linked subprograms that the work is specifically designed to require,
  such as by intimate data communication or control flow between those
  subprograms and other parts of the work.

    The Corresponding Source need not include anything that users
  can regenerate automatically from other parts of the Corresponding
  Source.

    The Corresponding Source for a work in source code form is that
  same work.

    2. Basic Permissions.

    All rights granted under this License are granted for the term of
  copyright on the Program, and are irrevocable provided the stated
  conditions are met.  This License explicitly affirms your unlimited
  permission to run the unmodified Program.  The output from running a
  covered work is covered by this License only if the output, given its
  content, constitutes a covered work.  This License acknowledges your
  rights of fair use or other equivalent, as provided by copyright law.

    You may make, run and propagate covered works that you do not
  convey, without conditions so long as your license otherwise remains
  in force.  You may convey covered works to others for the sole purpose
  of having them make modifications exclusively for you, or provide you
  with facilities for running those works, provided that you comply with
  the terms of this License in conveying all material for which you do
  not control copyright.  Those thus making or running the covered works
  for you must do so exclusively on your behalf, under your direction
  and control, on terms that prohibit them from making any copies of
  your copyrighted material outside their relationship with you.

    Conveying under any other circumstances is permitted solely under
  the conditions stated below.  Sublicensing is not allowed; section 10
  makes it unnecessary.

    3. Protecting Users' Legal Rights From Anti-Circumvention Law.

    No covered work shall be deemed part of an effective technological
  measure under any applicable law fulfilling obligations under article
  11 of the WIPO copyright treaty adopted on 20 December 1996, or
  similar laws prohibiting or restricting circumvention of such
  measures.

    When you convey a covered work, you waive any legal power to forbid
  circumvention of technological measures to the extent such circumvention
  is effected by exercising rights under this License with respect to
  the covered work, and you disclaim any intention to limit operation or
  modification of the work as a means of enforcing, against the work's
  users, your or third parties' legal rights to forbid circumvention of
  technological measures.

    4. Conveying Verbatim Copies.

    You may convey verbatim copies of the Program's source code as you
  receive it, in any medium, provided that you conspicuously and
  appropriately publish on each copy an appropriate copyright notice;
  keep intact all notices stating that this License and any
  non-permissive terms added in accord with section 7 apply to the code;
  keep intact all notices of the absence of any warranty; and give all
  recipients a copy of this License along with the Program.

    You may charge any price or no price for each copy that you convey,
  and you may offer support or warranty protection for a fee.

    5. Conveying Modified Source Versions.

    You may convey a work based on the Program, or the modifications to
  produce it from the Program, in the form of source code under the
  terms of section 4, provided that you also meet all of these conditions:

      a) The work must carry prominent notices stating that you modified
      it, and giving a relevant date.

      b) The work must carry prominent notices stating that it is
      released under this License and any conditions added under section
      7.  This requirement modifies the requirement in section 4 to
      "keep intact all notices".

      c) You must license the entire work, as a whole, under this
      License to anyone who comes into possession of a copy.  This
      License will therefore apply, along with any applicable section 7
      additional terms, to the whole of the work, and all its parts,
      regardless of how they are packaged.  This License gives no
      permission to license the work in any other way, but it does not
      invalidate such permission if you have separately received it.

      d) If the work has interactive user interfaces, each must display
      Appropriate Legal Notices; however, if the Program has interactive
      interfaces that do not display Appropriate Legal Notices, your
      work need not make them do so.

    A compilation of a covered work with other separate and independent
  works, which are not by their nature extensions of the covered work,
  and which are not combined with it such as to form a larger program,
  in or on a volume of a storage or distribution medium, is called an
  "aggregate" if the compilation and its resulting copyright are not
  used to limit the access or legal rights of the compilation's users
  beyond what the individual works permit.  Inclusion of a covered work
  in an aggregate does not cause this License to apply to the other
  parts of the aggregate.

    6. Conveying Non-Source Forms.

    You may convey a covered work in object code form under the terms
  of sections 4 and 5, provided that you also convey the
  machine-readable Corresponding Source under the terms of this License,
  in one of these ways:

      a) Convey the object code in, or embodied in, a physical product
      (including a physical distribution medium), accompanied by the
      Corresponding Source fixed on a durable physical medium
      customarily used for software interchange.

      b) Convey the object code in, or embodied in, a physical product
      (including a physical distribution medium), accompanied by a
      written offer, valid for at least three years and valid for as
      long as you offer spare parts or customer support for that product
      model, to give anyone who possesses the object code either (1) a
      copy of the Corresponding Source for all the software in the
      product that is covered by this License, on a durable physical
      medium customarily used for software interchange, for a price no
      more than your reasonable cost of physically performing this
      conveying of source, or (2) access to copy the
      Corresponding Source from a network server at no charge.

      c) Convey individual copies of the object code with a copy of the
      written offer to provide the Corresponding Source.  This
      alternative is allowed only occasionally and noncommercially, and
      only if you received the object code with such an offer, in accord
      with subsection 6b.

      d) Convey the object code by offering access from a designated
      place (gratis or for a charge), and offer equivalent access to the
      Corresponding Source in the same way through the same place at no
      further charge.  You need not require recipients to copy the
      Corresponding Source along with the object code.  If the place to
      copy the object code is a network server, the Corresponding Source
      may be on a different server (operated by you or a third party)
      that supports equivalent copying facilities, provided you maintain
      clear directions next to the object code saying where to find the
      Corresponding Source.  Regardless of what server hosts the
      Corresponding Source, you remain obligated to ensure that it is
      available for as long as needed to satisfy these requirements.

      e) Convey the object code using peer-to-peer transmission, provided
      you inform other peers where the object code and Corresponding
      Source of the work are being offered to the general public at no
      charge under subsection 6d.

    A separable portion of the object code, whose source code is excluded
  from the Corresponding Source as a System Library, need not be
  included in conveying the object code work.

    A "User Product" is either (1) a "consumer product", which means any
  tangible personal property which is normally used for personal, family,
  or household purposes, or (2) anything designed or sold for incorporation
  into a dwelling.  In determining whether a product is a consumer product,
  doubtful cases shall be resolved in favor of coverage.  For a particular
  product received by a particular user, "normally used" refers to a
  typical or common use of that class of product, regardless of the status
  of the particular user or of the way in which the particular user
  actually uses, or expects or is expected to use, the product.  A product
  is a consumer product regardless of whether the product has substantial
  commercial, industrial or non-consumer uses, unless such uses represent
  the only significant mode of use of the product.

    "Installation Information" for a User Product means any methods,
  procedures, authorization keys, or other information required to install
  and execute modified versions of a covered work in that User Product from
  a modified version of its Corresponding Source.  The information must
  suffice to ensure that the continued functioning of the modified object
  code is in no case prevented or interfered with solely because
  modification has been made.

    If you convey an object code work under this section in, or with, or
  specifically for use in, a User Product, and the conveying occurs as
  part of a transaction in which the right of possession and use of the
  User Product is transferred to the recipient in perpetuity or for a
  fixed term (regardless of how the transaction is characterized), the
  Corresponding Source conveyed under this section must be accompanied
  by the Installation Information.  But this requirement does not apply
  if neither you nor any third party retains the ability to install
  modified object code on the User Product (for example, the work has
  been installed in ROM).

    The requirement to provide Installation Information does not include a
  requirement to continue to provide support service, warranty, or updates
  for a work that has been modified or installed by the recipient, or for
  the User Product in which it has been modified or installed.  Access to a
  network may be denied when the modification itself materially and
  adversely affects the operation of the network or violates the rules and
  protocols for communication across the network.

    Corresponding Source conveyed, and Installation Information provided,
  in accord with this section must be in a format that is publicly
  documented (and with an implementation available to the public in
  source code form), and must require no special password or key for
  unpacking, reading or copying.

    7. Additional Terms.

    "Additional permissions" are terms that supplement the terms of this
  License by making exceptions from one or more of its conditions.
  Additional permissions that are applicable to the entire Program shall
  be treated as though they were included in this License, to the extent
  that they are valid under applicable law.  If additional permissions
  apply only to part of the Program, that part may be used separately
  under those permissions, but the entire Program remains governed by
  this License without regard to the additional permissions.

    When you convey a copy of a covered work, you may at your option
  remove any additional permissions from that copy, or from any part of
  it.  (Additional permissions may be written to require their own
  removal in certain cases when you modify the work.)  You may place
  additional permissions on material, added by you to a covered work,
  for which you have or can give appropriate copyright permission.

    Notwithstanding any other provision of this License, for material you
  add to a covered work, you may (if authorized by the copyright holders of
  that material) supplement the terms of this License with terms:

      a) Disclaiming warranty or limiting liability differently from the
      terms of sections 15 and 16 of this License; or

      b) Requiring preservation of specified reasonable legal notices or
      author attributions in that material or in the Appropriate Legal
      Notices displayed by works containing it; or

      c) Prohibiting misrepresentation of the origin of that material, or
      requiring that modified versions of such material be marked in
      reasonable ways as different from the original version; or

      d) Limiting the use for publicity purposes of names of licensors or
      authors of the material; or

      e) Declining to grant rights under trademark law for use of some
      trade names, trademarks, or service marks; or

      f) Requiring indemnification of licensors and authors of that
      material by anyone who conveys the material (or modified versions of
      it) with contractual assumptions of liability to the recipient, for
      any liability that these contractual assumptions directly impose on
      those licensors and authors.

    All other non-permissive additional terms are considered "further
  restrictions" within the meaning of section 10.  If the Program as you
  received it, or any part of it, contains a notice stating that it is
  governed by this License along with a term that is a further
  restriction, you may remove that term.  If a license document contains
  a further restriction but permits relicensing or conveying under this
  License, you may add to a covered work material governed by the terms
  of that license document, provided that the further restriction does
  not survive such relicensing or conveying.

    If you add terms to a covered work in accord with this section, you
  must place, in the relevant source files, a statement of the
  additional terms that apply to those files, or a notice indicating
  where to find the applicable terms.

    Additional terms, permissive or non-permissive, may be stated in the
  form of a separately written license, or stated as exceptions;
  the above requirements apply either way.

    8. Termination.

    You may not propagate or modify a covered work except as expressly
  provided under this License.  Any attempt otherwise to propagate or
  modify it is void, and will automatically terminate your rights under
  this License (including any patent licenses granted under the third
  paragraph of section 11).

    However, if you cease all violation of this License, then your
  license from a particular copyright holder is reinstated (a)
  provisionally, unless and until the copyright holder explicitly and
  finally terminates your license, and (b) permanently, if the copyright
  holder fails to notify you of the violation by some reasonable means
  prior to 60 days after the cessation.

    Moreover, your license from a particular copyright holder is
  reinstated permanently if the copyright holder notifies you of the
  violation by some reasonable means, this is the first time you have
  received notice of violation of this License (for any work) from that
  copyright holder, and you cure the violation prior to 30 days after
  your receipt of the notice.

    Termination of your rights under this section does not terminate the
  licenses of parties who have received copies or rights from you under
  this License.  If your rights have been terminated and not permanently
  reinstated, you do not qualify to receive new licenses for the same
  material under section 10.

    9. Acceptance Not Required for Having Copies.

    You are not required to accept this License in order to receive or
  run a copy of the Program.  Ancillary propagation of a covered work
  occurring solely as a consequence of using peer-to-peer transmission
  to receive a copy likewise does not require acceptance.  However,
  nothing other than this License grants you permission to propagate or
  modify any covered work.  These actions infringe copyright if you do
  not accept this License.  Therefore, by modifying or propagating a
  covered work, you indicate your acceptance of this License to do so.

    10. Automatic Licensing of Downstream Recipients.

    Each time you convey a covered work, the recipient automatically
  receives a license from the original licensors, to run, modify and
  propagate that work, subject to this License.  You are not responsible
  for enforcing compliance by third parties with this License.

    An "entity transaction" is a transaction transferring control of an
  organization, or substantially all assets of one, or subdividing an
  organization, or merging organizations.  If propagation of a covered
  work results from an entity transaction, each party to that
  transaction who receives a copy of the work also receives whatever
  licenses to the work the party's predecessor in interest had or could
  give under the previous paragraph, plus a right to possession of the
  Corresponding Source of the work from the predecessor in interest, if
  the predecessor has it or can get it with reasonable efforts.

    You may not impose any further restrictions on the exercise of the
  rights granted or affirmed under this License.  For example, you may
  not impose a license fee, royalty, or other charge for exercise of
  rights granted under this License, and you may not initiate litigation
  (including a cross-claim or counterclaim in a lawsuit) alleging that
  any patent claim is infringed by making, using, selling, offering for
  sale, or importing the Program or any portion of it.

    11. Patents.

    A "contributor" is a copyright holder who authorizes use under this
  License of the Program or a work on which the Program is based.  The
  work thus licensed is called the contributor's "contributor version".

    A contributor's "essential patent claims" are all patent claims
  owned or controlled by the contributor, whether already acquired or
  hereafter acquired, that would be infringed by some manner, permitted
  by this License, of making, using, or selling its contributor version,
  but do not include claims that would be infringed only as a
  consequence of further modification of the contributor version.  For
  purposes of this definition, "control" includes the right to grant
  patent sublicenses in a manner consistent with the requirements of
  this License.

    Each contributor grants you a non-exclusive, worldwide, royalty-free
  patent license under the contributor's essential patent claims, to
  make, use, sell, offer for sale, import and otherwise run, modify and
  propagate the contents of its contributor version.

    In the following three paragraphs, a "patent license" is any express
  agreement or commitment, however denominated, not to enforce a patent
  (such as an express permission to practice a patent or covenant not to
  sue for patent infringement).  To "grant" such a patent license to a
  party means to make such an agreement or commitment not to enforce a
  patent against the party.

    If you convey a covered work, knowingly relying on a patent license,
  and the Corresponding Source of the work is not available for anyone
  to copy, free of charge and under the terms of this License, through a
  publicly available network server or other readily accessible means,
  then you must either (1) cause the Corresponding Source to be so
  available, or (2) arrange to deprive yourself of the benefit of the
  patent license for this particular work, or (3) arrange, in a manner
  consistent with the requirements of this License, to extend the patent
  license to downstream recipients.  "Knowingly relying" means you have
  actual knowledge that, but for the patent license, your conveying the
  covered work in a country, or your recipient's use of the covered work
  in a country, would infringe one or more identifiable patents in that
  country that you have reason to believe are valid.

    If, pursuant to or in connection with a single transaction or
  arrangement, you convey, or propagate by procuring conveyance of, a
  covered work, and grant a patent license to some of the parties
  receiving the covered work authorizing them to use, propagate, modify
  or convey a specific copy of the covered work, then the patent license
  you grant is automatically extended to all recipients of the covered
  work and works based on it.

    A patent license is "discriminatory" if it does not include within
  the scope of its coverage, prohibits the exercise of, or is
  conditioned on the non-exercise of one or more of the rights that are
  specifically granted under this License.  You may not convey a covered
  work if you are a party to an arrangement with a third party that is
  in the business of distributing software, under which you make payment
  to the third party based on the extent of your activity of conveying
  the work, and under which the third party grants, to any of the
  parties who would receive the covered work from you, a discriminatory
  patent license (a) in connection with copies of the covered work
  conveyed by you (or copies made from those copies), or (b) primarily
  for and in connection with specific products or compilations that
  contain the covered work, unless you entered into that arrangement,
  or that patent license was granted, prior to 28 March 2007.

    Nothing in this License shall be construed as excluding or limiting
  any implied license or other defenses to infringement that may
  otherwise be available to you under applicable patent law.

    12. No Surrender of Others' Freedom.

    If conditions are imposed on you (whether by court order, agreement or
  otherwise) that contradict the conditions of this License, they do not
  excuse you from the conditions of this License.  If you cannot convey a
  covered work so as to satisfy simultaneously your obligations under this
  License and any other pertinent obligations, then as a consequence you may
  not convey it at all.  For example, if you agree to terms that obligate you
  to collect a royalty for further conveying from those to whom you convey
  the Program, the only way you could satisfy both those terms and this
  License would be to refrain entirely from conveying the Program.

    13. Use with the GNU Affero General Public License.

    Notwithstanding any other provision of this License, you have
  permission to link or combine any covered work with a work licensed
  under version 3 of the GNU Affero General Public License into a single
  combined work, and to convey the resulting work.  The terms of this
  License will continue to apply to the part which is the covered work,
  but the special requirements of the GNU Affero General Public License,
  section 13, concerning interaction through a network will apply to the
  combination as such.

    14. Revised Versions of this License.

    The Free Software Foundation may publish revised and/or new versions of
  the GNU General Public License from time to time.  Such new versions will
  be similar in spirit to the present version, but may differ in detail to
  address new problems or concerns.

    Each version is given a distinguishing version number.  If the
  Program specifies that a certain numbered version of the GNU General
  Public License "or any later version" applies to it, you have the
  option of following the terms and conditions either of that numbered
  version or of any later version published by the Free Software
  Foundation.  If the Program does not specify a version number of the
  GNU General Public License, you may choose any version ever published
  by the Free Software Foundation.

    If the Program specifies that a proxy can decide which future
  versions of the GNU General Public License can be used, that proxy's
  public statement of acceptance of a version permanently authorizes you
  to choose that version for the Program.

    Later license versions may give you additional or different
  permissions.  However, no additional obligations are imposed on any
  author or copyright holder as a result of your choosing to follow a
  later version.

    15. Disclaimer of Warranty.

    THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
  APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
  HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
  OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
  IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
  ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

    16. Limitation of Liability.

    IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
  WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
  THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
  GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
  USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
  DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
  PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
  EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
  SUCH DAMAGES.

    17. Interpretation of Sections 15 and 16.

    If the disclaimer of warranty and limitation of liability provided
  above cannot be given local legal effect according to their terms,
  reviewing courts shall apply local law that most closely approximates
  an absolute waiver of all civil liability in connection with the
  Program, unless a warranty or assumption of liability accompanies a
  copy of the Program in return for a fee.

                       END OF TERMS AND CONDITIONS

              How to Apply These Terms to Your New Programs

    If you develop a new program, and you want it to be of the greatest
  possible use to the public, the best way to achieve this is to make it
  free software which everyone can redistribute and change under these terms.

    To do so, attach the following notices to the program.  It is safest
  to attach them to the start of each source file to most effectively
  state the exclusion of warranty; and each file should have at least
  the "copyright" line and a pointer to where the full notice is found.

      <one line to give the program's name and a brief idea of what it does.>
      Copyright (C) <year>  <name of author>

      This program is free software: you can redistribute it and/or modify
      it under the terms of the GNU 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 General Public License for more details.

      You should have received a copy of the GNU General Public License
      along with this program.  If not, see <https://www.gnu.org/licenses/>.

  Also add information on how to contact you by electronic and paper mail.

    If the program does terminal interaction, make it output a short
  notice like this when it starts in an interactive mode:

      <program>  Copyright (C) <year>  <name of author>
      This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
      This is free software, and you are welcome to redistribute it
      under certain conditions; type `show c' for details.

  The hypothetical commands `show w' and `show c' should show the appropriate
  parts of the General Public License.  Of course, your program's commands
  might be different; for a GUI interface, you would use an "about box".

    You should also get your employer (if you work as a programmer) or school,
  if any, to sign a "copyright disclaimer" for the program, if necessary.
  For more information on this, and how to apply and follow the GNU GPL, see
  <https://www.gnu.org/licenses/>.

    The GNU General Public License does not permit incorporating your program
  into proprietary programs.  If your program is a subroutine library, you
  may consider it more useful to permit linking proprietary applications with
  the library.  If this is what you want to do, use the GNU Lesser General
  Public License instead of this License.  But first, please read
  <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: c2792a3094fa6ba48af37206534496de56e79c9a02161794d4bac9db3b2ce305
name: python-8a-scraper
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A Python client for scraping data from 8a.nu
url: https://github.com/vishaalagartha/8a_scraper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-8a-scraper-0.0.4-1.src.rpm
checksum_type: sha256
description:
  [8a](https://www.8a.nu/) is a great resource to aggregate statistics on sportclimbers and boulderers. They recently deployed a new version of their website that rendered all the prior scrapers obsolete.

  This tool allows 8a users to scrape content from the website using their username, password, Selenium, and BeautifulSoup.





  Install using the following command:

  `pip install 8a-scraper`

  The latest version is `0.0.3`. If you have already installed the package, please update it using the following command:

  `pip install 8a-scraper --upgrade`



  Alternatively, you can just clone this repo and import the libraries at your own discretion.



  To install the package,

  This package requires the user to also install Google Chrome and [ChromeDriver](https://chromedriver.chromium.org/downloads).
  Please ensure that the version of ChromeDriver install matches your current version of Google Chrome. You can check your current version of Google Chrome by opening Chrome and checking the 'About Google Chrome' panel. Ensure that the chromedriver executable is in your `$PATH` variable as well.

  The user must also have an email and password that can be used to log into [8a](https://www.8a.nu/)

  Additionally, the user must set the following environment variables with their current login info:

  ```python
  _8A_USERNAME='<8a email>'
  _8A_PASSWORD='<8a password>'
  ```

  These variables are accessed using `os.getenv()`. These can be set in the `.bash_profile` file on MacOS or by 'Editing the system environmental variables' on Windows.



  Currently, the package only contains 2 modules: users and ascents.
  The package will be expanding to include other content as well, but this is a start.

  For more information, about the API please refer to the full [documentation](https://github.com/vishaalagartha/8a_scraper/blob/master/API.md)


pkgId: 4139d9b04a5d0ee1c93dba0f95b5ebf8f9a8c65432bb2a7ec507da25d510f43f
name: python-A-GIS
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Functional python that shields users from breaking changes.
url: https://pypi.org/project/A-GIS/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-A-GIS-0.8.1-1.src.rpm
checksum_type: sha256
description:
  ```python
  pip install A_GIS
  ```

  Pronounced with a long "a" like AEGIS, this is a package for functional python.



  Checkout out notebooks/roundtrip.ipynb for an example of round-tripping.

  In the `__A_GIS__` directory we can have the segmented data
  so that AI can operate on different parts more efficiently.

  The basic sequence is

  1. raw function only (8 lines or less ideally)
  2. add comments and spacing
  3. add docstring
  4. send through formatter
  5. this is now a complete function like someone would want to see in a code base

  To split it up again we go in reverse.

  6. remove docstring
  7. remove comments and spacing (save in file)
  8. save raw function

  Now you can see easily if the raw function changed. Once this iteration
  converges, the diff should be zero.

  This process has advantages in that we can isolate the docstring and
  work on making that beautiful.

  It could get examples, and all kinds of crazy awesome reformatting
  as its own document. Then we can reapply comments to the raw source,
  THEN the docstring, then format. We could send this to an AI now to
  create better comments and then ONLY update the comments file. I think
  the comments are somewhat dependent on the
  docstring so it's nice to have this flow of regenerating comments
  assuming a certain docstring and visibility of the whole file.

  After splitting back out and saving the raw function, you can see (with
  git diff for example), if the AI changed the execution of the code. One
  could imagine asking the AI to split a function into several that don't
  exceed e.g. 9 lines for example.

  This scheme gives us a way to then split those functions and send them
  to their place on the file system.

  By going to such small granularity, we should be able to fit in many AIs
  token counts and they should be able to design tests and examples much
  easier.

  We could also, based on similarity metrics for the raw functions, make
  sure AI aren't creating a bunch of extra functions. I.e. if they create
  a new one that has high similarity to an existing one, we could ask it
  to use the existing one instead, or propose modifications to the existing
  one, e.g. optional arguments, that would make it work.

  It would be interesting to see what an AI would generate in terms of a
  code base with this approach. It should arrive at lots of small
  functions that are basically idioms, like A_GIS.File.read().

  You should be able to apply this approach hierarchically to handle tests
  for example, each test a function. This should be a totally functional
  based system. Inside the functions we may want helper classes,
  especially for testing. We should start
  these names with an `_` to make sure they do not appear in the public
  API.

  Finally, it should be possible to hash the raw function content like
  IPFS and provide these in a distributed computing framework, where you
  basically call a function by the hash, `output = A_GIS.<hash>(input)`
  which ensures you get a specific version of that function even across
  different versions of `A_GIS`. All `A_GIS` functions should require
  keywords which may help with handling serialized data in dictionaries
  and such.




  ```
  tree -I *.pyc -I __A_GIS__ -I __init__.py -I __pycache__ -I tests A_GIS/
  ```

rpm_license:
  This is free and unencumbered software released into the public domain.  Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.  In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.  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 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.  For more information, please refer to <https://unlicense.org>


pkgId: 6ca584815fad370ee7a3cb7baffc81538f1882741512ac2e7604de4fc9aed820
name: python-A-library
arch: src
version: 3.4
epoch: 0
release: 1
url: https://github.com/R-Wolf/CFD_A_library
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-A-library-3.4-1.src.rpm
checksum_type: sha256
summary:
  Automated Library is a software to ease the entire library-book issuing process contributing to overall standards of the library and ensuring transparent and smooth conduction of the library processes


pkgId: f30be932e210fa6604d66d459c87d250d8e73d61fcf4bf45d47da57dc872db8f
name: python-A2KA
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Attention to Key Area, a plug and play interpretable network.
url: https://github.com/Dsadd4/NLSExplorer_1.0/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-A2KA-0.1.7-1.src.rpm
checksum_type: sha256
description:
  A2KA is a novel web architecture designed to
  identify crucial areas by extracting biological information from the embedding space of large language models.
  Make sure pytorch is installed firstly.
  The github storage is: https://github.com/Dsadd4/NLSExplorer_1.0


  You can install A2KA via pip:

  ```bash
  pip install A2KA
  ```

  A2KA
  ```python
  from A2KA import A2KA
  import torch
  hidden_dimention = 512

  config = [8,8,32]


  model =A2KA( hidden_dimention,config)

  exampletensor = torch.randn(5,100,512)
  prediction,layerattention = model(exampletensor)
  print(prediction)
  print(layerattention)
  ```

  SCNLS (in linux system)
  ```python
  from A2KA import SCNLS

  sequence_for_analysis = ['MSSAKRRKK','LSSSSKVR','MTNLP']
  kth_set = 3
  max_gap = 3
  processorsnumber = 2
  result = SCNLS(sequence_for_analysis,kth_set,max_gap,processorsnumber)
  print(result)
  ```


pkgId: 3e7c7ac1acfa918d5790e3a11626eb2543f8fc3c94c8b490ed92d98876b77029
name: python-AA-module
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Module for performing various archetypal analyses.
url: https://github.com/anden1305/AAM-Module
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AA-module-1.2.0-1.src.rpm
checksum_type: sha256
description:
  This module can be used to perform, evaluate and analyse Conventional Archetypal Analysis, Ordinal Archetypal Analysis and Response Bias Ordinal Archetypal Analysis. The module is developed by Andreas Bigom, Michael Harborg, Marcus Presutti and Oliver Elmgren in a collaboration between the Technical University of Denmark and Copenhagen Business School in order to enable students to analyse human questionnaire data in an effective and meaningful way.


pkgId: 56201004453d8adc050e30b4a796c52b4a6ad26c657851f406c049205b25a80a
name: python-AAIT
arch: src
version: 0.0.4.19
epoch: 0
release: 1
url: https://pypi.org/project/AAIT/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AAIT-0.0.4.19-1.src.rpm
checksum_type: sha256
summary:
  Advanced Artificial Intelligence Tools is a package meant to develop and enable advanced AI functionalities in Orange


pkgId: 19c1fe80ded74334ba639cdc6c76d5efe09e725a364f96fdf38f802d4fee5ae2
name: python-ABR
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: Evoked potential analysis software
url: https://pypi.org/project/ABR/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ABR-0.0.12-1.src.rpm
checksum_type: sha256
description:
  This program facilitates the analysis of auditory evoked responses (tested with auditory brainstem responses and compound action potentials).  You can visualize the waveform series collected during a single experiment, and identify the threshold and extract the amplitude and latency of each of the individual peaks in the waveform.

  The program works with the fillowing file formats:
  * ABR data generated by the Eaton Peabody Laboratories Cochlear Function Test Suite (EPL CFTS).
  * ABR data generated by [psiexperiment](https://github.com/psiexperiment/psiexperiment).
  * ABR data generated by the Intelligent Hearing Systems (IHS) text export.

  Individal research groups have also adapted the program to work with their own file formats.



  The simplest way to get started is to download the [Anaconda Python Distribution](https://www.anaconda.com/distribution/). Once installed, you will have new programs available in your start menu. One of these is called `Anaconda Prompt`. Open the `Anaconda Prompt` and you will get a command window. Type the following sequence of commands:

      conda create -n abr python=3.10
      conda activate abr
      pip install abr



  Open the `Anaconda Prompt` and type:

      conda activate abr
      abr



      conda activate abr
      pip install --upgrade abr



  There are two main interfaces to the ABR analysis program. The first is the basic interface where you manually drag files from your file browser and drop them on the window. You can drag one file or multiple files. Each file will be opened in a separate tab. The second interface is an automatic one that will loop through all unprocessed ABR files found in a folder and present each file to you individually for analysis. Once you save the analysis, it will immediately move to the next file.

  Both interfaces are accessed via the launcher. When you first open the launcher, you will specify:

  * Your name (i.e., the "analyzer")
  * The file format.  For many of you, you will pick the EPL CFTS unless you are using my software, [psiexperiment](https://github.com/bburan/psiexperiment) for data acquisition.
  * Which waves you want to analyze. If none are checked, we will assume that you only wish to mark threshold.
  * Filter settings to use. The original version of this program (distributed via the EPL website), filters waveforms using a 300 to 3000 Hz bandpass butterworth filter.



  Each waveform is bandpass filtered using a butterworth filter (filter order and highpass and lowpass cutoffs are specified via command-line options). This filtering process removes the baseline shift as well as high-frequency noise that may interfere with the peak-finding algorithm.  To prevent the waveform from being filtered, use the --nofilter option; however, be aware that this may degrade the efficacy of the automated peak.  Important note: since the algorithm uses a forward and reverse filter (to minimize phase shift), the actual order is double the requested order.

  An initial estimate of P1-5 is computed and presented for correction.  You may navigate through the waveform stack via the up/down arrows and select a point via the corresponding number (1-5).  Once a point is selected (it will turn to a white square), you can move it along the waveform using the right/left arrow keys.  Since the algorithm relies on the location of P1-5 to compute the best possible estimate of N1-5, you should correct the location of P1-5 before asking the algorithm to estimate N1-5.  You may also specify threshold by navigating to the appropriate waveform (via the up/down arrows) and hitting the "t" key.



  The amplitude and latency of each point are saved along with the threshold of the series. If the point is part of a subthreshold waveform, the additive inverse of the latency is saved (i.e. when parsing the file, subthreshold data can be recognized by negative latencies).  Amplitudes from subthreshold points can be used to estimate the noise floor if desired.



  The current waveform is displayed as a thick, black line.  Once a threshold is specified, subthreshold waveforms are indicated by a dashed line.  The selected point is indicated by a white square.  Negativities are indicated by triangles, positivities as squares.  Red is P1/N1, yellow is P2/N2, green is P3/N3, light blue is P4/N4, and dark blue is P5/N5.

  Instructions for using the program are included in the user interface.



  Code relating to marking points unscoreable and/or shifting waveforms up/down to ensure they don't run off the plot are adapted from work performed for the United States government and, therefore, are in the public domain. All other part of the code remain licensed under the BSD 3-clause.

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


pkgId: 1ca3b131f0d29d7f3c91acd4c02a3075cbbd1b711f749beeafe6a44cb26493e5
name: python-ABSQL
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: A rendering engine for templated SQL
url: https://github.com/pipeline-tools/ABSQL
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ABSQL-0.6.2-1.src.rpm
checksum_type: sha256
description:
  ABSQL is a format for templated SQL, and the ABSQL package is a rendering engine for this format.
  ABSQL allows users to inject limitless context - text, objects, and functions - into their SQL templates, both within the rendering engine (the _Runner_) and in the SQL file itself.
  The flexibility and extendibility of ABSQL affords SQL engineers a consistent interface for generating templated SQL, while simultaneously giving downstream orchestration solutions (e.g. Airflow) the opportunity to develop orchestrator-specific implementations for ABSQL.
  ABSQL leverages the familiar Jinja2 templating engine, as well as YAML-style frontmatter to provide users with a unique and intuitive SQL authoring experience.


  The ABSQL Runner is robust, but we will start simple. The static `render_text` method will render user-provided text with any provided context.
  ```python
  from absql import Runner
  Runner.render_text('{{greeting}}, World!', greeting="Hello")

  ```

  We might want to reuse the context we provide. In this case, we can instantiate a runner and provide it with context. We can then render any text with this saved context. An instantiated runner has a `render` method, that works with text and - as we will see later - file paths, as well.
  ```python
  from absql import Runner
  r = Runner(greeting = "Hello")
  r.render("{{greeting}}, World!")

  ```

  The runner is not bound to plain text, and the context provided by the user is not confined to just the runner. Context can also be passed in through a frontmatter block at the top of a `.sql` file. This frontmatter block is parsed as YAML.
  In the example file below, `my_file.sql`, the `table_name` context is provided in the frontmatter block. This block can either start and end with three hyphens (`---`) or be a block comment at the beginning of the SQL file (`/* ... */`). The body of the file contains the templated SQL we want to render.
  Using a frontmatter block contained within `---`:


pkgId: f6632965147503c996c74c616410167e3f066d7d0b893d444af6005a5d79ac2e
name: python-ABSmartly
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: ABSmartly Python SDK lib
url: https://github.com/absmartly/python3-sdk
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ABSmartly-0.2.4-1.src.rpm
checksum_type: sha256
description:
  A/B Smartly - Python SDK



  The A/B Smartly Python SDK is compatible with Python 3.
  It provides both a blocking and an asynchronous interfaces.




   ```bash
   pip install absmartly==0.2.3
   ```


  ```
  setuptools~=60.2.0
  requests~=2.28.1
  urllib3~=1.26.12
  jsons~=1.6.3
  ```





  Once the SDK is installed, it can be initialized in your project.
  ```python
      def main():
          client_config = ClientConfig()
          client_config.endpoint = "https://sandbox.test.io/v1"
          client_config.api_key = "test"
          client_config.application = "www"
          client_config.environment = "prod"

          default_client_config = DefaultHTTPClientConfig()
          default_client = DefaultHTTPClient(default_client_config)
          sdk_config = ABSmartlyConfig()
          sdk_config.client = Client(client_config, default_client)
          sdk = ABSmartly(sdk_config)

          context_config = ContextConfig()
          ctx = sdk.create_context(context_config)
  ```

  **SDK Options**

  | Config      | Type                                          | Required? |                 Default                 | Description                                                                                                                                                                   |
  | :---------- |:----------------------------------------------| :-------: |:---------------------------------------:|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | endpoint    | `string`                                      |  &#9989;  |               `undefined`               | The URL to your API endpoint. Most commonly `"your-company.absmartly.io"`                                                                                                     |
  | apiKey      | `string`                                      |  &#9989;  |               `undefined`               | Your API key which can be found on the Web Console.                                                                                                                           |
  | environment | `"production"` or `"development"`             |  &#9989;  |               `undefined`               | The environment of the platform where the SDK is installed. Environments are created on the Web Console and should match the available environments in your infrastructure.   |
  | application | `string`                                      |  &#9989;  |               `undefined`               | The name of the application where the SDK is installed. Applications are created on the Web Console and should match the applications where your experiments will be running. |
  | max_retries     | `number`                                      | &#10060;  |                   `5`                   | The number of retries before the SDK stops trying to connect.                                                                                                                 |
  | connection_timeout     | `number`                                      | &#10060;  |                   `3`                   | An amount of time, in seconds, before the SDK will stop trying to connect.                                                                                                    |
  | context_event_logger | `(self, event_type: EventType, data: object)` | &#10060;  | See "Using a Custom Event Logger" below | A callback function which runs after SDK events.


  The A/B Smartly SDK can be instantiated with an event logger used for all contexts.
  In addition, an event logger can be specified when creating a particular context, in the `ContextConfig`.
  ```python
      class EventType(Enum):
          ERROR = "error"
          READY = "ready"
          REFRESH = "refresh"
          PUBLISH = "publish"
          EXPOSURE = "exposure"
          GOAL = "goal"
          CLOSE = "close"


      class ContextEventLogger:

          @abstractmethod
          def handle_event(self, event_type: EventType, data: object):
              raise NotImplementedError
  ```
  The data parameter depends on the type of event.
  Currently, the SDK logs the following events:

  | event | when                                                       | data |
  |:---: |------------------------------------------------------------|---|
  | `Error` | `Context` receives an error                                | `Throwable` object |
  | `Ready` | `Context` turns ready                                      | `ContextData` used to initialize the context |
  | `Refresh` | `Context.refresh()` method succeeds                        | `ContextData` used to refresh the context |
  | `Publish` | `Context.publish()` method succeeds                        | `PublishEvent` sent to the A/B Smartly event collector |
  | `Exposure` | `Context.getTreatment()` method succeeds on first exposure | `Exposure` enqueued for publishing |
  | `Goal` | `Context.track()` method succeeds                          | `GoalAchievement` enqueued for publishing |
  | `Close` | `Context.close()` method succeeds the first time           | `null` |




  **Synchronously**
  ```python

      context_config = ContextConfig()
      context_config.publish_delay = 10
      context_config.refresh_interval = 5

      context_config = ContextConfig()
      ctx = sdk.create_context(context_config)
      ctx.wait_until_ready()
  ```

  **Asynchronously**
  ```python

      context_config = ContextConfig()
      context_config.publish_delay = 10
      context_config.refresh_interval = 5

      context_config = ContextConfig()
      ctx = sdk.create_context(context_config)
      ctx.wait_until_ready_async()
  ```

  **With Prefetched Data**
  ```python

      context_config = ContextConfig()
      context_config.publish_delay = 10
      context_config.refresh_interval = 5
      context_config.units = {"session_id": "bf06d8cb5d8137290c4abb64155584fbdb64d8",
                              "user_id": "12345"}

      context_config = ContextConfig()
      ctx = sdk.create_context(context_config)
      ctx.wait_until_ready_async()
  ```

  **Refreshing the Context with Fresh Experiment Data**
  For long-running contexts, the context is usually created once when the application is first started.
  However, any experiments being tracked in your production code, but started after the context was created, will not be triggered.
  To mitigate this, we can use the `set_refresh_interval()` method on the context config.

  ```python
      default_client_config = DefaultHTTPClientConfig()
      default_client_config.refresh_interval = 5
  ```

  Alternatively, the `refresh()` method can be called manually.
  The `refresh()` method pulls updated experiment data from the A/B Smartly collector and will trigger recently started experiments when `get_treatment()` is called again.
  ```python
      context.refresh()
  ```

  **Setting Extra Units**
  You can add additional units to a context by calling the `set_unit()` or the `set_units()` method.
  This method may be used for example, when a user logs in to your application, and you want to use the new unit type to the context.
  Please note that **you cannot override an already set unit type** as that would be a change of identity, and will throw an exception. In this case, you must create a new context instead.
  The `SetUnit()` and `SetUnits()` methods can be called before the context is ready.

  ```python
      context.set_unit("db_user_id", "1000013")

      context.set_units({
              "db_user_id": "1000013"
      })
  ```




  ```python
      res, _ = context.get_treatment("exp_test_experiment")
      if res == 0:
              
      else:
             
  ```



  ```python
       res = context.get_variable_value(key, 17)
  ```



  Although generally not recommended, it is sometimes necessary to peek at a treatment or variable without triggering an exposure.
  The A/B Smartly SDK provides a `peek_treament()` method for that.

  ```python
      res = context.peek_treament("exp_test_experiment")
      if res == 0:
          
      else:
          

  ```

  ```python
      variable = context.peek_variable("my_variable")
  ```


  During development, for example, it is useful to force a treatment for an experiment. This can be achieved with the `override()` and/or `overrides()` methods.
  The `set_override()` and `set_overrides()` methods can be called before the context is ready.
  ```python
      context.set_override("exp_test_experiment", 1) # force variant 1 of treatment
      context.set_overrides({
          "exp_test_experiment": 1,
          "exp_another_experiment": 0
      })
  ```




  Attributes are used to pass meta-data about the user and/or the request.
  They can be used later in the Web Console to create segments or audiences.
  The `set_attributes()` and `set_attributes()` methods can be called before the context is ready.
  ```python
      context.set_attributes("user_agent", req.get_header("User-Agent"))

      context.set_attributes({
              "customer_age": "new_customer"
      })
  ```



  Sometimes it may be necessary to override the automatic selection of a
  variant. For example, if you wish to have your variant chosen based on
  data from an API call. This can be accomplished using the
  `set_custom_assignment()` method.

  ```python
      context.set_custom_assignment("exp_test_not_eligible", 3)
  ```

  If you are running multiple experiments and need to choose different
  custom assignments for each one, you can do so using the
  `set_custom_assignments()` method.

  ```python
      context.set_custom_assignments({"db_user_id2": 1})
  ```


  Sometimes it is necessary to ensure all events have been published to the A/B Smartly collector, before proceeding.
  You can explicitly call the `publish()` or `publish_async()` methods.
  ```python
      context.publish()
  ```


  The `close()` and `close_async()` methods will ensure all events have been published to the A/B Smartly collector, like `publish()`, and will also "seal" the context, throwing an error if any method that could generate an event is called.
  ```python
      context.close()
  ```


  Goals are created in the A/B Smartly web console.
  ```python
      context.track("payment", {
              "item_count": 1,
              "total_amount": 1999.99
      })
  ```


  **A/B Smartly** is the leading provider of state-of-the-art, on-premises, full-stack experimentation platforms for engineering and product teams that want to confidently deploy features as fast as they can develop them.
  A/B Smartly's real-time analytics helps engineering and product teams ensure that new features will improve the customer experience without breaking or degrading performance and/or business metrics.


  - [Java SDK](https://www.github.com/absmartly/java-sdk)
  - [JavaScript SDK](https://www.github.com/absmartly/javascript-sdk)
  - [PHP SDK](https://www.github.com/absmartly/php-sdk)
  - [Swift SDK](https://www.github.com/absmartly/swift-sdk)
  - [Vue2 SDK](https://www.github.com/absmartly/vue2-sdk)
  - [Go SDK](https://www.github.com/absmartly/go-sdk)
  - [Ruby SDK](https://www.github.com/absmartly/ruby-sdk)

rpm_license:
  The MIT License (MIT) Copyright © 2022 <copyright holders>  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: e70c4fe0e7c4d14787f9eb696fd0c18964057f566f53836f37b4712ff662e583
name: python-ABlooper
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Set of functions to predict CDR structure
url: https://pypi.org/project/ABlooper/
rpm_license: BSD 3-clause license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ABlooper-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Antibodies are a key component of the immune system and have been extensively used as biotherapeutics. Accurate knowledge of their structure is central to understanding their antigen binding function. The key area for antigen binding and the main area of structural variation in antibodies is concentrated in the six complementarity determining regions (CDRs), with the most important for binding and most variable being the CDR-H3 loop. The sequence and structural variability of CDR-H3 make it particularly challenging to model. Recently deep learning methods have offered a step change in our ability to predict protein structures. In this work we present ABlooper, an end-to-end equivariant deep-learning based CDR loop structure prediction tool. ABlooper rapidly predicts the structure of CDR loops with high accuracy and provides a confidence estimate for each of its predictions. On the models of the Rosetta Antibody Benchmark, ABlooper makes predictions with an average CDR-H3 RMSD of 2.49Å, which drops to 2.05Å when considering only its 76% most confident predictions.



  To install via PyPi:

  ```bash
  $ pip install ABlooper
  ```

  To download and install the latest version from github:

  ```bash
  $ git clone https://github.com/brennanaba/ABlooper.git
  $ pip install ABlooper/
  ```

  This package requires PyTorch. If you do not already have PyTorch installed, you can do so following these <a href="https://pytorch.org/get-started/locally/">instructions</a>.


  Either OpenMM or PyRosetta are required for the optional refinement and side-chain prediction steps.
  OpenMM and pdbfixer can be installed via conda using:

  ```bash
  $ conda install -c conda-forge openmm pdbfixer
  ```

  If you want to use PyRosetta for refinement and do not have it installed, it can be obtained from <a href="https://www.pyrosetta.org/">here</a>.



  To use ABlooper, you will need an IMGT numbered antibody model. If you do not already have an antibody model, you can generate one using <a href="http://opig.stats.ox.ac.uk/webapps/newsabdab/sabpred/abodybuilder/">ABodyBuilder</a>.

  To remodel the CDRs of an existing antibody model using the command line:

  ```bash
  $ ABlooper my_antibody_model.pdb --output ABlooper_model.pdb --heavy_chain H --light_chain L
  ```

  To remodel the CDRs of an existing model using the python API:

  ```python
  from ABlooper import CDR_Predictor

  input_path = "my_antibody_model.pdb"
  output_path = "ABlooper_model.pdb"

  pred = CDR_Predictor(input_path, chains = ("H", "L"))
  pred.write_predictions_in_pdb_format(output_path)
  ```

  Two pretrained models are available. The default predicts CDRs defined by the Chothia numbering scheme (This is the model described in the paper). To get predictions of CDRs defined by the IMGT numbering scheme use:

  ```python
  pred = CDR_Predictor(input_path, chains = ("H", "L"), model = 'imgt')
  pred.write_predictions_in_pdb_format(output_path)
  ```

  I would recommend using the command line if you just want a quick antibody model. If speed is a priority, it is probably best to just use the trained pytorch model. The python class will work best if you want to incorporate CDR prediction into a pipeline or access other details such as confidence score or RMSD to original model. Both of which can be obtained as follows:


  ```python
  rmsd_from_input = pred.calculate_BB_rmsd_wrt_input()
  confidence_score = pred.decoy_diversity
  ```

  I have been made aware that ABlooper will occasionally generate abnormal geometries. To fix this, and to generate side-chains you can do (Only works if you have PyRosetta or OpenMM installed):

  ```bash
  $ ABlooper my_antibody_model.pdb --output ABlooper_model.pdb --model chothia --side_chains
  ```

  As a default this will use OpenMM if it is installed.



  The code and data in this package is based on the following paper <a href="https://academic.oup.com/bioinformatics/article/38/7/1877/6517780">ABlooper</a>. If you use it, please cite:

  ```tex
  @article{10.1093/bioinformatics/btac016,
      author = {Abanades, Brennan and Georges, Guy and Bujotzek, Alexander and Deane, Charlotte M},
      title = {ABlooper: fast accurate antibody CDR loop structure prediction with accuracy estimation},
      journal = {Bioinformatics},
      volume = {38},
      number = {7},
      pages = {1877-1880},
      year = {2022},
      month = {01},
      issn = {1367-4803},
      doi = {10.1093/bioinformatics/btac016},
      url = {https://doi.org/10.1093/bioinformatics/btac016},
  ```


pkgId: 8acebbfebd1fdae85039a8bdd7aa24321bc812c12676625ee5da38a000671058
name: python-ACSConv
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: [IEEE JBHI] Reinventing 2D Convolutions for 3D Images
url: https://github.com/M3DV/ACSConv
rpm_license: Apache-2.0 License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ACSConv-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Reinventing 2D Convolutions for 3D Images ([arXiv](https://arxiv.org/abs/1911.10477))

  IEEE Journal of Biomedical and Health Informatics (IEEE JBHI), 2021 ([DOI](http://doi.org/10.1109/JBHI.2021.3049452))

  **News**:
  - 2022.01.26 - ACS [ConvNeXt](acsconv/models/convnext.py) supported.
  - 2021.12.17 - torch 1.10 supported & pip installation supported.
  - 2021.4.19 - torch 1.8 supported.



  * ACS convolution aims at a **plug-and-play replacement** of standard 3D convolution, for 3D medical images.
  * ACS convolution enables **2D-to-3D transfer learning**, which consistently provides significant performance boost in our experiments.
  * Even without pretraining, ACS convolution is **comparable to or even better than** 3D convolution, with **smaller model size** and **less computation**.




  If you want to use this class, you have two options:

  A) Install ACSConv as a standard Python package from PyPI:

  ```bash
  pip install ACSConv
  ```

  B) Simply copy and paste it in your project;


  You could run the `test.py` to validate the installation. (If you want to test the validity of pip installation, please move this `test.py` file outside of this git project directory, otherwise it is testing the code inside the project instead of pip installation.)




  ```python
  torch>=1.0.0 and torch<=1.10.0
  ```

  You can install it on the [official homepage](https://pytorch.org/docs/stable/index.html).



  All libraries needed to run the included experiments (base requirements included).

  ```python
  fire
  jupyterlab
  matplotlib
  pandas
  tqdm
  sklearn
  tensorboardx
  ```



  * ``acsconv``
    the core implementation of ACS convolution, including the operators, models, and 2D-to-3D/ACS model converters.
    * ``operators``: include ACSConv, SoftACSConv and Conv2_5d.
    * ``converters``: include converters which convert 2D models to 3d/ACS/Conv2_5d counterparts.
    * ``models``: Native ACS models.
  * ``experiments``
    the scripts to run experiments.
    * ``mylib``: the lib for running the experiments.
    * ``poc``: the scripts to run proof-of-concept experiments.
    * ``lidc``: the scripts to run LIDC-IDRI experiments.



  ```python
  import torch
  from torchvision.models import resnet18
  from acsconv.converters import ACSConverter

  model_2d = resnet18(pretrained=True)
  B, C_in, H, W = (1, 3, 64, 64)
  input_2d = torch.rand(B, C_in, H, W)
  output_2d = model_2d(input_2d)

  model_3d = ACSConverter(model_2d)

  B, C_in, D, H, W = (1, 3, 64, 64, 64)
  input_3d = torch.rand(B, C_in, D, H, W)
  output_3d = model_3d(input_3d)
  ```



  ```python
  import torch
  from acsconv.operators import ACSConv, SoftACSConv
  B, C_in, D, H, W = (1, 3, 64, 64, 64)
  x = torch.rand(B, C_in, D, H, W)

  conv = ACSConv(in_channels=3, out_channels=10, kernel_size=3, padding=1)
  out = conv(x)

  conv = SoftACSConv(in_channels=3, out_channels=10, kernel_size=3, padding=1)
  out = conv(x)
  ```



  ```python
  import torch
  from acsconv.models.acsunet import ACSUNet
  unet_3d = ACSUNet(num_classes=3)
  B, C_in, D, H, W = (1, 1, 64, 64, 64)
  input_3d = torch.rand(B, C_in, D, H, W)
  output_3d = unet_3d(input_3d)
  ```



  * [Proof-of-Concept Segmentation](./experiments/poc/README.md)
  * [Lung Nodule Classification and Segmentation](./experiments/lidc/README.md)
  * ...


pkgId: 660a59f8e7dc29ef041b02bc5f4f9f0de8f9c0d5431c322714bcf8d7e954fcb9
name: python-ACSpy
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Package for working with ACS motion controllers.
url: https://github.com/petebachant/ACSpy.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ACSpy-0.0.8-1.src.rpm
checksum_type: sha256
description:
  A Python package for working with [ACS motion controllers](https://www.acsmotioncontrol.com/). Note that this project is not
  affiliated with or endorsed by ACS Motion Control.


pkgId: 96373e6422142eec083f8acdf9b0817e53de727e044727a9fd4815469086fc68
name: python-AD-testing-packaging-CS207
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Automatic Differentiation Package
url: https://github.com/cs207-f18-WIRS/cs207-FinalProject
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AD-testing-packaging-CS207-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/cs207-f18-WIRS/cs207-FinalProject.svg?branch=master)](https://travis-ci.com/cs207-f18-WIRS/cs207-FinalProject)

  [![Coverage Status](https://coveralls.io/repos/github/cs207-f18-WIRS/cs207-FinalProject/badge.svg?branch=master)](https://coveralls.io/github/cs207-f18-WIRS/cs207-FinalProject?branch=master)


  This repository contains the Final Project Deliverable on Automatic Differentiation for the Harvard Course CS 207: Systems Development for Computational Science.


    - Specific information can be found at `docs/milestone1.md`.
    - [Course Project discription](https://iacs-cs-207.github.io/cs207-F18/project.html) : Overview of the instruction on the project on automatic differentiation (AD).


    - [Main course website](https://iacs-cs-207.github.io/cs207-F18/) : Check this site for all course-related policies including the syllabus, course schedule, and project policies.
    - [GitHub Repo](https://github.com/IACS-CS-207/cs207-F18) : All course materials will be released on GitHub.


    - FELDHAUS Isabelle
    - JIANG Shenghao
    - STRUYVEN Robbert
    - WANG William


pkgId: 34c6da23521046619a8275109d3ce33fef3d51d4d41535d10fe2bff829c32d01
name: python-ADAMModbusDriver
arch: src
version: 0.19.0
epoch: 0
release: 1
summary: A Python client for interfacing with Adam devices via ModbusTCP
url: https://github.com/spanio/ADAM-driver
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADAMModbusDriver-0.19.0-1.src.rpm
checksum_type: sha256
description:
  This is a reader for the ADAM-6018+ TC reader.

  To use, include the AdamClient.py file in your project.
  The output of this code is a list of thermocouples 1-8.


  ```python
  from AdamClient import AdamClient

  ADAM_IP = "172.18.120.250"
  client = AdamClient(ADAM_IP, thermocouple_type="K")

  try:
      converted_values = client.read_and_convert()
      print(converted_values)
  except Exception as e:
      print(f"Error: {e}")
  ```

  With one thermocouple attached to input 1, and the thermocouple installed in a coffee, the output will be:
  ```
  [48.37, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
  ```



  The ADAM devices only connect through Ethernet, _and don't respond to ping_. Yeah, have fun with that. They must be configured using the [Advantech ADAM/APAX Utility](https://www.advantech.com/en-us/support/details/utility?id=1-2AKUDB) using a Windows box.

  To use the Advantech ADAM Utility, plug the ADAM device into Ethernet. On the same network, run the ADAM Utility on a Windows machine. In the ADAM Utility, select Tools -> Search Device, and hopefully the ADAM device will show up in the left hand column. From there, change the IP / subnet / gateway to something that works. I would suggest using static IP. Have fun.


pkgId: 8a2ebe6adbd6e74b36fe23be465554b8d85d150ee8d58c1f9015cf152622c66a
name: python-ADCPy
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: read ADCP data from TRDI and Nortek instruments
url: https://github.com/mmartini-usgs/ADCPy
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADCPy-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/adcpy/badge/?version=latest)](https://adcpy.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://travis-ci.org/mmartini-usgs/ADCPy.svg?branch=master)](https://travis-ci.org/mmartini-usgs/ADCPy)

  This code prepares large amounts of single ping ADCP data from the raw binary for use with xarray by converting it to netCDF.


  The code was written for the TRDI ADCP when I discovered theat TRDI's Velocity software could not easily export single ping data.  While there are other packages out there, as the time of writing this code, I had yet to find one that saved the data in netCDF format (so it can be accessed with xarray and dask), could be run on linux, windows and mac, and did not load it into memory (the files I have are > 2GB)

  The code is written as a module of functions, rather than classes, ensemble information is stored as nested dicts, in order to be more readable and to make the structure of the raw data (particularly the TRDI instruments) understandable.


  As the code stands now, a 3.5 GB, single ping Workhorse ADCP .pd0 file with 3 Million ensembles will take 4-5 hours to convert.  I live with this, because I can just let the conversion happen overnight on such large data sets, and once my data is in netCDF, everything else is convenient and fast.  I suspect that more speed might be acheived by making use of xarray and dask to write the netCDF output, and I may do this if time allows, and I invite an enterprising soul to beat me to it.  I use this code myself on a routine basis in my work, and continue to make it better as I learn more about python.

  At USGS Coastal and Marine Geology we use the PMEL EPIC convention for netCDF as we started doing this back in the early 1990's.  Downstream we do convert to more current CF conventions, however our diagnostic and other legacy code for processing instrument data from binary and other raw formats depends on the EPIC convention for time, so you will see a time (Time (UTC) in True Julian Days: 2440000 = 0000 h on May 23, 1968) and time2 (msec since 0:00 GMT) variable created as default.  This may confuse your code.  If you want the more python friendly CF time (seconds since 1970-01-01T00:00:00 UTC) set timetype to CF.

  Use at  your own risk - this is a work in progress and a python learning project.

  Enjoy,

  Marinna


pkgId: 4ac4c1c56a45bbb78afe0fdc92ec96c0a59b03acb72f4d8b31dda2104021f60a
name: python-ADLStream
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: ADLStream is a novel asynchronous dual-pipeline deep learning framework for data stream mining
url: https://adlstream.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADLStream-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/ADLStream.svg)](https://pypi.org/project/ADLStream/)
  [![Documentation Status](https://readthedocs.org/projects/adlstream/badge/?version=latest)](https://adlstream.readthedocs.io/en/latest/?badge=latest)
  ![CI](https://github.com/pedrolarben/ADLStream/workflows/CI/badge.svg?branch=master)
  [![Downloads](https://pepy.tech/badge/adlstream)](https://pepy.tech/project/adlstream)
  [![Python 3.6](https://img.shields.io/badge/Python-3.6%20%7C%203.7%20%7C%203.8-blue)](https://www.python.org/downloads/release/python-360/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)




  ADLStream is a novel asynchronous  dual-pipeline deep  learning  framework  for  data  stream  mining.
  This system has two separated layers for training and testing that work simultaneously in order to provide quick predictions and perform frequent updates of the model.
  The dual-layer architecture  allows  to  alleviate  the  computational  cost problem  of  complex  deep  learning  models,  such  as convolutional neural networks, for the data streaming context,  in  which  speed  is  essential.

  <p align="center">
    <img width="100%"  src="https://raw.githubusercontent.com/pedrolarben/ADLStream/master/docs/img/ADLStream.png">
  </p>

  Complete documentation and API of ADLStream can be found in [adlstream.readthedocs.io](https://adlstream.readthedocs.io).


  - [ADLStream](#adlstream)
          - [Asynchronous dual-pipeline deep learning framework for online data stream mining.](#asynchronous-dual-pipeline-deep-learning-framework-for-online-data-stream-mining)
    - [Installation Guide](#installation-guide)
      - [GPU support](#gpu-support)
        - [Hardware requirements](#hardware-requirements)
        - [Software requirements](#software-requirements)
      - [Installing ADLStream](#installing-adlstream)
    - [Getting Started](#getting-started)
        - [1. Create the stream](#1-create-the-stream)
        - [2. Create the stream generator.](#2-create-the-stream-generator)
        - [3. Configure the evaluation process.](#3-configure-the-evaluation-process)
        - [4. Configure model and create ADLStream](#4-configure-model-and-create-adlstream)
        - [5. Run ADLStream & Results](#5-run-adlstream--results)
    - [Research papers related](#research-papers-related)
    - [Contributing](#contributing)
    - [License](#license)
    - [Authors](#authors)
      - [Contributors](#contributors)





  Ideally, ADLStream should be run in a two GPU computer.
  However, it is not compulsory and ADLStream can be also run in CPU.

  ADLStream uses [Tensorflow](https://www.tensorflow.org/).
  If you are interested in running ADLStream in GPU, the [tensorflow>=2.1.0](https://www.tensorflow.org/install/gpu
  ) GPU specifications are querired.

  If you don't want to use GPU go to [Installing ADLStream](#installing-adlstream).



    * Computer with at least 2 NVIDIA® GPU card with CUDA® Compute Capability 3.5 or higher



  The following NVIDIA® software must be installed on your system:

    * NVIDIA® GPU drivers —CUDA 10.0 requires 418.x or higher.
    * CUDA® Toolkit —TensorFlow supports CUDA 10.1 (TensorFlow >= 2.1.0)
    * CUPTI ships with the CUDA Toolkit.
    * cuDNN SDK (>= 7.6)
    * (Optional) TensorRT 6.0 to improve latency and throughput for inference on some models.



  You can install ADLStream and its dependencies from PyPI with:

  ```bash
  pip install ADLStream
  ```

  We strongly recommend that you install ADLStream in a dedicated virtualenv, to avoid conflicting with your system packages.

  To use ADLStream:

  ```python
  import ADLStream
  ```



  These instructions explain how to use ADLStream framework with a simple example.

  In this example we will use a LSTM model for time series forecasting in streaming.



  Fist of all we will need to create the stream.
  Stream objects can be created using the classes from `ADLStream.data.stream`. We can choose different options depending on the source of our stream (from a csv file, a Kafka cluster, etc).

  In this example, we will use the `FakeStream`, which implements a sine wave.

  ```python
  import ADLStream

  stream = ADLStream.data.stream.FakeStream(
      num_features=6, stream_length=1000, stream_period=100
  )
  ```

  More precisely, this stream will return a maximun of 1000 instances. The stream sends one message every 100 milliseconds (0.1 seconds).



  Once we have our source stream, we need to create our stream generator.
  A `StreamGenerator` is an object that will preprocess the `stream` and convert the messages into input (`x`) and target (`y`) data of the deep learning model.
  There are different options to choose under `ADLStream.data` and, if needed, we can create our custom `StreamGenerator` by inheriting `BaseStreamGenerator`.

  As our problem is time series forecasting, we will use the `MovingWindowStreamGenerator`, which performs the moving-window preprocessing method.

  ```python
  stream_generator = ADLStream.data.MovingWindowStreamGenerator(
      stream=stream, past_history=12, forecasting_horizon=3, shift=1
  )
  ```

  For the example we have set the past history to 12 and the model will predict the next 3 elements.



  In order to evaluate the performance of the model, we need to create a validator object.
  There exist different alternative for data-stream validation, some of the most common one can be found under `ADLStream.evaluation`.
  Furthermore, custom evaluators can be easily implemented by inheriting `BaseEvaluator`.

  In this case, we are going to create a `PrequentialEvaluator` which implements the idea that more recent examples are more important using a decaying factor.

  ```python
  evaluator = ADLStream.evaluation.PrequentialEvaluator(
      chunk_size=10,
      metric="MAE",
      fadding_factor=0.98,
      results_file="ADLStream.csv",
      dataset_name="Fake Data",
      show_plot=True,
      plot_file="test.jpg",
  )
  ```

  As can be seen, we are using the mean absolute error (MAE) metrics. Other options can be found in `ADLStream.evaluation.metrics`.
  The evaluator will save the progress of the error metric in `results_file` and will also plot the progress and saved the image in `plot_file`.



  Finally we will create our `ADLStream` object specifying the model to use.

  The required model arguments are the architecture, the loss and the optimizer. In addition, we can provides a dict with the model parameters to customize its architecture.
  All the available model architecture and its parameters can be found in `ADLStream.models`.

  For the example we are using a deep learning model with 3 stacked LSTM layers of 16, 32 and 64 units followed by a fully connected block of two layers with 16 and 8 neurons.

  ```python
  model_architecture = "lstm"
  model_loss = "mae"
  model_optimizer = "adam"
  model_parameters = {
      "recurrent_units": [16, 32, 64],
      "recurrent_dropout": 0,
      "return_sequences": False,
      "dense_layers": [16, 8],
      "dense_dropout": 0,
  }

  adls = ADLStream.ADLStream(
      stream_generator=stream_generator,
      evaluator=evaluator,
      batch_size=60,
      num_batches_fed=20,
      model_architecture=model_architecture,
      model_loss=model_loss,
      model_optimizer=model_optimizer,
      model_parameters=model_parameters,
      log_file="ADLStream.log",
  )
  ```



  Once we came the ADLStream object created, we can initiate it by calling its `run` function.

  ```python
  adls.run()
  ```

  The processes will start and the progress will be plot obtaining a result similar to this one

  ![output-plot](https://raw.githubusercontent.com/pedrolarben/ADLStream/master/docs/img/fakedata-example.gif)

  Complete API reference can be found [here](https://adlstream.readthedocs.io).



  Here it is the original paper that you can cite to reference ADLStream

  * [Lara-Benítez, Pedro, Manuel Carranza-garcía, et al. ‘Asynchronous Dual-pipeline Deep Learning Framework for Online Data Stream Classification’. Integrated Computer-Aided Engineering. 1 Jan. 2020 : 101 – 119.](https://doi.org/10.3233/ICA-200617)

  Any other study using ADLStream framework will be listed here.

  * [Lara-Benítez, Pedro, et al. "On the performance of deep learning models for time series classification in streaming." International Workshop on Soft Computing Models in Industrial and Environmental Applications. Springer, Cham, 2020.](http://arxiv.org/abs/2003.02544v2.pdf)



  Read [CONTRIBUTING.md](CONTRIBUTING.md). We appreciate all kinds of help.



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



  * **Pedro Lara-Benítez** - [LinkedIn](www.linkedin.com/in/pedrolarben)
  * **Manuel Carranza-García** - [LinkedIn](https://www.linkedin.com/in/manuelcarranzagarcia96/)
  * **Jorge García-Gutiérrez**
  * **José C. Riquelme**


  * [@pedrolarben](https://github.com/pedrolarben)
  * [@carranza96](https://github.com/carranza96)
  * [@preinaj](https://github.com/preinaj)


pkgId: 89f02787bb1a59b17f0d44ffa3611390d555be603c4cecded78a3abf308f0b1d
name: python-ADLStream2
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: ADLStream2 is a novel asynchronous dual-pipeline deep learning framework for data stream mining
url: https://adlstream.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADLStream2-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/ADLStream.svg)](https://pypi.org/project/ADLStream/)
  [![Documentation Status](https://readthedocs.org/projects/adlstream/badge/?version=latest)](https://adlstream.readthedocs.io/en/latest/?badge=latest)
  ![CI](https://github.com/pedrolarben/ADLStream/workflows/CI/badge.svg?branch=master)
  [![Downloads](https://pepy.tech/badge/adlstream)](https://pepy.tech/project/adlstream)
  [![Python 3.6](https://img.shields.io/badge/Python-3.6%20%7C%203.7%20%7C%203.8-blue)](https://www.python.org/downloads/release/python-360/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)




  ADLStream is a novel asynchronous  dual-pipeline deep  learning  framework  for  data  stream  mining.
  This system has two separated layers for training and testing that work simultaneously in order to provide quick predictions and perform frequent updates of the model.
  The dual-layer architecture  allows  to  alleviate  the  computational  cost problem  of  complex  deep  learning  models,  such  as convolutional neural networks, for the data streaming context,  in  which  speed  is  essential.

  <p align="center">
    <img width="100%"  src="https://raw.githubusercontent.com/pedrolarben/ADLStream/master/docs/img/ADLStream.png">
  </p>

  Complete documentation and API of ADLStream can be found in [adlstream.readthedocs.io](https://adlstream.readthedocs.io).


  - [ADLStream](#adlstream)
          - [Asynchronous dual-pipeline deep learning framework for online data stream mining.](#asynchronous-dual-pipeline-deep-learning-framework-for-online-data-stream-mining)
    - [Installation Guide](#installation-guide)
      - [GPU support](#gpu-support)
        - [Hardware requirements](#hardware-requirements)
        - [Software requirements](#software-requirements)
      - [Installing ADLStream](#installing-adlstream)
    - [Getting Started](#getting-started)
        - [1. Create the stream](#1-create-the-stream)
        - [2. Create the stream generator.](#2-create-the-stream-generator)
        - [3. Configure the evaluation process.](#3-configure-the-evaluation-process)
        - [4. Configure model and create ADLStream](#4-configure-model-and-create-adlstream)
        - [5. Run ADLStream & Results](#5-run-adlstream--results)
    - [Research papers related](#research-papers-related)
    - [Contributing](#contributing)
    - [License](#license)
    - [Authors](#authors)
      - [Contributors](#contributors)





  Ideally, ADLStream should be run in a two GPU computer.
  However, it is not compulsory and ADLStream can be also run in CPU.

  ADLStream uses [Tensorflow](https://www.tensorflow.org/).
  If you are interested in running ADLStream in GPU, the [tensorflow>=2.1.0](https://www.tensorflow.org/install/gpu
  ) GPU specifications are querired.

  If you don't want to use GPU go to [Installing ADLStream](#installing-adlstream).



    * Computer with at least 2 NVIDIA® GPU card with CUDA® Compute Capability 3.5 or higher



  The following NVIDIA® software must be installed on your system:

    * NVIDIA® GPU drivers —CUDA 10.0 requires 418.x or higher.
    * CUDA® Toolkit —TensorFlow supports CUDA 10.1 (TensorFlow >= 2.1.0)
    * CUPTI ships with the CUDA Toolkit.
    * cuDNN SDK (>= 7.6)
    * (Optional) TensorRT 6.0 to improve latency and throughput for inference on some models.



  You can install ADLStream and its dependencies from PyPI with:

  ```bash
  pip install ADLStream2
  ```

  We strongly recommend that you install ADLStream in a dedicated virtualenv, to avoid conflicting with your system packages.

  To use ADLStream:

  ```python
  import ADLStream2
  ```



  These instructions explain how to use ADLStream framework with a simple example.

  In this example we will use a LSTM model for time series forecasting in streaming.



  Fist of all we will need to create the stream.
  Stream objects can be created using the classes from `ADLStream.data.stream`. We can choose different options depending on the source of our stream (from a csv file, a Kafka cluster, etc).

  In this example, we will use the `FakeStream`, which implements a sine wave.

  ```python
  import ADLStream2

  stream = ADLStream2.data.stream.FakeStream(
    num_features=6, stream_length=1000, stream_period=100
  )
  ```

  More precisely, this stream will return a maximun of 1000 instances. The stream sends one message every 100 milliseconds (0.1 seconds).



  Once we have our source stream, we need to create our stream generator.
  A `StreamGenerator` is an object that will preprocess the `stream` and convert the messages into input (`x`) and target (`y`) data of the deep learning model.
  There are different options to choose under `ADLStream.data` and, if needed, we can create our custom `StreamGenerator` by inheriting `BaseStreamGenerator`.

  As our problem is time series forecasting, we will use the `MovingWindowStreamGenerator`, which performs the moving-window preprocessing method.

  ```python
  stream_generator = ADLStream.data.MovingWindowStreamGenerator(
      stream=stream, past_history=12, forecasting_horizon=3, shift=1
  )
  ```

  For the example we have set the past history to 12 and the model will predict the next 3 elements.



  In order to evaluate the performance of the model, we need to create a validator object.
  There exist different alternative for data-stream validation, some of the most common one can be found under `ADLStream.evaluation`.
  Furthermore, custom evaluators can be easily implemented by inheriting `BaseEvaluator`.

  In this case, we are going to create a `PrequentialEvaluator` which implements the idea that more recent examples are more important using a decaying factor.

  ```python
  evaluator = ADLStream.evaluation.PrequentialEvaluator(
      chunk_size=10,
      metric="MAE",
      fadding_factor=0.98,
      results_file="ADLStream2.csv",
      dataset_name="Fake Data",
      show_plot=True,
      plot_file="test.jpg",
  )
  ```

  As can be seen, we are using the mean absolute error (MAE) metrics. Other options can be found in `ADLStream.evaluation.metrics`.
  The evaluator will save the progress of the error metric in `results_file` and will also plot the progress and saved the image in `plot_file`.



  Finally we will create our `ADLStream` object specifying the model to use.

  The required model arguments are the architecture, the loss and the optimizer. In addition, we can provides a dict with the model parameters to customize its architecture.
  All the available model architecture and its parameters can be found in `ADLStream.models`.

  For the example we are using a deep learning model with 3 stacked LSTM layers of 16, 32 and 64 units followed by a fully connected block of two layers with 16 and 8 neurons.

  ```python
  model_architecture = "lstm"
  model_loss = "mae"
  model_optimizer = "adam"
  model_parameters = {
      "recurrent_units": [16, 32, 64],
      "recurrent_dropout": 0,
      "return_sequences": False,
      "dense_layers": [16, 8],
      "dense_dropout": 0,
  }

  adls = ADLStream.ADLStream(
      stream_generator=stream_generator,
      evaluator=evaluator,
      batch_size=60,
      num_batches_fed=20,
      model_architecture=model_architecture,
      model_loss=model_loss,
      model_optimizer=model_optimizer,
      model_parameters=model_parameters,
      log_file="ADLStream2.log",
  )
  ```



  Once we came the ADLStream object created, we can initiate it by calling its `run` function.

  ```python
  adls.run()
  ```

  The processes will start and the progress will be plot obtaining a result similar to this one

  ![output-plot](https://raw.githubusercontent.com/pedrolarben/ADLStream/master/docs/img/fakedata-example.gif)

  Complete API reference can be found [here](https://adlstream.readthedocs.io).



  Here it is the original paper that you can cite to reference ADLStream

  * [Lara-Benítez, Pedro, Manuel Carranza-garcía, et al. ‘Asynchronous Dual-pipeline Deep Learning Framework for Online Data Stream Classification’. Integrated Computer-Aided Engineering. 1 Jan. 2020 : 101 – 119.](https://doi.org/10.3233/ICA-200617)

  Any other study using ADLStream framework will be listed here.

  * [Lara-Benítez, Pedro, et al. "On the performance of deep learning models for time series classification in streaming." International Workshop on Soft Computing Models in Industrial and Environmental Applications. Springer, Cham, 2020.](http://arxiv.org/abs/2003.02544v2.pdf)



  Read [CONTRIBUTING.md](CONTRIBUTING.md). We appreciate all kinds of help.



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



  * **Pedro Lara-Benítez** - [LinkedIn](www.linkedin.com/in/pedrolarben)
  * **Manuel Carranza-García** - [LinkedIn](https://www.linkedin.com/in/manuelcarranzagarcia96/)
  * **Jorge García-Gutiérrez**
  * **José C. Riquelme**


  * [@pedrolarben](https://github.com/pedrolarben)
  * [@carranza96](https://github.com/carranza96)
  * [@preinaj](https://github.com/preinaj)


pkgId: 832ce5e8fa2ff0a2e722b5b6f36cf532b7685e2e9b97ceffd65b0db44c8b0758
name: python-ADPTC-LIB
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: 自适应密度峰值树聚类（Adaptive Density Peak Tree Clustering）
url: https://pypi.org/project/ADPTC-LIB/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADPTC-LIB-0.0.7-1.src.rpm
checksum_type: sha256
description:
  <!--
   * @Description:
   * @Author: SongJ
   * @Date: 2020-12-29 13:52:28
   * @LastEditTime: 2021-04-12 10:44:01
   * @LastEditors: SongJ
  -->


  本算法是在快速搜索与发现密度峰值聚类算法（Clustering by fast search and find of density peaks）CFSFDP的基础上进行改进的成果，主要解决的问题有:
  - 手动选择聚类中心
  - 单簇多密度峰值导致类簇误分
  - 面向时空数据聚类时，无法顾及时空耦合

  通过CFSFDP算法的核心概念：局部密度和斥群值，构建密度峰值树，通过直达点、连通点和切割点分离子树，达到类簇划分的目的。

  <img src="https://cdn.jsdelivr.net/gh/SuilandCoder/PicStorage//img/image-20210409210616098.png" alt="image-20210409210616098" style="zoom: 80%;" />

  ![image-20210409210731545](https://cdn.jsdelivr.net/gh/SuilandCoder/PicStorage//img/image-20210409210731545.png)

  ![image-20210409212843640](https://cdn.jsdelivr.net/gh/SuilandCoder/PicStorage//img/image-20210409212843640.png)




  ```python
  pip install ADPTC-LIB
  ```



  ```python
  import numpy as np
  from ADPTC_LIB.cluster import ADPTC
  from ADPTC_LIB import visual
  X = np.loadtxt(r"../test_data/Aggregation.txt", delimiter="\t")
  X = X[:,[0,1]]
  atdpc_obj = ADPTC(X)
  atdpc_obj.clustering(2)
  visual.show_result(atdpc_obj.labels,X,np.array(list(atdpc_obj.core_points)))
  ```

  ![image-20210410095608378](https://cdn.jsdelivr.net/gh/SuilandCoder/PicStorage//img/image-20210410095608378.png)



  ```python
  from ADPTC_LIB.cluster import ADPTC
  from ADPTC_LIB import visual
  import xarray as xr
  import os
  import numpy as np
  filePath = os.path.join(r'Z:\regions_daily_010deg\\05\\2013.nc')
  dataset = xr.open_dataset(filePath)
  pre_ds = dataset['precipitation']
  lon = pre_ds.lon
  lat = pre_ds.lat
  lon_range = lon[(lon>-30)&(lon<70)]
  lat_range = lat[(lat>30)&(lat<90)]
  var = pre_ds.sel(lon=lon_range,lat = lat_range)
  var = var.resample(time='1M',skipna=True).sum()
  var_t = var.sel(time=var.time[0])
  reduced = var_t.coarsen(lon=5).mean().coarsen(lat=5).mean()
  data_nc = np.array(reduced)
  spatial_eps=4
  attr_eps=8
  density_metric='gauss'
  spre = ADPTC(data_nc)
  spre.spacial_clustering_raster(spatial_eps,attr_eps,density_metric,knn_num=100,leaf_size=3000,connect_eps=0.9)
  visual.show_result_2d(reduced,spre.labels)
  ```

  ![image-20210410104300578](https://cdn.jsdelivr.net/gh/SuilandCoder/PicStorage//img/image-20210410104300578.png)



  ```python
  from ADPTC_LIB.cluster import ADPTC
  from ADPTC_LIB import visual
  import xarray as xr
  import numpy as np
  temp= xr.open_dataset(r'Z:\MSWX\temp\2020.nc')
  temp_2020 = temp['air_temperature']
  lon = temp_2020.lon
  lat = temp_2020.lat
  time = temp_2020.time
  lon_range = lon[(lon>70)&(lon<140)]
  lat_range = lat[(lat>15)&(lat<55)]
  var = temp_2020.sel(lon=lon_range,lat = lat_range)
  reduced = var.coarsen(lon=5).mean().coarsen(lat=5).mean()
  data_nc = np.array(reduced)
  s_eps = 5
  t_eps = 1
  attr_eps = 2.5
  density_metric='gauss'
  spre = ADPTC(data_nc)
  spre.st_clustering_raster(s_eps,t_eps,attr_eps,density_metric,knn_num=100,leaf_size=3000,connect_eps=0.9)
  visual.show_result_3d(reduced,spre,[70, 140, 15, 50],[0,12],21)
  ```

  ![image-20210412095947596](https://cdn.jsdelivr.net/gh/SuilandCoder/PicStorage//img/image-20210412095947596.png)


pkgId: 94cd43ff9b416216ea04e4a713a577b77aa6c2c870319776a40ac274487ab16d
name: python-ADPYNE-207
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Automatic Differentiation Package for Python
url: https://github.com/PYNE-AD/cs207-FinalProject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADPYNE-207-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/PYNE-AD/cs207-FinalProject.svg?branch=master)](https://travis-ci.org/PYNE-AD/cs207-FinalProject)

  [![Coverage Status](https://codecov.io/gh/PYNE-AD/cs207-FinalProject/branch/master/graph/badge.svg)](https://codecov.io/gh/PYNE-AD/cs207-FinalProject)





  -
    Paulina Toro Isaza

  - Yaowei Li

  - Nikhil Vanderklaauw

  - Emma Li





  1. Ensure you can run Python from the command line.
     - You can check this by running: `python --version`
  2. Ensure you can run  pip form the command line.
     - You can check this by running: `pip --version`



  1. Using virtual environment

     - Create an environment with the command: `conda create --name env_name python`
     - Activating the environment: `conda activate env_name`
     - You can get out of the environment (deactivate it) by typing: `conda deactivate`

  2. Install the package from PyPi and dependencies

     - Type  `pip install ADPYNE-207`


pkgId: ee04b3a5e9c7f6dd6bd290ef96b10a9a92afbbc08309346d9f1897e780277734
name: python-ADRpy
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Aircraft Design Recipes in Python: a library of aircraft conceptual design tools.
url: https://github.com/sobester/ADRpy
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADRpy-0.2.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ADRpy.svg)](https://badge.fury.io/py/ADRpy)
  [![Build Status](https://travis-ci.com/sobester/ADRpy.svg?branch=master)](https://travis-ci.com/sobester/ADRpy)
  A library of aircraft conceptual design and performance analysis tools, including
  virtual (design) atmospheres, constraint analysis methods, propulsion system
  performance models, conversion functions and much else.
  For a detailed description of the library, please consult the
  [Documentation](https://adrpy.readthedocs.io/en/latest/). To get started,
  follow the instructions below.
  For video tutorials and explainers (a.k.a. *ADRpy Shorts*) scroll to the bottom of this page.
  author: Andras Sobester


pkgId: 3d67f3bc7ef54f4f75c8f70f290a5674204656cdc1bc8990a249d75b01749e3a
name: python-ADS1x15-ADC
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Python library used for ADS1x15 analog to digital converter (ADC)
url: https://github.com/chandrawi/ADS1x15-ADC
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADS1x15-ADC-1.2.2-1.src.rpm
checksum_type: sha256
description:
  <!-- PROJECT SHIELDS -->
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/ADS1x15-ADC)](https://pypi.org/project/ADS1x15-ADC/)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/chandrawi/ADS1x15-ADC)](https://github.com/chandrawi/ADS1x15-ADC/releases)
  [![GitHub license](https://img.shields.io/github/license/chandrawi/ADS1x15-ADC)](https://github.com/chandrawi/ADS1x15-ADC/blob/main/LICENCE)



  Python library for I2C ADC ADS1015, ADS1115, and similar analog to digital converter. This library works with Raspberry pi or other SBC using I2C bus under Linux kernel.

  For using I2C ADC with Arduino, you can check similar library in this [link](https://github.com/RobTillaart/ADS1X15).




  This library should work for the devices mentioned below,
  although not all sensors support all functionality.

  | Device  | Channels | Resolution | Max sps | Comparator | ProgGainAMP | Notes  |
  |:-------:|:--------:|:----------:|:-------:|:----------:|:-----------:|:-------|
  | ADS1013 |    1     |     12     |  3300   |     N      |      N      |        |
  | ADS1014 |    1     |     12     |  3300   |     Y      |      Y      |        |
  | ADS1015 |    4     |     12     |  3300   |     Y      |      Y      |        |
  | ADS1113 |    1     |     16     |  860    |     N      |      N      |        |
  | ADS1114 |    1     |     16     |  860    |     Y      |      Y      |        |
  | ADS1115 |    4     |     16     |  860    |     Y      |      Y      | Tested |

  As the 1015 and the 1115 are both 4 channels these are the most
  interesting from functionality point of view as these can also do
  differential measurement.






  Using terminal run following command.
  ```sh
  pip3 install ADS1x15-ADC
  ```



  To using latest update of the library, you can clone then build python package manually. Using this method require **setuptools** and **wheel** module.
  ```sh
  git clone https://github.com/chandrawi/ADS1x15-ADC.git
  cd ADS1x15-ADC
  python3 setup.py bdist_wheel
  pip3 install dist/ADS1x15_ADC-1.2.1-py3-none-any.whl
  ```



  Before using the library, I2C interface must be enabled. For Raspberry pi OS, this is done by set I2C interface enable using raspi-config or edit **/boot/config.txt** by adding following line.
  ```txt
  dtparam=i2c_arm=on
  ```




  The address of the ADS1113/4/5 is determined by to which pin the **ADDR**
  is connected to:

  | ADDR pin connected to | Address | Notes   |
  |:---------------------:|:-------:|:-------:|
  |      GND              |   0x48  | default |
  |      VDD              |   0x49  |         |
  |      SDA              |   0x4A  |         |
  |      SCL              |   0x4B  |         |

  To initialize the library you must call constructor as described below.
  - **ADS1x15()** base constructor, should not be used.
  - **ADS1013(I2C_busId, I2C_address)** Constructor with I2C bus id,
  and optional device address as parameter.
  - **ADS1014(I2C_busId, I2C_address)** Constructor with I2C bus id,
  and optional device address as parameter.
  - **ADS1015(I2C_busId, I2C_address)** Constructor with I2C bus id,
  and optional device address as parameter.
  - **ADS1113(I2C_busId, I2C_address)** Constructor with I2C bus id,
  and optional device address as parameter.
  - **ADS1114(I2C_busId, I2C_address)** Constructor with I2C bus id,
  and optional device address as parameter.
  - **ADS1115(I2C_busId, I2C_address)** Constructor with I2C bus id,
  and optional device address as parameter.

  For example.

  ```python
  import ADS1x15


  ADS = ADS1x15.ADS1115(1)
  ```






  - **setGain(gain: int)** set the gain value, indicating the maxVoltage that can be measured. Adjusting the gain allowing to make more precise measurements.
  Note: the gain is not set in the device until an explicit read/request of the ADC (any read call will do).
  See table below.
  - **getGain()** returns the gain value (index).

  | PGA value | Max Voltage | Constant   | Notes   |
  |:---------:|:-----------:|:----------:|:-------:|
  |      0    |   ±6.144V   | PGA_6_144V | default |
  |      1    |   ±4.096V   | PGA_4_096V |         |
  |      2    |   ±2.048V   | PGA_2_048V |         |
  |      4    |   ±1.024V   | PGA_1_024V |         |
  |      8    |   ±0.512V   | PGA_0_512V |         |
  |      16   |   ±0.256V   | PGA_0_256V |         |

  - **getMaxVoltage()** returns the max voltage with the current gain.
  - **toVoltage(raw: int)** converts a raw measurement to a voltage.
  Can be used for normal and differential measurements.
  The default value of 1 returns the conversion factor for any raw number.

  The voltage factor can also be used to set HIGH and LOW threshold registers
  with a voltage in the comparator mode.
  Check the [examples](https://github.com/chandrawi/ADS1x15-ADC/blob/main/examples/ADS_comparator.py).

  ```python
    f = ADS.toVoltage()
    ADS.setComparatorThresholdLow( 1.5 / f )
    ADS.setComparatorThresholdHigh( 2.5 / f )
  ```




  The ADS sensor can operate in single shot or continuous mode.
  Depending on how often conversions needed you can tune the mode.
  - **setMode(mode: int)** 0 = MODE_CONTINUOUS, 1 = MODE_SINGLE (default)
  Note: the mode is not set in the device until an explicit read/request of the ADC (any read call will do).
  - **getMode()** returns current mode 0 or 1, or INVALID_MODE = -1.




  - **setDataRate(dataRate: int)** Data rate depends on type of device.
  For all devices the index 0..7 can be used, see table below.
  Values above 7 ==> will be set to the default 4.
  Note: the data rate is not set in the device until an explicit read/request of the ADC (any read call will do).
  - **getDataRate()** returns the current data rate (index).

  Data rate in samples per second, based on datasheet is described on table below.

  | data rate | ADS101x  | ADS111x | Constant        | Constant       | Notes   |
  |:---------:|---------:|--------:|:---------------:|:--------------:|:-------:|
  |     0     | 128 SPS  | 8 SPS   | DR_ADS101X_128  | DR_ADS111X_8   | slowest |
  |     1     | 250 SPS  | 16 SPS  | DR_ADS101X_250  | DR_ADS111X_16  |         |
  |     2     | 490 SPS  | 32 SPS  | DR_ADS101X_490  | DR_ADS111X_32  |         |
  |     3     | 920 SPS  | 64 SPS  | DR_ADS101X_920  | DR_ADS111X_64  |         |
  |     4     | 1600 SPS | 128 SPS | DR_ADS101X_1600 | DR_ADS111X_128 | default |
  |     5     | 2400 SPS | 250 SPS | DR_ADS101X_2400 | DR_ADS111X_250 |         |
  |     6     | 3300 SPS | 475 SPS | DR_ADS101X_3300 | DR_ADS111X_475 |         |
  |     7     | 3300 SPS | 860 SPS | DR_ADS101X_3300 | DR_ADS111X_860 | fastest |




  Reading the ADC in single mode is very straightforward, the **readADC()** function handles all in one call. This function will wait until conversion finished.
  - **readADC(pin: int)** normal ADC functionality, pin = 0..3.
  If the pin number is out of range, this function will return 0.

  ```python

  ADS.readADC(0)
  ```

  See [examples](https://github.com/chandrawi/ADS1x15-ADC/blob/main/examples/ADS_minimum.py).

  To read the ADC in an asynchronous way (e.g. to minimize blocking) you need call three functions:
  - **requestADC(pin: int)**  Start the conversion. pin = 0..3.
  - **isBusy()** (Is the conversion not ready yet?) or **isReady()** (Is the conversion ready?) Works only in SINGLE mode!
  - **getValue()** Read the result of the conversion.

  ```python

  ADS.setMode(ADS.MODE_SINGLE)    # SINGLE SHOT MODE
  ADS.requestADC(0)               # request on pin 0

  if ADS.isReady() :
      value = ADS.getValue()
      ADS.requestADC(0)           # request new conversion

  ```

  See [examples](https://github.com/chandrawi/ADS1x15-ADC/blob/main/examples/ADS_read_async.py).




  For reading the ADC in a differential way there are 4 calls possible.

  - **readADC_Differential_0_1()** returns the difference between 2 ADC pins.
  - **readADC_Differential_0_3()** ADS1x15 only
  - **readADC_Differential_1_3()** ADS1x15 only
  - **readADC_Differential_2_3()** ADS1x15 only

  ```python

  ADS.readADC_Differential_0_1(0)
  ```

  The differential reading of the ADC can also can be done using asynchronous calls.

  - **requestADC_Differential_0_1()** starts conversion for differential reading
  - **requestADC_Differential_0_3()** ADS1x15 only
  - **requestADC_Differential_1_3()** ADS1x15 only
  - **requestADC_Differential_2_3()** ADS1x15 only

  After one of these calls you need to call
  - **getValue()** Read the result of the last conversion.

  See [examples](https://github.com/chandrawi/ADS1x15-ADC/blob/main/examples/ADS_differential.py).




  To use the continuous mode you need call three functions:
  - **setMode(0)** 0 = MODE_CONTINUOUS, 1 = MODE_SINGLE (default).
  Note: the mode is not set in the device until an explicit read/request of the ADC (any read call will do).
  - **readADC(pin: int)** or **requestADC(pin: int)** to get the continuous mode started.
  - **getValue()** to return the last value read by the device.
  Note this can be a different pin, so be warned.
  Calling this over and over again can give the same value multiple times.

  ```python

  ADS.setMode(ADS.MODE_CONTINUOUS)
  ADS.requestADC(0)               # request on pin 0

  while True :
      value = ADS.getValue()
      sleep(1)
  ```

  See [examples](https://github.com/chandrawi/ADS1x15-ADC/blob/main/examples/ADS_continuous.py).


  In continuous mode, you can't use **isBusy()** or **isReady()** functions to wait until new data available.
  Instead you can configure **ALERT/RDY** pin to trigger an interrupt signal when conversion data ready.



  Interrupt signals on the **ALERT/RDY** pin can be triggered every conversion data ready.
  This is done by setting Hi_thresh register MSB to 1 and the Lo_thresh register MSB to 0.

  - **setComparatorThresholdLow(lo: int)** set 0x8000 as parameter.
  - **setComparatorThresholdHigh(hi: int)** set 0x7FFF as parameter.

  See [examples]().




  Please read Page 15 of the datasheet as the behaviour of the
  comparator is not trivial.

  NOTE: all comparator settings are copied to the device only after calling
  **readADC()** or **requestADC()** functions.




  When configured as a **TRADITIONAL** comparator, the **ALERT/RDY** pin asserts
  (active low by default) when conversion data exceed the limit set in the
  high threshold register. The comparator then de-asserts when the input
  signal falls below the low threshold register value.

  - **setComparatorMode(mode: int)** value 0 = COMP_MODE_TRADITIONAL 1 = COMP_MODE_WINDOW,
  - **getComparatorMode()** returns value set.


  If the comparator **LATCH** is set, the **ALERT/RDY** pin asserts and it will be
  reset after reading the sensor (conversion register) again.
  *An SMB alert command (00011001) on the I2C bus will also reset the alert state.*
  *Not implemented in the library (yet)*

  In **WINDOW** comparator mode, the **ALERT/RDY** pin asserts if conversion data exceeds
  the high threshold register or falls below the low threshold register.
  In this mode the alert is held if the **LATCH** is set. This is similar as above.




  Default state of the **ALERT/RDY** pin is **LOW**, can be to set **HIGH**.

  - **setComparatorPolarity(pol)**
  Flag is only explicitly set after a **readADC()** or a **requestADC()**
  - **getComparatorPolarity()** returns value set.




  Holds the **ALERT/RDY** to **HIGH** (or **LOW** depending on polarity) after triggered
  even if actual value has been 'restored to normal' value.

  - **setComparatorLatch(latch: int)** 0 = NO LATCH, not 0 = LATCH
  - **getComparatorLatch()** returns value set.




  Set the number of conversions before trigger activates.
  The **setComparatorQueConvert(mode: int)** is used to set the number of
  conversions that exceed the threshold before the **ALERT/RDY** pin is set **HIGH**.
  A value of 3 (or above) effectively disables the comparator. See table below.

  - **setComparatorQueConvert(mode: int)** See table below.
  - **getComparatorQueConvert()**  returns value set.

  | Value | Constant        | Meaning                           | Notes   |
  |:-----:|:---------------:|:----------------------------------|:-------:|
  |   0   | COMP_QUE_1_CONV | trigger alert after 1 conversion  |         |
  |   1   | COMP_QUE_2_CONV | trigger alert after 2 conversions |         |
  |   2   | COMP_QUE_4_CONV | trigger alert after 4 conversions |         |
  |   3   | COMP_QUE_NONE   | Disable comparator                | default |




  Depending on the comparator mode **TRADITIONAL** or **WINDOW** the thresholds registers mean something different.
  See Comparator Mode section or datasheet for more information.

  - **setComparatorThresholdLow(lo)** set the low threshold; take care the hi >= lo.
  - **setComparatorThresholdHigh(hi)**  set the high threshold; take care the hi >= lo.
  - **getComparatorThresholdLow()** reads value from device.
  - **getComparatorThresholdHigh()** reads value from device.




  - Improve documentation
  - More examples ?
  - SMB alert command (00011001) on I2C bus?




  See examples in this [link](https://github.com/chandrawi/ADS1x15-ADC/tree/main/examples)


pkgId: 76e0483f2a2ae80ea4b0ab16555e085170c4557212dc1da01e946919041d831c
name: python-ADTCreate
arch: src
version: 1.0.0rc5
epoch: 0
release: 1
url: https://github.com/MainJay/ADTPythonLibrary/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADTCreate-1.0.0rc5-1.src.rpm
checksum_type: sha256
summary:
  ADT Create provides a general method to create and customize Attack-Defense Trees (ADTs), allowing users to visualize and analyse security scenarios. A user is able to create and customize ADTs from scratch, upload/download ADTs in XML format, generate ADTerms based on ADTs, compare ADTerms to determine equivalence using an equivalence threshold using the Levenshtein Distance, determine satisfiability of an ADT and generate statistics of an ADT

description:
  Welcome to **ADT Create**. This project aims to provide a general method to create and customize Attack-Defense Trees (ADTs), allowing users to visualize and analyse security scenarios. A user is able to *create and customize ADTs from scratch*, *upload/download ADTs in XML format*, *generate ADTerms based on ADTs*, *compare ADTerms to determine equivalence using an equivalence threshold using the Levenshtein Distance*, *determine satisfiability of an ADT* and *generate statistics of an ADT*.


  This document will guide you through the project structure and the installation process of **ADT Create**.

  Explore the unlimited possible ADTs and strenghten your defenses!


  The files of the **package** can be found in folder `ADTCreate/`. \
  This folder contains the following files:
  - `ADT.py`: general functionalities for creation and construction of ADTs, contains the calls to other modules.
  - `ADTXML.py`: XML import and export functionalities.
  - `ADTSatisfiability.py`: Satisfiability functionalities.
  - `GenerateADTerm.py`: ADTerm Generation functionalities.
  - `CompareADTerms.py`: ADTerms Comparison functionalities.
  - `MultisetList.py`: Multiset implementation based on the `List` type.

  The **testprogram** can be found in this project in file `main.py` \
  The **changelog** can be found in this project in file `changelog.md`. \
  The **manual** can be found in this project in file `code_documentation.md`.


  Make sure you have installed **Python version >= 3.7** and the `pip` package. \
  Open your Terminal (on UNIX systems), and run `pip install ADTCreate`. \
  Open up a Python file, and add `from ADTCreate import ADT`.

  You have now succesfully installed **ADT Create** and imported it into your project. \
  Happy coding!

  To create an ADT, use: `adt_instance = ADT.initADT(type, refinement, label)`. \
  Use the features of **ADT Create** by performing them on `adt_instance`, such as `adt_instance.addChild(...)`.

  See `code_documentation.md` for instructions on how to use **ADT Create**, and `changelog.md` for the changelog on the GitHub repository of this project.


pkgId: ad641f7abd54e93685425fa1a67cd594ee17dacbe447fea795c6b6cacfa7aec6
name: python-ADattribution
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: make it easy to use AD postback
url: https://gitee.com/ZeroSeeker/ADattribution
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADattribution-0.0.10-1.src.rpm
checksum_type: sha256
description:
  广告归因

  1.  依赖管理
  - 生成依赖
  ```shell script
  pip3 freeze > requirements.txt
  ```
  - 安装依赖
  ```shell script
  pip3 install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple
  ```
  - 虚拟环境管理
  ```text
  创建虚拟环境：python3 -m venv venv
  激活虚拟环境：source venv/bin/activate

  退出虚拟环境：deactivate
  ```


pkgId: fecb0a2dc16a799d8d27ff65238c6eb33740d7559daf44b3a87cf9bd69c9f19a
name: python-ADmanage
arch: src
version: 0.9
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ADmanage/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ADmanage-0.9-1.src.rpm
checksum_type: sha256
description:
  The provided script is a Python program that interacts with an Active Directory (AD) server using the LDAP protocol. It allows you to perform various operations on DNS entries and AD objects (users, groups and computers).


  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.get_DNSentries()
  ad_client.disconnect()
  print(result)
  ```

  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.get_DNSentry('quad9')
  ad_client.disconnect()
  print(result)
  ```

  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.add_DNSentry('quad9', '149.112.112.112')
  ad_client.disconnect()
  print(result)
  ```

  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.modify_DNSentry('quad9', '9.9.9.9')
  ad_client.disconnect()
  print(result)
  ```

  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.del_DNSentry('quad9')
  ad_client.disconnect()
  print(result)
  ```

  Searches for and returns all user, group, and computer objects.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.get_ADobjects()
  ad_client.disconnect()
  print(result)
  ```

  Searches for and returns a specific AD object based on its sAMAccountName value.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.get_ADobject('Administrator')
  ad_client.disconnect()
  print(result)
  ```

  Adds users, computers, or groups to the AD server.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.add_ADobject('OU=test,DC=cobblepot59,DC=int', {'objectClass': 'user', 'givenName': 'Jack', 'sn': 'Bower', 'password': 'Password1'})
  ad_client.disconnect()
  print(result)
  ```
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.add_ADobject('OU=test,DC=cobblepot59,DC=int', {'objectClass': 'computer', 'cn': 'jbower-pc'})
  ad_client.disconnect()
  print(result)
  ```
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.add_ADobject('OU=test,DC=cobblepot59,DC=int', {'objectClass': 'group', 'cn': '24hChrono'})
  ad_client.disconnect()
  print(result)
  ```

  Deletes a specified AD object.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.del_ADobject('jbower')
  ad_client.disconnect()
  print(result)
  ```
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.del_ADobject('jbower-pc$')
  ad_client.disconnect()
  print(result)
  ```

  Retrieves the members of a specified group.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.get_member('Administrators')
  ad_client.disconnect()
  print(result)
  ```

  Retrieves the groups to which a user belongs.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.get_memberOf('Administrator')
  ad_client.disconnect()
  print(result)
  ```

  Adds an AD object to a group.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.add_ADobject_to_group('jbower', 'test')
  ad_client.disconnect()
  print(result)
  ```

  Removes an AD object from a group.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.del_ADobject_from_group('jbower', 'test')
  ad_client.disconnect()
  print(result)
  ```

  Modifies attributes of a specified AD object.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.modify_ADobject_attributes('jbower', {'mail': 'jack.bower@cobblepot59.int'})
  ad_client.disconnect()
  print(result)
  ```

  Resets the password of a user (works with SSL bind).
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.reset_password('jbower', 'Password2')
  ad_client.disconnect()
  print(result)
  ```

  Enables a user or computer account.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.enable_ADobject('jbower')
  ad_client.disconnect()
  print(result)
  ```

  Disables a user or computer account.
  ```sh
  from ADmanage import ADclient

  ad_client = ADclient(domain='cobblepot59.int', username='Administrator', password='Password1', dc_ip='ldap.cobblepot59.int', base_dn='DC=cobblepot59,DC=int', secure=True)
  result = ad_client.disable_ADobject('jbower-pc$')
  ad_client.disconnect()
  print(result)
  ```


pkgId: 88c9a338dc8cbcb02fe7c3d0f289ec89b8dd9eaededd1e8555d9cb5999ac8986
name: python-AEFM
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: An automatic experiment framework for microservice.
url: https://pypi.org/project/AEFM/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AEFM-0.2.0-1.src.rpm
checksum_type: sha256
description:
  AEFM is an ***A***utomatic ***E***xperiment ***F***ramework for ***M***icroservice, it provides a basic configuration that helps you to profiling basic information of microservices, and also the programmable interface to extend its usage.

  AEFM treat every experiment as a lifecycle, through the lifecycle, it will trigger different events. Users can customize different event handlers to achieve different objectives.

  The basic events of a lifecycle are as follows:
  * Start Experiment (`start_experiment`)
    * Registration of components / data
  * Init Environment (`init_environment`)
    * Initialization of MS application
  * \[Customized Events to Handle Test Case Starts \] (`start_$TEST_CASE_NAME`)
    * **Notes**: Before any test case handler events, `curretn_test_case` is set to `manager.data`
  * Start Single Test Case (`start_single_test_case`)
    * Workload should be generated here
  * Start Data Collection (`start_data_collection`)
    * Collect data asynchronously
  * End Experiment (`end_experiment`)
    * Waiting for data collector
    * Remove interference


  AEFM provides out-of-box commands, you only need a little of configuration.


  * Kubernetes cluster: At least 4 nodes (1 master + 3 slave), each of slave nodes has at least 8 CPU Cores + 32 GB RAM, slave nodes should be homogeneous.
  * Prometheus: We recommand installing prometheus from helm with the following command:
    ```bash
    helm install monitor prometheus-community/kube-prometheus-stack --version 39.11.0 -n monitor
    ```
    The corresponding service of prometheus should be set as `NodePort`, the AEFM uses it to fetch hardware data.
  * wrk2: Check [here](https://github.com/giltene/wrk2)
  * Some other dependencies (required by [DeathStarBench](https://github.com/delimitrou/DeathStarBench/blob/master/socialNetwork/README.md)):
    ```bash
    apt-get install -y libssl-dev libz-dev luarocks
    luarocks install luasocket
    ```
  * If you are using the default image of AEFM, you also need to put config files on all of worker nodes, check *Commands* > *download* part for more information.


  By running the following command, AEFM will create init files in current directory.
  ```bash
  python -m AEFM init
  ```

  You can also init into another directory with following command:
  ```bash
  python -m AEFM init -d my_first_app
  ```

  After initialization, the target directory will contain following files:
  ```
  target_dir
  ├─handlers.py
  ├─main.py
  └─sample_configs.yaml
  ```
  * `handlers.py` provides default handlers, you may edit them to match your requirement.
  * `main.py` is the entrance file of experiment, to run the experiment, use:
    ```bash
    python main.py
    ```
    By editing the `configs.CONFIG_FILE_PATH`, you can use different config file.
  * `sample_configs.yaml` is an sample config file. Please read comments inside to understand usage of each value.



  AEFM provides a command that can help you quickly generate configuration file, try the following command:
  ```bash
  python -m AEFM auto-config
  ```

  The program will check specification of your cluster and help you to set config file.


  AEFM relies on different components to perform efficiently and correctly.


  Manager is the highest level component that used to manage whole experiment. It provides events handling, globally data accessing and component registration. You can customize your experiment workflow, register new events, or replace default components with the help of manager object. You can also extend the class and create your customized manager.


  Deployer is used to manage kubernetes resources such as pod, deployments, etc. We manage theses resources based on YAML files, which can help users to detect which part is incorrect more efficient by directly look at YAML files.


  Workload generator is used to provide pressure to applications. By default, we use [wrk](https://github.com/giltene/wrk2) as workload generator, which can generate HTTP requests. You can also use other workload generating tools, as they provides the required API.

  By default, the workload generator provides test scripts of all applications & services, they are listed below, change `test_cases.workload.script` to use them:
  * Social Network:
    * Compose Post: `$MODULE_DEFAULT/hotel/compose-post.lua`
    * ReadHomeTimeline: `$MODULE_DEFAULT/hotel/read-home-timeline.lua`
    * ReadUserTimeline: `$MODULE_DEFAULT/hotel/read-user-timeline.lua`
    * Mixed Workload: `$MODULE_DEFAULT/hotel/mixed-workload.lua`
  * Hotel Reservation:
    * Login: `$MODULE_DEFAULT/hotel/login.lua`
    * Recommendation: `$MODULE_DEFAULT/hotel/recommendation.lua`
    * Search: `$MODULE_DEFAULT/hotel/search.lua`
    * Reservation: `$MODULE_DEFAULT/hotel/reserve.lua`
    * Mixed Workload: `$MODULE_DEFAULT/hotel/mixed-workload_type_1.lua`
  * Media Microservices:
    * Compose Review: `$MODULE_DEFAULT/media/compose-review.lua`
  * Train Ticket:
    * Query: `$MODULE_DEFAULT/train/query.lua`


  Data collector will collect data from different data sources, and save them as files. By default, we use Jaeger to collect traces data, Prometheus to collect hardware data and rely on output of wrk to collect throughput data. You can use other data sources by writing your own collectors, as they follow the collector interface, they can be set as component and let manager to involve it.


  Interference generator generates CPU, memory capacity/bandwidth and network bandwidth interferences by default. User can also customized their own interference generator to generates other types of intererence. For CPU and memory capacity/bandwidth interference, we use a [modified version](https://github.com/Nick-LCY/iBench) of [iBench](https://github.com/stanford-mast/iBench). For network bandwidth interference, we use [IPerf3](https://hub.docker.com/r/networkstatic/iperf3) to generate.


  Below listed out the available commands of the AEFM, try them by typing:
  ```bash
  python -m AEFM ${command}
  ```

  ```bash
  python -m AEFM init
  ```
  Initialize the application. Generates minimum required files to run the experiment.


  ```bash
  python -m AEFM get-file
  ```
  Get files, including:
  * DeathStarBench Configs: Config files that needed to be mount on DeathStarBench applications. By default, it should be unzipped and placed at `/root/social` and `/root/media`.

  * Deployment YAMLs: YAML files that used to deploy DeathStarBench and TrainTicket applications. If you need to modify them, download them, modify them and then change the path of `file_paths.yaml_repo` to them.


  ```bash
  python -m AEFM auto-config
  ```
  Automatically detect your kubernetes environment and specification of physical machines, suggest a basic config file.

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU 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 General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) <year>  <name of author> This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: 9a4b26eff6c82df31b259cc8db8983a4ac72e168cf1e24dd3c44e35fad2bf788
name: python-AEMET-OpenData
arch: src
version: 0.5.4
epoch: 0
release: 1
summary: AEMET OpenData Rest API library
url: https://github.com/Noltari/AEMET-OpenData
rpm_license: GPL-2.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AEMET-OpenData-0.5.4-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version][mdversion-button]][md-pypi]
  [![Python Versions][pyversion-button]][md-pypi]
  [![License: GPL v2][gpl2-button]](LICENSE.md)

  [gpl2-button]: https://img.shields.io/badge/License-GPL%20v2-blue.svg
  [md-pypi]: https://pypi.org/project/AEMET-OpenData
  [mdversion-button]: https://img.shields.io/pypi/v/AEMET-OpenData.svg
  [pyversion-button]: https://img.shields.io/pypi/pyversions/AEMET-OpenData.svg

  Python client for the AEMET OpenData Rest API.



  AEMET-OpenData is a Python module implementing an interface to the AEMET OpenData Rest API.<br/>
  It allows a user to gather all the public weather information from AEMET (Agencia Estatal de Meteorología).

  Documentation for the AEMET OpenData Rest API is available at https://opendata.aemet.es/.

  This package has been developed to be used with [Home-Assistant](https://home-assistant.io/) but it can be used in other contexts.



  AEMET-OpenData was created for my own use, and for others who may wish to experiment with personal Internet of Things systems.

  I have no connection with AEMET. I receive no help (financial or otherwise) from AEMET, and have no business interest with them.

  This software is provided without warranty, according to the GNU Public Licence version 2, and should therefore not be used where it may endanger life, financial stakes, or cause discomfort and inconvenience to others.


  - Python >= 3.11


  ```bash
  pip install AEMET-OpenData
  ```


  Run the following command inside this folder
  ```bash
  pip install --upgrade .
  ```


  Examples can be found in the `examples` folder


pkgId: b6f8b1952172acfbccff12f7cb88d634ac964870548ea5a684f4fb2a5ec24a4d
name: python-AEPi
arch: src
version: 0.8.3.2
epoch: 0
release: 1
summary: Read and write Abyss Engine Image (AEI) files from python, for Galaxy on Fire 2
url: https://github.com/Trimatix/AEPi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AEPi-0.8.3.2-1.src.rpm
checksum_type: sha256
description:
  <h3 align="center">AEPi</h3>
    <p align="center">
      Abyss Engine Image (AEI) conversion for python<br>
      Join <a href='https://discord.gg/Qv8zTur'>The Kaamo Club discord server</a> for Galaxy on Fire fans and modding
    </p>
  </div>
  <p align="center">
    <a href="https://github.com/Trimatix/AEPi/actions"
      ><img
        src="https://img.shields.io/github/actions/workflow/status/Trimatix/AEPi/testing.yml?branch=main"
        alt="GitHub Actions workflow status"
    /></a>
    <a href="https://github.com/Trimatix/AEPi/projects/1?card_filter_query=label%3Abug"
      ><img
        src="https://img.shields.io/github/issues-search?color=eb4034&label=bug%20reports&query=repo%3ATrimatix%2FAEPi%20is%3Aopen%20label%3Abug"
        alt="GitHub open bug reports"
    /></a>
    <a href="https://github.com/Trimatix/AEPi/actions"
      ><img
        src="https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/Trimatix/8a5430ecc0f87b003367174b1521f3bb/raw/AEPi__heads_main.json"
        alt="Test coverage"
    /></a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/AEPi"
      ><img
        src='https://badgen.net/pypi/v/AEPi/'
        alt="Pypi package version"
    /></a>
    <a href="https://pypi.org/project/AEPi"
      ><img
        src="https://img.shields.io/pypi/pyversions/AEPi.svg"
        alt="Minimum supported Python version"
    /></a>
    <a href="https://github.com/Trimatix/AEPi/blob/master/LICENSE"
      ><img
        src="https://img.shields.io/github/license/Trimatix/AEPi.svg"
        alt="License"
  </p>
  <p align="center">
    <a href="https://sonarcloud.io/dashboard?id=Trimatix_AEPi"
      ><img
        src="https://sonarcloud.io/api/project_badges/measure?project=Trimatix_AEPi&metric=bugs"
        alt="SonarCloud bugs analysis"
    /></a>
    <a href="https://sonarcloud.io/dashboard?id=Trimatix_AEPi"
      ><img
        src="https://sonarcloud.io/api/project_badges/measure?project=Trimatix_AEPi&metric=code_smells"
        alt="SonarCloud code smells analysis"
    /></a>
    <a href="https://sonarcloud.io/dashboard?id=Trimatix_AEPi"
      ><img
        src="https://sonarcloud.io/api/project_badges/measure?project=Trimatix_AEPi&metric=alert_status"
        alt="SonarCloud quality gate status"
    /></a>
  </p>



  <!-- TABLE OF CONTENTS -->
  <details open>
    <summary>Table of Contents</summary>
    <ol>
      <li>
        <a href="#about-the-project">About The Project</a>
      </li>
      <li>
        <a href="#getting-started">Getting Started</a>
        <ul>
          <li><a href="#prerequisites">Prerequisites</a></li>
          <li><a href="#installation">Installation</a></li>
        </ul>
      </li>
      <li>
        <a href="#usage">Usage</a></li>
        <ul>
          <li><a href="#open-an-aei-file-on-disk">Open an .aei file on disk</a></li>
          <li><a href="#create-a-new-aei">Create a new AEI</a></li>
        </ul>
      <li><a href="#roadmap">Roadmap</a></li>
      <li><a href="#contributing">Contributing</a></li>
    </ol>
  </details>



  <!-- ABOUT THE PROJECT -->


  **Abyss Engine** is an internal-only game engine developed by Deep Silver FishLabs, for the development of the Galaxy on Fire game series.

  The engine uses a proprietary file format for grids of images, called Abyss Engine Image (AEI). The image compression is platform dependant, for example Android texture files are compressed with [Ericsson Texture Compression (ETC)](https://github.com/Ericsson/ETCPACK).

  The AEI format was analysed by the Russian modding group 'CatLabs', who later created a GUI and command-line tool for conversion between PNG and AEI, named AEIEditor.

  This tool was closed-source, and relied on a windows DLL for compression. AEPi is a minimal recreation of the image conversion logic provided by AEIEditor, leaning on open source image codecs:
  - [K0lb3/etcpak](https://github.com/K0lb3/etcpak)
  - [K0lb3/tex2img](https://github.com/K0lb3/tex2img)

  See <a href="#roadmap">the project roadmap</a> for currently supported and upcoming features.


  <!-- GETTING STARTED -->



  * python 3.6+



  install AEPi from PyPi:
  ```
  python -m pip install aepi
  ```

  <!-- USAGE EXAMPLES -->


  This library reflects the real representation of an AEI file on disk; though textures are added to and read from an AEI object as individual images, the underlying representation is a single image. This improves encoding/decoding performance, and enables overlapping textures.

  For maximum flexibility, AEPi returns AEIs as BytesIO objects.

  The recommended best practise is to wrap your AEPi call in a `with` statement, to ensure that all of the AEI's images are cleaned out of memory when it goes out of scope.



  ```py
  from AEPi import AEI

  with AEI.read("path/to/file.aei") as aei:
    print(
      f"The AEI is compressed in {aei.format.name} format, "
      f"with {len(aei.textures)} textures. "
      f"Width: {aei.shape[0]} Height: {aei.shape[0]}"
  )
  ```



  `AEI.textures` provides read access to all of the AEI's bounding boxes. The `AEI.getTexture` method returns the relevant segment of the AEI, as a Pillow `Image`.

  Using this, you could for example, batch export all of the individual images within an AEI:

  ```py
  for i, tex in enumerate(aei.textures):
    with aei.getTexture(tex) as im:
      im.save(f"batch/export/{i}.png")
  ```



  ```py
  from AEPi import AEI, CompressionFormat,
  from PIL import Image

  image_path = "ship-texture.png"
  image2_path = "another-texture.png"


  with Image.open(image_path) as image, Image.open(image2_path) as image2:
    
    with AEI(image) as new_aei:
      
      new_aei.addTexture(image2, 0, 0)
      
      new_aei.removeTexture(0, 0, image2.width, image2.height, clearImage=False)
  ```



  ```py
      with open("path/to/newFile.aei", "wb") as new_file:
        
        aei.write(new_file, format=CompressionFormat.DXT5)
  ```

  <!-- ROADMAP -->


  The AEPi 1.0 release will mark feature parity with AEIEditor, which theoretically reflects all of the capabilities required to manipulate Galaxy on Fire 2 AEIs on all platforms.

  For details of the work that needs to be done, see the issues listed under the 1.0 milestone: https://github.com/Trimatix/AEPi/milestones

  Other work is needed (e.g documentation, QOL improvements...), but below is an overview of the *features* implementation progress towards AEIEditor parity:

  |Feature                    |Read support|Write support |
  |---------------------------|:----------:|:------------:|
  |Raw image content          |     ✅     |      ✅      |
  |Basic metadata             |     ✅     |      ✅      |
  |Texture regions            |     ✅     |      ✅      |
  |Mipmapping                 |     ✅     |      ❌      |
  |Compression quality (l/m/h)|     ❌     |      ❌      |
  |Symbol maps                |     ❌     |      ❌      |

  And compression format support progress:

  |Format                 |Read support|Write support |
  |-----------------------|:----------:|:------------:|
  |Uncompressed           |     ❌     |      ❌      |
  |Uncompressed_UI        |     ✅     |      ✅      |
  |Uncompressed_CubeMap_PC|     ✅     |      ✅      |
  |Uncompressed_CubeMap   |     ✅     |      ✅      |
  |PVRTC12A               |     ❌     |      ❌      |
  |PVRTC14A               |     ❌     |      ❌      |
  |ATC                    |     ✅     |      ❌      |
  |DXT1                   |     ✅     |      ❌      |
  |DXT3                   |     ❌     |      ❌      |
  |DXT5                   |     ✅     |      ✅      |
  |ETC1                   |     ✅     |      ✅      |

  Extra feature requests for after the 1.0 release are very welcome.

  To report a bug or request a feature, please submit an issue to the [open issues](https://github.com/Trimatix/AEPi/issues) page of this repository.


  <!-- CONTRIBUTING -->


  This project has a huge amount of potential to help the community and extend the lifetime of our beloved game series. Your contributions will make that possible, and so I thank you deeply for your help with this project.

  Please star the repository to let me know that my work is appreciated!

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request


pkgId: 8a1d65fa1b9b55417abe1acd509648c5cc14ca24efb088372ec64c55c41f8a9b
name: python-AES-Python
arch: src
version: 1.5.5
epoch: 0
release: 1
summary: AES (Advanced Encryption Standard) implementation in Python-3
url: https://github.com/Glindeb/AES-Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AES-Python-1.5.5-1.src.rpm
checksum_type: sha256
description:
  - Implementation of the AES encryption and decryption processes.
  - Support for two different modes of operation: ECB, CBC.
  - Support for the three different key lengths included in the [AES standard](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.197-upd1.pdf). (128, 192, 256 bit)
  - Key expansion and round key generation.
  - Encryption & decryption of individual files.
  - Encryption & decryption of python string objects.


pkgId: fac0a32f919cfdb7ff00e8d8e07a0337ecae3027f82fad20edac70d858fd0957
name: python-AESencrypt
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: tool for encrypting files using AES encryption
url: https://github.com/AhmadTaj1754/AESencrypter
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AESencrypt-0.0.5-1.src.rpm
checksum_type: sha256
description:
  AESencrypter is a cross-platform hashing/mapping Python module for human beings. Used to simulate a Python dictionary.
  Install AESencrypter on your system using :
  pip install AESencrypt
  Import AESencrypter into your project using :
  import AESencrypter
  Example of creating and using instance of hashMap:
  import AESencrypter
  AESencrypter.create()


pkgId: dc26c51c93121e0638227dc27ab261ee27e458c60f72902a8e7d99ce1bf22dc0
name: python-AFEM
arch: src
version: 1.0.34
epoch: 0
release: 1
summary: A Finite Element Python implementation
url: https://github.com/ZibraMax/FEM
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AFEM-1.0.34-1.src.rpm
checksum_type: sha256
description:
  <!-- LTeX: language=en -->

  [![Build status](https://github.com/ZibraMax/FEM/actions/workflows/python-publish.yml/badge.svg)](https://github.com/ZibraMax/FEM/actions/workflows/python-publish.yml)
  [![Docs](https://github.com/ZibraMax/FEM/actions/workflows/python-docs.yml/badge.svg)](https://github.com/ZibraMax/FEM/actions/workflows/python-docs.yml)
  [![PyPI version](https://badge.fury.io/py/AFEM.svg)](https://badge.fury.io/py/AFEM)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/854107ce95794d28beac5ea5c44e1dd2)](https://www.codacy.com/gh/ZibraMax/FEM/dashboard?utm_source=github.com&utm_medium=referral&utm_content=ZibraMax/FEM&utm_campaign=Badge_Grade)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/ZibraMax/FEM/blob/master/LICENSE)
  [![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
  [![GitHub release](https://img.shields.io/github/v/release/ZibraMax/FEM.svg)](https://github.com/ZibraMax/FEM/releases/)

  A [Python](https://www.python.org/) FEM implementation.

  N dimensional FEM implementation for M variables per node problems.



  Use the package manager [pip](https://pypi.org/project/AFEM/) to install AFEM.

  ```bash
  pip install AFEM
  ```

  From source:

  ```bash
  git clone https://github.com/ZibraMax/FEM
  cd FEM
  python -m venv .venv
  python -m pip install build
  python -m build
  python -m pip install -e .[docs] # Basic instalation with docs
  ```



  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.







  Avaliable equations:

  -   1D 1 Variable ordinary diferential equation
  -   1D 1 Variable 1D Heat with convective border
  -   1D 2 Variable Euler Bernoulli Beams
  -   1D 3 Variable Non-linear Euler Bernoulli Beams
  -   2D 1 Variable Torsion
  -   2D 1 Variable Poisson equation
  -   2D 1 Variable second order PDE
  -   2D 1 Variable 2D Heat with convective borders
  -   2D 2 Variable Plane Strees
  -   2D 2 Variable Plane Strees Orthotropic
  -   2D 2 Variable Plane Strain
  -   3D 3 variables per node isotropic elasticity

  Numerical Validation:

  -   [x] 1D 1 Variable ordinary diferential equation
  -   [ ] 1D 1 Variable 1D Heat with convective border
  -   [ ] 1D 2 Variable Euler Bernoulli Beams
  -   [ ] 1D 3 Variable Non-linear Euler Bernoulli Beams
  -   [x] 2D 1 Variable Torsion
  -   [ ] 2D 1 Variable 2D Heat with convective borders
  -   [x] 2D 2 Variable Plane Strees
  -   [x] 2D 2 Variable Plane Strain



  -   Create geometry
  -   Create Border Conditions (Point and regions supported)
  -   Solve!
  -   For example: Example 2, Example 5, Example 11-14



  ```python
  import matplotlib.pyplot as plt #Import libraries
  from FEM.Torsion2D import Torsion2D #import AFEM Torsion class
  from FEM.Geometry import Delaunay #Import Meshing tools


  a = 0.3
  b = 0.3
  tw = 0.05
  tf = 0.05


  E = 200000
  v = 0.27
  G = E / (2 * (1 + v))
  phi = 1 #Rotation angle


  vertices = [
          [0, 0],
          [a, 0],
          [a, tf],
          [a / 2 + tw / 2, tf],
          [a / 2 + tw / 2, tf + b],
          [a, tf + b],
          [a, 2 * tf + b],
          [0, 2 * tf + b],
          [0, tf + b],
          [a / 2 - tw / 2, tf + b],
          [a / 2 - tw / 2, tf],
          [0, tf],
  ]


  params = Delaunay._strdelaunay(constrained=True, delaunay=True,
                                                                          a='0.00003', o=2)

  geometry = Delaunay(vertices, params)


  geometry.exportJSON('I_test.json')


  O = Torsion2D(geometry, G, phi)


  O.solve()
  plt.show()

  ```



  ```python
  import matplotlib.pyplot as plt #Import libraries
  from FEM.Torsion2D import Torsion2D #import AFEM
  from FEM.Geometry import Geometry #Import Geometry tools


  E = 200000
  v = 0.27
  G = E / (2 * (1 + v))
  phi = 1 #Rotation angle


  geometry = Geometry.importJSON('I_test.json')


  O = Torsion2D(geometry, G, phi)


  O.solve()
  plt.show()


  ```



  Note: Don't forget the docstring!



  1. Create a Python flie and import the libraries:

      ```python
      from .Core import *
      from tqdm import tqdm
      import numpy as np
      import matplotlib.pyplot as plt
      ```

      - Core: Solver
      - Numpy: Numpy data
      - Matplotlib: Matplotlib graphs
      - Tqdm: Progressbars

  2. Create a Python class with Core inheritance
      ```python
      class PlaneStress(Core):
          def __init__(self,geometry,*args,**kargs):
          
          Core.__init__(self,geometry)
      ```
      It is important to manage the number of variables per node in the input geometry.
  3. Define the matrix calculation methods and post porcessing methods.

      ```python
      def elementMatrices(self):
      def postProcess(self):
      ```

  4. The `elementMatrices` method uses gauss integration points, so you must use the following structure:

      ```python

      for e in tqdm(self.elements,unit='Element'):
          _x,_p = e.T(e.Z.T) #Gauss points in global coordinates and Shape functions evaluated in gauss points
          jac,dpz = e.J(e.Z.T) #Jacobian evaluated in gauss points and shape functions derivatives in natural coordinates
          detjac = np.linalg.det(jac)
          _j = np.linalg.inv(jac) #Jacobian inverse
          dpx = _j @ dpz #Shape function derivatives in global coordinates
          for k in range(len(e.Z)): #Iterate over gauss points on domain
              
          
      ```

  A good example is the `PlaneStress` class in the `Elasticity2D.py` file.



  1. 2D elastic plate theory
  2. Transient analysis (Core modification)
  3. Non-Lineal for 2D equation (All cases)
  4. Testing and numerical validation (WIP)





  J. N. Reddy. Introduction to the Finite Element Method, Third Edition (McGraw-Hill Education: New York, Chicago, San Francisco, Athens, London, Madrid, Mexico City, Milan, New Delhi, Singapore, Sydney, Toronto, 2006). https://www.accessengineeringlibrary.com/content/book/9780072466850

  Jonathan Richard Shewchuk, (1996) Triangle: Engineering a 2D Quality Mesh Generator and Delaunay Triangulator

  Ramirez, F. (2020). ICYA 4414 Modelación con Elementos Finitos [Class handout]. Universidad de Los Andes.



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


pkgId: 746bbf144d12fdd31da6aaf7ce46f80a39aff7175d3aad8d63cfc5698d3ce578
name: python-AFMReader
arch: src
version: 0.0.1
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.1-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)

  </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/) |

  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                                     |
  |-------------|---------------------------------------------------------|--------------------------------------------|
  | `.gwy`      | [Gwyddion](http://gwyddion.net/)                        | TopoStats supported, to be migrated (#1).  |
  | `.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 `.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 `.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.


