# packages

pkgId: 51100e466b23bb20b8ddf82597d4737ff0c6b8800fe6853f75bedea81c48f3ce
name: python-babyyoda
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/babyyoda/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-babyyoda-0.0.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/babyyoda.svg)](https://pypi.org/project/babyyoda)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/babyyoda.svg)](https://pypi.org/project/babyyoda)
  [![CI/CD](https://github.com/APN-Pucky/babyyoda/actions/workflows/ci.yml/badge.svg)](https://github.com/APN-Pucky/babyyoda/actions/workflows/ci.yml)
  [![Code Coverage](https://codecov.io/gh/APN-Pucky/babyyoda/graph/badge.svg?branch=master)](https://codecov.io/gh/APN-Pucky/babyyoda?branch=master)

  ______________________________________________________________________



  `babyyoda` has the advantages

  - works with just Python 3 and can be installed with pip.
  - makes it easy to manipulate the bin contents (compared to YODA-1).
  - tries to adhere to the UHI standard.
  - is easy to plot in a Jupyter notebook.
  - keeps data representation close to the yoda file format.

  and the disadvantages to `yoda` are that it

  - is slower.
  - is not as feature complete.
  - is not as well tested.
  - only has histogram support.



  ```console
  pip install babyyoda
  ```



  `babyyoda` is designed to be a drop-in replacement for `yoda` with a few key differences:

  ```python
  import babyyoda as yoda
  ```

  with UHI support.
  It can use either `yoda` (C++) or `babyyoda.grogu` (Python) as backend.
  At some point the UHI support might be adapted by the original `yoda` package.

  For a less feature complete version, `babyyoda.grogu` is a simpler python drop-in replacement for `yoda` without UHI:

  ```python
  import babyyoda.grogu as yoda
  ```

  or force yoda use with

  ```python
  import babyyoda.yoda as yoda
  ```



  | Interface                                                        | Status | Examples and Notes                                                                                                       |
  | ---------------------------------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------ |
  | [histoprint](https://github.com/scikit-hep/histoprint)           | ✅     | [histo1d](examples/interface/histoprint/histo1d.ipynb)                                                                   |
  | [mplhep](https://github.com/scikit-hep/mplhep)                   | ✅     | [histo1d](examples/interface/mplhep/histo1d.ipynb), [histo2d](examples/interface/mplhep/histo2d.ipynb)                   |
  | [plothist](https://github.com/scikit-hep/plothist)               | ❌     | Does not support UHI/PlottableProtocol, only boost-histogram                                                             |
  | [uproot](https://github.com/scikit-hep/uproot)                   | ❌     | WIP: [histo1d](examples/interface/uproot/histo1d.ipynb)                                                                  |
  | [hist](https://github.com/scikit-hep/hist)                       | ✅     | [histo1d](examples/interface/hist/histo1d.ipynb), [histo2d](examples/interface/hist/histo2d.ipynb)                       |
  | [boost-histogram](https://github.com/scikit-hep/boost-histogram) | ✅     | [histo1d](examples/interface/boost-histogram/histo1d.ipynb), [histo2d](examples/interface/boost-histogram/histo2d.ipynb) |
  | [cuda-histogram](https://github.com/scikit-hep/cuda-histogram)   | ❔     |                                                                                                                          |
  | [ROOT](https://github.com/root-project/root)                     | ❔     |                                                                                                                          |



  `babyyoda` is distributed under the terms of the [BSD-3-Clause](https://spdx.org/licenses/BSD-3-Clause.html) license.


pkgId: eaf9529c0cba27317d1669fe30347ac35424ed1e9c3ca9b387ea0f5803f3f9eb
name: python-bacalhau-airflow
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: An Apache Airflow provider for Bacalhau.
url: https://github.com/filecoin-project/bacalhau/tree/main/integration/airflow
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bacalhau-airflow-1.3.2-1.src.rpm
checksum_type: sha256
description:
  This is `bacalhau-airflow`, a Python package that integrates [Bacalhau](https://github.com/bacalhau-project/bacalhau) with [Apache Airflow](https://github.com/apache/airflow).
  The benefit is two fold.
  First, thanks to this package you can now write complex pipelines for Bacalhau.
  For instance, jobs can communicate their output's CIDs to downstream jobs, that can use those as inputs.
  Second, Apache Airflow provides a solid solution to reliably orchestrate your DAGs.




  - Create Airflow tasks that run on Bacalhau (via custom operator!)
  - Support for sharded jobs: output shards can be passed downstream (via [XComs](https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/xcoms.html))
  - Coming soon...
      - Lineage (see [OpenLineage proof-of-concept integration here](https://github.com/enricorotundo/bacalhau-airflow-provider))
      - Various working code examples
      - Hosting instructions



  - Python 3.8+
  - [`bacalhau-sdk` 0.1.6](https://pypi.org/project/bacalhau-sdk/)
  - `apache-airflow` 2.3+



  The integration automatically registers itself for Airflow 2.3+ if it's installed on the Airflow worker's Python.



  ```console
  pip install bacalhau-airflow
  ```



  Clone the public repository:

  ```shell
  git clone https://github.com/bacalhau-project/bacalhau/
  ```

  Once you have a copy of the source, you can install it with:

  ```shell
  cd integration/airflow/
  pip install .
  ```






  > In a production environment you may want to follow the [official Airflow's instructions](https://airflow.apache.org/docs/apache-airflow/stable/administration-and-deployment/production-deployment.html) or pick one of the suggested [hosted solutions](https://airflow.apache.org/ecosystem/#airflow-as-a-service).

  If you're just curious and want to give it a try on your *local machine*, please follow the steps below.

  First, install and initialize Airflow:

  ```shell
  $ pip install apache-airflow
  export AIRFLOW_HOME=~/airflow
  $ airflow db init
  ```

  Then, we need to point Airflow to the absolute path of the folder where your pipelines live.
  To do that we edit the `dags_folder` field in `${AIRFLOW_HOME}/airflow.cfg` file.
  In this example I'm going to use the `hello_world.py` DAG shipped with this repository;
  for the sake of completeness, the next section will walk you through the actual code.

  My config file looks like what follows:

  ```
  [core]
  dags_folder = /Users/enricorotundo/bacalhau/integration/airflow/example_dags
  ...
  ```

  Optionally, to reduce clutter in the Airflow UI, you could disable the loading of the default example DAGs by setting `load_examples` to `False`.

  Finally, we can launch Airflow locally:

  ```shell
  airflow standalone
  ```



  While Airflow's pinwheel is warming up in the background, let's take a look at the `hello_world.py` break down below.

  > In brief, the first task of this DAG prints out "Hello World" to stdout, then automatically pipe its output into the subsequent task as an input file. The second task will simply print out the content of its input file.

  All you need to import from this package is the `BacalhauSubmitJobOperator`.
  It allows you to submit a job spec comprised of the usual fields such as engine, image, etc.

  ```python
  from datetime import datetime
  from airflow import DAG
  from bacalhau_airflow.operators import BacalhauSubmitJobOperator
  ```

  This operator supports chaining multiple jobs without the need to manually pass any CID along, in this regards a special note goes to the `input_volumes` parameter (see `task_2` below).
  Every time the operator runs a task, it stores a comma-separated string with the output shard-CIDs in an internal key-value store under the `cids` key.
  Thus, downstream tasks can read in those CIDs via the `input_volumes` parameter.

  All you need to do is (1) use the [XComs syntax](https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/xcoms.html) (in curly brackets) to specify the "sender" task ids and the `cids` key (e.g. `{{ task_instance.xcom_pull(task_ids='task_1', key='cids') }}`), (2) define a target mount point separated by a colon (e.g. `:/task_1_output`).

  Lastly, we define task dependencies simply with `task_1 >> task_2`.
  To learn more about [Airflow's DAG syntax please check out this page](https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/dags.html#task-dependencies).

  ```python
  with DAG("bacalhau-helloworld-dag", start_date=datetime(2023, 3, 1)) as dag:
      task_1 = BacalhauSubmitJobOperator(
          task_id="task_1",
          api_version="V1beta1",
          job_spec=dict(
              engine="Docker",
              publisher="IPFS",
              docker=dict(
                  image="ubuntu",
                  entrypoint=["echo", "Hello World"],
              ),
              deal=dict(concurrency=1),
          ),
      )

      task_2 = BacalhauSubmitJobOperator(
          task_id="task_2",
          api_version="V1beta1",
          input_volumes=[
              "{{ task_instance.xcom_pull(task_ids='task_1', key='cids') }}:/task_1_output",
          ],
          job_spec=dict(
              engine="Docker",
              publisher="IPFS",
              docker=dict(
                  image="ubuntu",
                  entrypoint=["cat", "/task_1_output/stdout"],
              ),
              deal=dict(concurrency=1),
          ),
      )

      task_1 >> task_2
  ```



  Now the we understand what the example DAG is supposed to do, let's just run it!
  Head over to http://0.0.0.0:8080 were Airflow UI is being served.
  The screenshot below shows our hello world has been loaded correctly.

  ![](docs/_static/airflow_01.png)

  When you inspect a DAG, Airflow will render a graph depicting a color-coded topology (see image below).
  For active (i.e. running) pipelines, this will be useful to oversee what the status of each task is.

  To trigger a DAG please enable the toggle shown below.

  ![](docs/_static/airflow_02.png)

  When all tasks have completed, we want to fetch the output of our pipeline.
  To do so we need to retrieve the job-id of the last task.
  Click on a green box in the `task_2` line and then open the XCom tab.

  ![](docs/_static/airflow_03.png)

  Here we find the `bacalhau_job_id`.
  Select that value and copy into your clipboard.

  ![](docs/_static/airflow_04.png)

  Lastly, we can use the bacalhau cli `get` command to fetch the output data as follows:

  ```console
  $ bacalhau get 8fdab73b-00fd-4d13-941c-8ba002f8178d
  Fetching results of job '8fdab73b-00fd-4d13-941c-8ba002f8178d'...
  ...
  Results for job '8fdab73b-00fd-4d13-941c-8ba002f8178d' have been written to...
  /tmp/dag-example/job-8fdab73b

  $ cat /tmp/dag-example/job-8fdab73b/combined_results/stdout
  Hello World
  ```

  That's all folks :rainbow:.




  ```console
  pip install -r dev-requirements.txt
  ```




  ```shell
  tox
  ```

  You can also skip using `tox` and run `pytest` on your own dev environment.


pkgId: d22bbe10d8782aca00b16c86d2d91e0cf80747039f4c95a60660507a3417703a
name: python-back
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Backbone for PyTorch training loop
url: https://github.com/EvgenyKashin/backbone
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-back-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Will try to keep it minimalistic.

  `pip install back`
  ```python
  from back import Bone
  ```


  - Progress bar
  - Checkpoints saving/loading
  - Schedulers
  - Tensorboard logging
  - Early stopping
  - Multiple GPUs


  - [ ] Learning Rate Finder
  - [ ] Notebook example
  - [ ] Docs/tests


  `docker build -t backbone_pytorch .`

  or

  `sudo docker pull digitman/backbone_pytorch:latest`



  https://github.com/EvgenyKashin/SRMnet


pkgId: 47c39f923981e0d3af25e26a82f3c4fcc337dab492ea3e682adb740bdd5d8788
name: python-backbone-translation
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Python Utilities & Basalam Micro-Services SDK
url: https://github.com/basalam/backbone-translation
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backbone-translation-1.0.1-1.src.rpm
checksum_type: sha256
description:
  - Python 3.6+



  ```shell
  pip install basalam.backbone-translation
  ```



  ```python
  from backbone_translation.translator import Translator

  translator = Translator({
      "messages.greeting" : "Bonjour {name}"
  })



  translator.translate("messages.greeting", name="Mojtabaa")

  ```



  ```bash

  pip install pytest


  python -m pytest
  ```


  - 0.0.2 added from_json_file method
  - 0.0.3 Now build and push are done using gitlab-ci
  - 0.0.4 new `exists(phrase: str) -> bool` method
  - 0.1.0 added utf-8 encoding thanks to alimohammayali@gmail.com


pkgId: 8171aa87f59dbe2f8a7030225a577f58beeb0904620da1c3ea7bc5ae3bf6dde5
name: python-backend-dev-utils
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Utility functions for python backend developers.
url: https://backend-dev-utils.melikbugraozcelik.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backend-dev-utils-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Release🐍](https://github.com/melikbugra/backend-dev-utils/actions/workflows/python-publish.yml/badge.svg?branch=main)](https://github.com/melikbugra/backend-dev-utils/actions/workflows/python-publish.yml)
  ![Coverage](https://backend-dev-utils.melikbugraozcelik.com/coverage.svg)



  Utility functions for Python backend developers.



  This project provides a collection of utility functions to assist backend developers in their daily tasks. It aims to simplify common operations and improve productivity.




  To install the package, use the following command:

  ```bash
  pip install backend-dev-utils
  ```



  Please see the [Documentation](https://backend-dev-utils.melikbugraozcelik.com/) for the usage and tutorials.



  Contributions are welcome! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request.



  This project is licensed under the [MIT License](LICENSE).


pkgId: 7a7e38abe9078e5bcefc8c99d62cc19d65458f002161fa4629d033ba1f206677
name: python-backend.ai-accelerator-cuda
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Backend.AI Accelerator Plugin for CUDA
url: https://backend.ai
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backend.ai-accelerator-cuda-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Just install this along with Backend.AI agents, using the same virtual environment.
  This will allow the agents to detect CUDA devices on their hosts and make them
  available to Backend.AI kernel sessions.
  ```console
  $ pip install backend.ai-accelerator-cuda
  ```
  This open-source edition of CUDA plugins support allocation of one or more CUDA
  devices to a container, slot-by-slot.


pkgId: c92e198bf3eeb3f712fe7c93b853e173b774b4b56c759e3bd0456c9d63326952
name: python-backend.ai-kernel-runner
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: User code executors for Backend.AI kernels
url: https://github.com/lablup/backend.ai-kernel-runner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backend.ai-kernel-runner-1.4.2-1.src.rpm
checksum_type: sha256
description:
  A common base runner for various programming languages.
  It manages an internal task queue so that multiple command/code execution requests
  are processed in the FIFO order, without garbling the console output.


pkgId: 09f88d7d8925b18eaa6e4f50cc103a2efd4ff8a98545e0cc5d05320d291459fb
name: python-backend.ai-krunner-static-gnu
arch: src
version: 4.3.0
epoch: 0
release: 1
summary: Backend.AI Kernel Runner based on GNU libc
url: https://backend.ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backend.ai-krunner-static-gnu-4.3.0-1.src.rpm
checksum_type: sha256
description:
  Backend.AI Kernel Runner Package for glibc-based Kernels

  This package contains a statically built Python distribution and 3rd-party libraries required to run
  [our krunner module](https://github.com/lablup/backend.ai/tree/main/src/ai/backend/kernel)
  inside containers whose images are provided by users.

  The krunner wheel itself can be installed into any Python environments (the content of this plugin
  package is agnostic to platforms and architectures as it's a mere declaration of the plugin
  interface), but we still apply the binary wheel platform tags so that setuptools could distinguish
  the target CPU architecture as follows:

  | Where is Backend.AI running? | What is the user container's base image? | The krunner wheel used |
  |------------------------------|------------------------------------------|------------------------|
  | manylinux (x86-64)           | manylinux (x86-64)                       | `backend.ai_krunner_static_gnu-X.X.X-py3-none-manylinux2014_x86_64.musllinux_1_1_x86_64.macosx_11_0_x86_64.whl` |
  | manylinux (x86-64)           | musllinux (x86-64)                       | `backend.ai_krunner_alpine-X.X.X-py3-none-manylinux2014_x86_64.musllinux_1_1_x86_64.macosx_11_0_x86_64.whl` |
  | manylinux (aarch64)          | manylinux (aarch64)                      | `backend.ai_krunner_static_gnu-X.X.X-py3-none-manylinux2014_aarch64.musllinux_1_1_aarch64.macosx_11_0_arm64.whl` |
  | manylinux (aarch64)          | musllinux (aarch64)                      | `backend.ai_krunner_alpine-X.X.X-py3-none-manylinux2014_aarch64.musllinux_1_1_aarch64.macosx_11_0_arm64.whl` |
  | musllinux (x86-64)           | manylinux (x86-64)                       | `backend.ai_krunner_static_gnu-X.X.X-py3-none-manylinux2014_x86_64.musllinux_1_1_x86_64.macosx_11_0_x86_64.whl` |
  | musllinux (x86-64)           | musllinux (x86-64)                       | `backend.ai_krunner_alpine-X.X.X-py3-none-manylinux2014_x86_64.musllinux_1_1_x86_64.macosx_11_0_x86_64.whl` |
  | musllinux (aarch64)          | manylinux (aarch64)                      | `backend.ai_krunner_static_gnu-X.X.X-py3-none-manylinux2014_aarch64.musllinux_1_1_aarch64.macosx_11_0_arm64.whl` |
  | musllinux (aarch64)          | musllinux (aarch64)                      | `backend.ai_krunner_alpine-X.X.X-py3-none-manylinux2014_aarch64.musllinux_1_1_aarch64.macosx_11_0_arm64.whl` |
  | macOS (x86-64)               | manylinux (x86-64)                       | `backend.ai_krunner_static_gnu-X.X.X-py3-none-manylinux2014_x86_64.musllinux_1_1_x86_64.macosx_11_0_x86_64.whl` |
  | macOS (x86-64)               | musllinux (x86-64)                       | `backend.ai_krunner_alpine-X.X.X-py3-none-manylinux2014_x86_64.musllinux_1_1_x86_64.macosx_11_0_x86_64.whl` |
  | macOS (aarch64)              | manylinux (aarch64)                      | `backend.ai_krunner_static_gnu-X.X.X-py3-none-manylinux2014_aarch64.musllinux_1_1_aarch64.macosx_11_0_arm64.whl` |
  | macOS (aarch64)              | musllinux (aarch64)                      | `backend.ai_krunner_alpine-X.X.X-py3-none-manylinux2014_aarch64.musllinux_1_1_aarch64.macosx_11_0_arm64.whl` |

  We named the krunner package based on musl 1.2 as "alpine" because practically Alpine linux is the
  only distribution which actively uses musl and it is currently not possible to build static CPython
  which can import 3rd-party dynamic modules on top of the musl ecosystem.



  This package is to distribute prebuilt binaries, so the source distribution does not have prebuilt
  binaries and does not work as intended.  Just refer this repository on how we build stuffs.



  * `{distro}` is a string like `static-gnu`, `alpine`, etc. depending on which repository you are in.
  * `{distro_}` is a string same to `{distro}` but with hyphens replaced with underscores for Python
    package names and paths. (e.g., `static_gnu`, `alpine`)



  ```console
  $ git clone https://github.com/lablup/backend.ai-krunner-{distro} krunner-{distro}
  $ cd krunner-{distro}
  $ pyenv virtualenv 3.12.2 venv-krunner  # you may share the same venv with other krunner projects
  $ pyenv local venv-krunner
  $ pip install -U pip setuptools
  $ pip install -U -r build/requirements.txt
  $ pip install -U -e .
  ```



  1. Modify Dockerfile and/or other contents.
    - To update the Python version, update `src/ai/backend/krunner/{distro_}/krunner-python.{distro}.txt`
      and the dockerfiles (both python and wheels) accordingly, including the
      `PYTHON_VERSION` environment variable and the download URL of the
      statically built Python distribution.
  2. Increment *the volume version number* specified as a label `ai.backend.krunner.version`
     in `src/ai/backend/krunner/{distro_}/krunner-env.{distro}.dockerfile`
  3. Run `scripts/build.py`.
  4. Repeat the above steps for each distro version. (For static builds, there is only one.)
  5. Increment *the package version number* in `src/ai/backend/krunner/{distro_}/__init__.py`
  6. `rm -r dist/* build/*` (skip if these directories do not exist and or are empty)
  7. Commit.
  8. Create a signed annotated tag and push the tag to let GitHub Action build and publish wheels.

  Note that `src/ai/backend/krunner/{distro_}/krunner-version.{distro}.txt` files are
  overwritten by the build script from the label.

  WARNING: We should choose [`x86_64_v2` binaries from the indygreg repository](https://gregoryszorc.com/docs/python-build-standalone/main/running.html)
  when updating the Python runtime version for CPU compatibility with some of our
  test setups and customer sites.



  [Use CentOS 7 or later and install this list of packages.](https://github.com/lablup/backend.ai-krunner-static-gnu/blob/master/compat-test.Dockerfile)
  Also [refer the test script](https://github.com/lablup/backend.ai-krunner-static-gnu/blob/main/scripts/test.sh).



  **⚠️ Warning: Use a x86-64 host to build ttyd, because:**
    - ttyd uses `musl` as their C stdlib, not `glibc`.
    - The `musl` toochain used by the build script is x86_64 binaries.

  `libwebsockets>=4.0.0` features auto ping/pong with 5 min default interval.
  (https://github.com/warmcat/libwebsockets#connection-validity-tracking) And,
  `ws_ping_pong_interval` of ttyd is not effective in `libwebsockets>=4.0.0`.
  This seems to be the reason why `ttyd>=1.6.1` does not set
  `ws_ping_pong_interval` for `libwebsockets>=4.0.0`.
  (https://github.com/tsl0922/ttyd/blob/master/src/server.c#L456)

  To fix this issue, we modify and build the latest version of `libwebsockets` used by the ttyd build script manually.

  ```console

  sudo apt-get update
  sudo apt-get install -y autoconf automake build-essential cmake curl file libtool


  git clone https://github.com/tsl0922/ttyd.git
  cd ttyd
  ```

  Now let's modify `./scripts/cross-build.sh`.
  Add these two lines under `pushd "${BUILD_DIR}/libwebsockets-${LIBWEBSOCKETS_VERSION}"`:
  ```sh
  sed -i 's/context->default_retry.secs_since_valid_ping = 300/context->default_retry.secs_since_valid_ping = 20/g' lib/core/context.c
  sed -i 's/context->default_retry.secs_since_valid_hangup = 310/context->default_retry.secs_since_valid_hangup = 30/g' lib/core/context.c
  ```

  Finally, build the `ttyd` binary.
  ```console

  ./scripts/cross-build.sh


  ./build/ttyd --version
  ```


pkgId: 99c982f4e2e37a2a9614fe28c2e4c4e2e2f3a17e05c6d734595a47b8ed5c89a7
name: python-backend1
arch: src
version: 1.0.15
epoch: 0
release: 1
summary: This a demo project
url: https://pypi.org/project/backend1/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backend1-1.0.15-1.src.rpm
checksum_type: sha256
description:
  backend1

  Bellow API calls

  1. hello_world
  2. route_hello_world
  3. signup
  4. login
  5. Added jwt authentication.


pkgId: 95284fad55ba8f38276d766b59f7a03ccc8d6d495164cdf83d8934da31990715
name: python-backendpy
arch: src
version: 0.2.8a1
epoch: 0
release: 1
summary: Async (ASGI) Python web framework
url: https://github.com/savangco/backendpy
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backendpy-0.2.8a1-1.src.rpm
checksum_type: sha256
description:
  ![alt text](https://github.com/savangco/backendpy/blob/master/assets/backendpy_logo_small.png?raw=true)


  Python web framework for building the backend of your project!

  Some features:
  * Asynchronous programming (ASGI-based projects)
  * Application-based architecture and the ability to install third-party applications in a project
  * Support of middlewares for different layers such as Application, Handler, Request or Response
  * Supports events and hooks
  * Data handler classes, including validators and filters to automatically apply to request input data
  * Supports a variety of responses including JSON, HTML, file and… with various settings such as stream, gzip and…
  * Router with the ability to define urls as Python decorator or as separate files
  * Application-specific error codes
  * Optional default database layer by the Sqlalchemy async ORM with management of sessions for the scope of each request
  * Optional default templating layer by the Jinja template engine
  * …


  Python 3.8+


  Documentation is available at https://backendpy.readthedocs.io.





  ```shell
  $ pip3 install backendpy
  ```
  Or use the following command to install optional additional libraries:
  ```shell
  $ pip3 install backendpy[full]
  ```
  You also need to install an ASGI server such as Uvicorn, Hypercorn or Daphne:
  ```shell
  $ pip3 install uvicorn
  ```



  *project/main.py*
  ```python
  from backendpy import Backendpy

  bp = Backendpy()
  ```



  *project/apps/hello/main.py*
  ```python
  from backendpy.app import App
  from .handlers import routes

  app = App(
      routes=[routes])
  ```
  *project/apps/hello/handlers.py*
  ```python
  from backendpy.router import Routes
  from backendpy.response import Text

  routes = Routes()

  @routes.get('/hello-world')
  async def hello(request):
      return Text('Hello World!')
  ```



  *project/config.ini*
  ```ini
  [networking]
  allowed_hosts =
      127.0.0.1:8000

  [apps]
  active =
      project.apps.hello
  ```



  Inside the project root path:
  ```shell
  $ uvicorn main:bp
  ```


  The basic structure of a project mentioned above can also be created by commands:
  ```shell
  $ backendpy create_project --name myproject
  ```
  To create a project with more complete sample components:
  ```shell
  $ backendpy create_project --name myproject --full
  ```
  Or to create an application:
  ```shell
  $ backendpy create_app --name myapp
  ```
  ```shell
  $ backendpy create_app --name myapp --full
  ```


pkgId: 0cccefc365eba1a92636aeef80da63edf2b720bf21101094fd8cfa09494477db
name: python-backends-matrix
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Structured matrices
url: https://github.com/wesselb/matrix
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backends-matrix-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/wesselb/matrix/workflows/CI/badge.svg?branch=master)](https://github.com/wesselb/matrix/actions?query=workflow%3ACI)
  [![Coverage Status](https://coveralls.io/repos/github/wesselb/matrix/badge.svg?branch=master&service=github)](https://coveralls.io/github/wesselb/matrix?branch=master)
  [![Latest Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://wesselb.github.io/matrix)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  Structured matrices



  See [the instructions here](https://gist.github.com/wesselb/4b44bf87f3789425f96e26c4308d0adc).
  Then simply

  ```bash
  pip install backends-matrix
  ```


  ```python
  >>> import lab as B

  >>> from matrix import Diagonal

  >>> d = Diagonal(B.rand(2, 3))  # A batch of diagonal marices

  >>> d
  <diagonal matrix: batch=(2,), shape=(3, 3), dtype=float64
   diag=[[0.427 0.912 0.622]
         [0.777 0.048 0.808]]>

  >>> 2 * d
  <diagonal matrix: batch=(2,), shape=(3, 3), dtype=float64
   diag=[[0.854 1.824 1.243]
         [1.553 0.096 1.616]]>

  >>> 2 * d + 1
  <Woodbury matrix: batch=(2,), shape=(3, 3), dtype=float64
   diag=<diagonal matrix: batch=(2,), shape=(3, 3), dtype=float64
         diag=[[0.854 1.824 1.243]
               [1.553 0.096 1.616]]>
   lr=<low-rank matrix: batch=(), shape=(3, 3), dtype=int64, rank=1
       left=[[1]
             [1]
             [1]]
       middle=<diagonal matrix: batch=(), shape=(1, 1), dtype=int64
               diag=[1]>>>

  >>> B.inv(2 * d + 1)
  <Woodbury matrix: batch=(2,), shape=(3, 3), dtype=float64
   diag=<diagonal matrix: batch=(2,), shape=(3, 3), dtype=float64
         diag=[[ 1.171  0.548  0.804]
               [ 0.644 10.386  0.619]]>
   lr=<low-rank matrix: batch=(2,), shape=(3, 3), dtype=float64, rank=1
       left=<dense matrix: batch=(2,), shape=(3, 1), dtype=float64
             mat=[[[ 1.171]
                   [ 0.548]
                   [ 0.804]]

                  [[ 0.644]
                   [10.386]
                   [ 0.619]]]>
       middle=<dense matrix: batch=(2,), shape=(1, 1), dtype=float64
               mat=[[[-0.284]]

                    [[-0.079]]]>
       right=<dense matrix: batch=(2,), shape=(3, 1), dtype=float64
              mat=[[[ 1.171]
                    [ 0.548]
                    [ 0.804]]

                   [[ 0.644]
                    [10.386]
                    [ 0.619]]]>>>

  >>> B.inv(B.inv(2 * d + 1))
  <Woodbury matrix: batch=(2,), shape=(3, 3), dtype=float64
   diag=<diagonal matrix: batch=(2,), shape=(3, 3), dtype=float64
         diag=[[0.854 1.824 1.243]
               [1.553 0.096 1.616]]>
   lr=<low-rank matrix: batch=(2,), shape=(3, 3), dtype=float64, rank=1
       left=<dense matrix: batch=(2,), shape=(3, 1), dtype=float64
             mat=[[[1.]
                   [1.]
                   [1.]]

                  [[1.]
                   [1.]
                   [1.]]]>
       middle=<dense matrix: batch=(2,), shape=(1, 1), dtype=float64
               mat=[[[1.]]

                    [[1.]]]>
       right=<dense matrix: batch=(2,), shape=(3, 1), dtype=float64
              mat=[[[1.]
                    [1.]
                    [1.]]

                   [[1.]
                    [1.]
                    [1.]]]>>>

  >>> B.inv(B.inv(2 * d + 1)) - 1
  <diagonal matrix: batch=(2,), shape=(3, 3), dtype=float64
   diag=[[0.854 1.824 1.243]
         [1.553 0.096 1.616]]>
  ```



  All matrix types are subclasses of `AbstractMatrix`.

  The following base types are provided:

  ```
  Zero
  Dense
  Diagonal
  Constant
  LowerTriangular
  UpperTriangular
  ```

  The following composite types are provided:
  ```
  LowRank
  Woodbury
  Kronecker
  TiledBlocks
  ```



  The following functions are added to LAB.
  They can be accessed with `B.<function>` where `import lab as B`.

  ```
  shape_broadcast(*elements)
  shape_batch(a, *indices)
  shape_batch_broadcast(*elements)
  shape_matrix(a, *indices)
  shape_matrix_broadcast(*elements)

  broadcast_batch_to(a, *batch)

  dense(a)
  fill_diag(a, diag_len)
  block(*rows)
  block_diag(*blocks)

  matmul_diag(a, b, tr_a=False, tr_b=False)

  pd_inv(a)
  schur(a)
  pd_schur(a)
  iqf(a, b, c)
  iqf_diag(a, b, c)

  ratio(a, c)
  root(a)

  sample(a, num=1)
  ```


pkgId: 72b6520222c3d29e8784a86b3d103ca62748980048ac9773f0b70bf47ab000e7
name: python-backframe
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Inspect the caller.
url: https://github.com/bswck/backframe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backframe-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/bswck/backframe/actions/workflows/test.yml/badge.svg)](https://github.com/bswck/backframe/actions/workflows/test.yml)
  [![Coverage](https://coverage-badge.samuelcolvin.workers.dev/bswck/backframe.svg)](https://coverage-badge.samuelcolvin.workers.dev/redirect/bswck/backframe)
  [![Documentation Status](https://readthedocs.org/projects/backframe/badge/?version=latest)](https://backframe.readthedocs.io/en/latest/?badge=latest)

  Inspect the caller.


  You might simply install it with pip:

  ```shell
  pip install backframe
  ```

  If you use [Poetry](https://python-poetry.org/), then you might want to run:

  ```shell
  poetry add backframe
  ```


  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![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)
  [![Pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  <!--
  This section was generated from skeleton-ci/skeleton-python@0.0.2rc-215-g792492f.
  Instead of changing this particular file, you might want to alter the template:
  https://github.com/skeleton-ci/skeleton-python/tree/0.0.2rc-215-g792492f/project/README.md.jinja
  -->
  > [!Note]
  > If you use Windows, it is highly recommended to complete the installation in the way presented below through [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install).
  1.  Fork the [backframe repository](https://github.com/bswck/backframe) on GitHub.

  1.  [Install Poetry](https://python-poetry.org/docs/#installation).<br/>
      Poetry is an amazing tool for managing dependencies & virtual environments, building packages and publishing them.
      You might use [pipx](https://github.com/pypa/pipx#readme) to install it globally (recommended):

      ```shell
      pipx install poetry
      ```

      <sub>If you encounter any problems, refer to [the official documentation](https://python-poetry.org/docs/#installation) for the most up-to-date installation instructions.</sub>

      Be sure to have Python 3.8 installed—if you use [pyenv](https://github.com/pyenv/pyenv#readme), simply run:

      ```shell
      pyenv install 3.8
      ```

  1.  Clone your fork locally and install dependencies.

      ```shell
      git clone https://github.com/your-username/backframe path/to/backframe
      cd path/to/backframe
      poetry env use $(cat .python-version)
      poetry install
      ```

      Next up, simply activate the virtual environment and install pre-commit hooks:

      ```shell
      poetry shell
      pre-commit install
      ```

  For more information on how to contribute, check out [CONTRIBUTING.md](https://github.com/bswck/backframe/blob/HEAD/CONTRIBUTING.md).<br/>
  Always happy to accept contributions! ❤️


  © Copyright by Bartosz Sławecki ([@bswck](https://github.com/bswck)).
  <br />This software is licensed under the terms of [MIT License](https://github.com/bswck/backframe/blob/HEAD/LICENSE).


pkgId: 867219873395d4090e4604eb984ab487fd20a9b2d7353b19662b5426ee77bb87
name: python-background
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: It does what it says it does.
url: https://github.com/kennethreitz/background
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-background-0.2.1-1.src.rpm
checksum_type: sha256
description:
  It runs stuff in the background.
      "An elegant decorator-based abstraction around Python 3's concurrent.futures ThreadPoolExecutor class"
      — Simon Willison
  This module makes it stupidly simple to run things in the background of your
  application, be it a CLI app, or a web app.


pkgId: 97d8fb769d7c1fad796911a325ddb0188f5e047cf7f75cf013c69b54120dcb5e
name: python-backgroundremover
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: Background remover from image and video using AI
url: https://github.com/nadermx/backgroundremover
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backgroundremover-0.2.8-1.src.rpm
checksum_type: sha256
description:
  ![Background Remover](https://raw.githubusercontent.com/nadermx/backgroundremover/main/examplefiles/backgroundremoverexample.png)
  <img alt="background remover video" src="https://raw.githubusercontent.com/nadermx/backgroundremover/main/examplefiles/backgroundremoverprocessed.gif" height="200" /><br>
  BackgroundRemover is a command line tool to remove background from [image](https://github.com/nadermx/backgroundremover#image) and [video](https://github.com/nadermx/backgroundremover#video) using AI, made by [nadermx](https://john.nader.mx) to power [https://BackgroundRemoverAI.com](https://backgroundremoverai.com). If you wonder why it was made read this [short blog post](https://johnathannader.com/my-first-open-source-project/).<br>




  * python >= 3.6
  * python3.6-dev #or what ever version of python you use
  * torch and torchvision stable version (https://pytorch.org)
  * ffmpeg 4.4+

  * To clarify, you must install both python and whatever dev version of python you installed. IE; python3.10-dev with python3.10 or python3.8-dev with python3.8



  Go to https://pytorch.org and scroll down to `INSTALL PYTORCH` section and follow the instructions.

  For example:

  ```
  PyTorch Build: Stable (1.7.1)
  Your OS: Windows
  Package: Pip
  Language: Python
  CUDA: None
  ```

  To install ffmpeg and python-dev

  ```
  sudo apt install ffmpeg python3.6-dev
  ```


  To Install backgroundremover, install it from pypi

  ```bash
  pip install --upgrade pip
  pip install backgroundremover
  ```
  Please note that when you first run the program, it will check to see if you have the u2net models, if you do not, it will pull them from this repo

  It is also possible to run this without installing it via pip, just clone the git to local start a virtual env and install requirements and run
  ```bash
  python -m backgroundremover.cmd.cli -i "video.mp4" -mk -o "output.mov"
  ```
  and for windows
  ```bash
  python.exe -m backgroundremover.cmd.cli -i "video.mp4" -mk -o "output.mov"
  ```

  ```bash
  git clone https://github.com/nadermx/backgroundremover.git
  cd backgroundremover
  docker build -t bgremover .
  alias backgroundremover='docker run -it --rm -v "$(pwd):/tmp" bgremover:latest'
  ```



  Remove the background from a local file image

  ```bash
  backgroundremover -i "/path/to/image.jpeg" -o "output.png"
  ```



  Sometimes it is possible to achieve better results by turning on alpha matting. Example:

  ```bash
  backgroundremover -i "/path/to/image.jpeg" -a -ae 15 -o "output.png"
  ```
  change the model for different background removal methods between `u2netp`, `u2net`, or `u2net_human_seg`
  ```bash
  backgroundremover -i "/path/to/image.jpeg" -m "u2net_human_seg" -o "output.png"
  ```




  ```bash
  backgroundremover -i "/path/to/video.mp4" -tv -o "output.mov"
  ```

  ```bash
  backgroundremover -i "/path/to/video.mp4" -tov "/path/to/videtobeoverlayed.mp4" -o "output.mov"
  ```

  ```bash
  backgroundremover -i "/path/to/video.mp4" -toi "/path/to/videtobeoverlayed.mp4" -o "output.mov"
  ```




  ```bash
  backgroundremover -i "/path/to/video.mp4" -tg -o "output.gif"
  ```


  Make a matte file for premiere

  ```bash
  backgroundremover -i "/path/to/video.mp4" -mk -o "output.matte.mp4"
  ```



  Change the framerate of the video (default is set to 30)

  ```bash
  backgroundremover -i "/path/to/video.mp4" -fr 30 -tv -o "output.mov"
  ```

  Set total number of frames of the video (default is set to -1, ie the remove background from full video)

  ```bash
  backgroundremover -i "/path/to/video.mp4" -fl 150 -tv -o "output.mov"
  ```

  Change the gpu batch size of the video (default is set to 1)

  ```bash
  backgroundremover -i "/path/to/video.mp4" -gb 4 -tv -o "output.mov"
  ```

  Change the number of workers working on video (default is set to 1)

  ```bash
  backgroundremover -i "/path/to/video.mp4" -wn 4 -tv -o "output.mov"
  ```
  change the model for different background removal methods between `u2netp`, `u2net`, or `u2net_human_seg` and limit the frames to 150
  ```bash
  backgroundremover -i "/path/to/video.mp4" -m "u2net_human_seg" -fl 150 -tv -o "output.mov"
  ```




  ```
  from backgroundremover.bg import remove
  def remove_bg(src_img_path, out_img_path):
      model_choices = ["u2net", "u2net_human_seg", "u2netp"]
      f = open(src_img_path, "rb")
      data = f.read()
      img = remove(data, model_name=model_choices[0],
                   alpha_matting=True,
                   alpha_matting_foreground_threshold=240,
                   alpha_matting_background_threshold=10,
                   alpha_matting_erode_structure_size=10,
                   alpha_matting_base_size=1000)
      f.close()
      f = open(out_img_path, "wb")
      f.write(img)
      f.close()
  ```



  - convert logic from video to image to utilize more GPU on image removal
  - clean up documentation a bit more
  - add ability to adjust and give feedback images or videos to datasets
  - add ability to realtime background removal for videos, for streaming
  - finish flask server api
  - add ability to use other models than u2net, ie your own
  - other



  Accepted



  Give a link to our project [BackgroundRemoverAI.com](https://backgroundremoverai.com) or this git, telling people that you like it or use it.



  We made it our own package after merging together parts of others, adding in a few features of our own via posting parts as bounty questions on superuser, etc.  As well as asked on hackernews earlier to open source the image part, so decided to add in video, and a bit more.





  - https://arxiv.org/pdf/2005.09007.pdf
  - https://github.com/NathanUA/U-2-Net
  - https://github.com/pymatting/pymatting
  - https://github.com/danielgatis/rembg
  - https://github.com/ecsplendid/rembg-greenscreen
  - https://superuser.com/questions/1647590/have-ffmpeg-merge-a-matte-key-file-over-the-normal-video-file-removing-the-backg
  - https://superuser.com/questions/1648680/ffmpeg-alphamerge-two-videos-into-a-gif-with-transparent-background/1649339?noredirect=1#comment2522687_1649339
  - https://superuser.com/questions/1649817/ffmpeg-overlay-a-video-after-alphamerging-two-others/1649856#1649856



  - Copyright (c) 2021-present [Johnathan Nader](https://github.com/nadermx)
  - Copyright (c) 2020-present [Lucas Nestler](https://github.com/ClashLuke)
  - Copyright (c) 2020-present [Dr. Tim Scarfe](https://github.com/ecsplendid)
  - Copyright (c) 2020-present [Daniel Gatis](https://github.com/danielgatis)

  Code Licensed under [MIT License](./LICENSE.txt)
  Models Licensed under [Apache License 2.0](./models/license)


pkgId: 1c4fff5b87cd929e9e0ce40ee500e10e0e907af8fbe517b1e8c342dd18e17189
name: python-backlooper
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Backlooper.app is a looper that allows you to decide to loop a few bars after you played them
url: https://github.com/spmvg/backlooper_backend
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backlooper-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [Backlooper.app](https://backlooper.app) loops audio without having to trigger beforehand.
  Audio is always being recorded.
  The last few bars will be played back if you select a track at approximately the first beat of the next bar.

  For user documentation, please see [here](https://backlooper.app/docs/general).

  For developer documentation, please continue reading.
  More developer documentation is provided [here](https://backlooper.readthedocs.io/en/latest/).

  The frontend code is provided [here](https://github.com/spmvg/backlooper_frontend).


  Install the backend locally:

  ```commandline
  python -m pip install -e .
  ```

  Run the backend:

  ```commandline
  python -m backlooper
  ```

  Generate developer documentation locally:

  ```commandline
  sphinx-build -M html docs build
  ```


pkgId: d2654967e66d30f604bb9b99af9a133822e10521a19186459f705fa64f4fb99b
name: python-backoff
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Function decoration for backoff and retry
url: https://github.com/litl/backoff
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backoff-2.2.1-1.src.rpm
checksum_type: sha256
description:
  **Function decoration for backoff and retry**
  This module provides function decorators which can be used to wrap a
  function such that it will be retried until some condition is met. It
  is meant to be of use when accessing unreliable resources with the
  potential for intermittent failures i.e. network resources and external
  APIs. Somewhat more generally, it may also be of use for dynamically
  polling resources for externally generated content.
  Decorators support both regular functions for synchronous code and
  `asyncio <https://docs.python.org/3/library/asyncio.html>`__'s coroutines
  for asynchronous code.


pkgId: baee7748d1d89f998226ce466f428629dd8002f8c477974c92d2364cd59ea756
name: python-backoff-async
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Function decoration for backoff and retry async functions
url: https://github.com/a.sk/backoff-async
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backoff-async-2.0.0-1.src.rpm
checksum_type: sha256
description:
  **Function decoration for backoff and retry**
  This module provides function decorators which can be used to wrap a
  function such that it will be retried until some condition is met. It
  is meant to be of use when accessing unreliable resources with the
  potential for intermittent failures i.e. network resources and external
  APIs. Somewhat more generally, it may also be of use for dynamically
  polling resources for externally generated content.


pkgId: 725d7485a19dc4a496acf68ff673f72063f1e4c871a9ec97e4849af6fbe340c8
name: python-backoff-stubs
arch: src
version: 1.11.1.post1
epoch: 0
release: 1
summary: External type annotations for the backoff library
url: https://github.com/gleb-chipiga/backoff-stubs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backoff-stubs-1.11.1.post1-1.src.rpm
checksum_type: sha256
description:
  This repository contains external type annotations (see `PEP 484 <https://www.python.org/dev/peps/pep-0484/>`_) for the `backoff <https://github.com/litl/backoff>`_ library.


pkgId: 09ca06a8987ba236186831c577e47661f91d845ea4d1a13f59c510d8a0506e73
name: python-backpack
arch: src
version: 0.1
epoch: 0
release: 1
summary: Useful utilities for Python.
url: https://github.com/sdispater/backpack
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backpack-0.1-1.src.rpm
checksum_type: sha256
description:
  The ``Collection`` class provides a fluent, convenient wrapper for working with list  of data.
  To instantiatte a ``Collection`` you can also use the ``collection()`` helper.
  Available Methods
  *****************
  For the remainder of this documentation, we'll discuss each method available on the ``Collection`` class.
  Remember, all of these methods may be chained for fluently manipulating the underlying list or dict.
  Furthermore, almost every method returns a new ``Collection`` instance,
  allowing you to preserve the original copy of the collection when necessary.
  You may select any method from this table to see an example of its usage:
  * all_
  * avg_
  * chunk_
  * collapse_
  * contains_
  * count_
  * diff_
  * each_
  * every_
  * filter_
  * first_
  * flatten_
  * forget_
  * for_page_
  * get_
  * implode_
  * is_empty_
  * last_
  * map_
  * merge_
  * pluck_
  * pop_
  * prepend_
  * pull_
  * push_
  * put_
  * reduce_
  * reject_
  * reverse_
  * serialize_
  * shift_
  * sort_
  * sum_
  * take_
  * to_json_
  * transform_
  * unique_
  * where_
  * zip_
  Methods Listing
  ***************


pkgId: dede2b0f1b9e5bc98b28d94a84372f4b710ddc072c9afdd50c219d3076948314
name: python-backpack-api
arch: src
version: 0.0.15
epoch: 0
release: 1
summary: Backpack REST API python implementation
url: https://pypi.org/project/backpack-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backpack-api-0.0.15-1.src.rpm
checksum_type: sha256
description:
  [![My Channel 🥰](https://img.shields.io/badge/My_Channel_🥰-0A66C2?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/web3_enjoyer_club)

  This is an unofficial Python SDK for the [Backpack exchange](https://backpack.exchange/refer/binance) REST API. Please note that I am not affiliated with Backpack, and you should use this library at your own risk.



  To install the [BackPack library](https://pypi.org/project/backpack-api/), run the following command:

  ```bash
  pip install backpack-api
  ```



  You can find the source code for this library on GitHub:

  [![Source Code](https://img.shields.io/badge/Source_Code-GitHub-white?style=for-the-badge&logo=github)](https://github.com/MsLolita/pybackpack)



  For the official documentation of the Backpack API (not the SDK), please visit:

  [![Official Documentation](https://img.shields.io/badge/Official_Documentation-Backpack_Exchange-red?style=for-the-badge)](https://docs.backpack.exchange/)



  If you'd like to see the library in action, please check out the [examples](https://github.com/MsLolita/pybackpack/tree/master/examples) provided.

  (Optional) Proxy in format: http://username:password@proxy_ip:proxy_port



  Before you start using the library, please follow these steps:

  1. Register an account with [Backpack](https://backpack.exchange/refer/binance).
  2. Generate an [API Key](https://backpack.exchange/settings/api-keys) and assign the necessary permissions.



  This project is licensed under the MIT License.

  [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)


pkgId: a05f89e2efda3f25ef6349164fefa0da6440b225a2199f704aa744a5c7a04d23
name: python-backpack-exchange-sdk
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: A simple SDK for backpack exchange
url: https://github.com/solomeowl/backpack_exchange_sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backpack-exchange-sdk-0.3.2-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/backpack-exchange-sdk?)


  The Backpack Exchange SDK provides a convenient interface for interacting with the Backpack Exchange API. It includes two main clients: `AuthenticationClient` for authenticated endpoints and `PublicClient` for public endpoints.



  - **Authentication Client**: Interact with authenticated endpoints for managing capital, historical data, and orders.
  - **Public Client**: Access public market data, system status, and public trade data.



  The SDK can be installed directly using pip:

  ```bash
  pip3 install backpack_exchange_sdk
  ```

  Alternatively, you can clone the repository and install the SDK manually:

  ```bash
  git clone https://github.com/solomeowl/backpack_exchange_sdk.git
  cd backpack_exchange_sdk
  pip3 install .
  ```



  ```python
  from backpack_exchange_sdk.authenticated import AuthenticationClient

  client = AuthenticationClient('<YOUR_API_KEY>', '<YOUR_SECRET>')


  balances = client.get_balances()
  print(balances)


  response = client.request_withdrawal('xxxxaddress', 'Solana', '0,1', 'Sol')
  print(response)

  ```

  ```python
  from backpack_exchange_sdk.public import PublicClient

  public_client = PublicClient()


  assets = public_client.get_assets()
  print(assets)


  ticker = public_client.get_ticker('SOL_USDC')
  print(ticker)

  ```


  For more detailed information about the API endpoints and their usage, refer to the [Backpack Exchange API documentation](https://docs.backpack.exchange/).



  If this SDK has been helpful to you 🌟 and you haven't signed up for Backpack Exchange yet, please consider using the following referral link to register: [Register on Backpack Exchange](https://backpack.exchange/refer/solomeowl) 🚀.

  Using this referral link is a great way to support this project ❤️, as it helps to grow the community and ensures the continued development of the SDK. 🛠️


pkgId: 43ca06960d1243413840c5aa640b543691c355b939f0fa13263d2d0293b2cadf
name: python-backpack-for-pytorch
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: BackPACK: Packing more into backprop
url: https://github.com/f-dangel/backpack
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backpack-for-pytorch-1.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Travis](https://travis-ci.org/f-dangel/backpack.svg?branch=master)](https://travis-ci.org/f-dangel/backpack)
  [![Coveralls](https://coveralls.io/repos/github/f-dangel/backpack/badge.svg?branch=master)](https://coveralls.io/github/f-dangel/backpack)
  [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/release/python-370/)

  BackPACK is built on top of [PyTorch](https://github.com/pytorch/pytorch). It efficiently computes quantities other than the gradient.

  - **Website:** https://backpack.pt
  - **Documentation:** https://docs.backpack.pt/en/master/
  - **Bug reports & feature requests:** https://github.com/f-dangel/backpack/issues

  Provided quantities include:
  - Individual gradients from a mini-batch
  - Estimates of the gradient variance or second moment
  - Approximate second-order information (diagonal and Kronecker approximations)

  **Motivation:** Computation of most quantities is not necessarily expensive (often just a small modification of the existing backward pass where backpropagated information can be reused). But it is difficult to do in the current software environment.



  ```bash
  pip install backpack-for-pytorch
  ```


  - [Basic usage](https://docs.backpack.pt/en/master/basic_usage/example_all_in_one.html)
  - [Some use cases](https://docs.backpack.pt/en/master/use_cases/index.html)



  BackPACK is actively being developed.
  We are appreciating any help.
  If you are considering to contribute, do not hesitate to contact us.
  An overview of the development procedure is provided in the [developer `README`](https://github.com/f-dangel/backpack/blob/master/README-dev.md).


  If you are using BackPACK, consider citing the [paper](https://openreview.net/forum?id=BJlrF24twB)
  ```
  @inproceedings{dangel2020backpack,
      title     = {Back{PACK}: Packing more into Backprop},
      author    = {Felix Dangel and Frederik Kunstner and Philipp Hennig},
      booktitle = {International Conference on Learning Representations},
      year      = {2020},
      url       = {https://openreview.net/forum?id=BJlrF24twB}
  }
  ```


pkgId: 871355022a8b2526b4927f95e7e734cd7c46e9c4106f6ad5c56df0d5f0fa6ac6
name: python-backplane
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: a dead-simple backplane for Dockerized applications
url: https://pypi.org/project/backplane/
rpm_license: LICENSE.md
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backplane-0.9.0-1.src.rpm
checksum_type: sha256
description:
  > 🚀 Check out our [Examples](examples) section for quick-start templates for [Wordpress](examples/wordpress), [Sonarqube](examples/sonarqube) and more
  ```bash
  pip install backplane
  backplane init
  backplane up
  ```
  You can now visit the dashboards of [Traefik](https://doc.traefik.io/traefik/) and [Portainer](https://www.portainer.io/) in your browser:
  - [traefik.127-0-0-1.ns0.co](http://traefik.127-0-0-1.ns0.co)
  - [portainer.127-0-0-1.ns0.co](http://portainer.127-0-0-1.ns0.co)

  Exposing one of your services through **backplane** is easy:
  - add it to the `backplane` Docker network
  - add a label `backplane.enabled` with value `true`
  **backplane** will automatically pick up the service's name (e.g. `whoami`) and exposes it as a subdomain of your **backplane domain** (defaults to `127-0-0-1.ns0.co`).
  > **NOTE**: this assumes that your service is accessible on port 80 inside the container. If that is NOT the case, see [Advanced configuration](#-advanced-configuration)
  ```yaml
  version: "3.3"
  services:
    whoami:
      image: "traefik/whoami"
      container_name: "whoami"
      networks:
        - backplane
      labels:
        - "backplane.enabled=true"
  networks:
    backplane:
      external: true
  ```
  Your service will be exposed as [http://whoami.127-0-0-1.ns0.co](http://whoami.127-0-0-1.ns0.co).

  Use `--https` and add a mail address for LetsEncrypt on installation to enable additional security for your applications. An optional `--domain` can be set on installation (defaults to `$SERVER_IP.ns0.co`, e.g. `193-43-54-23.ns0.co` if `--https` is set).
  ```bash
  backplane init --https --mail letsencrypt@mydomain.com [--domain mydomain.com]
  backplane up
  ```
  This enables the following additional features:
  - access your Docker Compose services as subdomains of `mydomain.com`
  - automatic SSL for your Docker Compose services through LetsEncrypt (HTTP-Validation, so this doesn't work on your developer machine unless you deal with the necessary port-forwardings)
  - automatic HTTP to HTTPS redirect
  - sane security defaults
  The Docker Compose stack definition doesn't change from the one without `--https`. **backplane** deals with the necessary configuration.
  ```yaml
  version: "3.3"
  services:
    whoami:
      image: "traefik/whoami"
      container_name: "whoami"
      networks:
        - backplane
      labels:
        - "backplane.enabled=true"
  networks:
    backplane:
      external: true
  ```
  Your container will be exposed as [https://whoami.mydomain.com](https://whoami.mydomain.com).

  The default username for authentication with backplane services is `admin`, the default password is `backplane`.
  Assuming you don't want to roll with the defaults when running **backplane** on a public server, you can add `--user` and `--password` to the `init` command to specify your own values.
  ```bash
  backplane init --https --user testuser --password testpassword
  ```

  Traefik comes with a [BasicAuth Middleware](https://doc.traefik.io/traefik/middlewares/basicauth/) that you can use to protect your services with the username and password configured above. All you need to do is to activate the Traefik middleware for your service:
  ```yaml
  version: "3.3"
  services:
    whoami:
      image: "traefik/whoami"
      container_name: "whoami"
      networks:
        - backplane
      labels:
        - "backplane.enabled=true"
        - "traefik.http.routers.whoami.middlewares=auth@docker"
  networks:
    backplane:
      external: true
  ```
  When initalized with `--https`, authentication will be activated for Traefik and Portainer automatically.

  > **NOTE**: this is still WIP and subject to change. We try to provide an unopinonated wrapper around docker-compose with a few "augmentations" that is fully compatible with **standard** Docker Compose stacks. We also plan to integrate with Portainer's templating system to make installing applications even easier.
  **backplane** offers multiple ways to launch your applications. They all expect your application to live inside a repository (i.e. a directory). **backplane** can deploy from a plain directory or local and remote git repositories.
  **backplane** implements a simple workflow around `docker-compose` to "install" your applications to a Docker engine it has access to. Basically **backplane** does this:
  - load variables from `.env`
  - augment with global configuration (i.e. `BACKPLANE_DOMAIN=127-0-0-1.ns0.co`)
  - use `--build` if necessary (i.e. if there's a `build:` section in `docker-compose.yml`)
  - run `docker-compose up -d`
  **backplane** (as of now) does not take care of the lifecycle of the application. To interface with it, use the bundled Portainer to manage your application from a UI or fall back to standard docker/docker-compose tooling.
  Installed applications will be saved to your local **backplane** config (default: `~/.backplane/contexts/default/backplane.yml`).
  An application that can be installed with **backplane** should contain:
  - a `docker-compose.yml` file
  - an optional `.env` file configuring your stack
  - the application code
  - an optional `Dockerfile` to build the application (**backplane** expects the `build:` section of the `docker-compose.yml` file to be correctly configured)
  Here are a few examples:
  - [Grafana Loki](https://github.com/backplane-apps/loki)
  - [Docker Registry](https://github.com/backplane-apps/registry)
  - [backplane itself](https://github.com/wearep3r/backplane)

  **backplane** can deploy an application directly from its repository directory. Assuming your application provides the necessary files, just run the following command from within your application directory:
  ```bash
  backplane install
  ```
  Optional arguments:
  - `--name`: the name of your application (translates to the `docker-compose` project, i.e. `-p NAME`); defaults to the name of the application directory (i.e. `$PWD`)
  - `--to` (or `-t`): the destination path of your application; defaults to the current directory (i.e. `$PWD`)
  - `--from` (or `-f`): a git repository, directory or URL where **backplane** can find the application; defaults to the current directory
  - `--compose-file` (or `-c`): the compose file to be used for installation (defaults to `docker-compose.yml`)
  - `app name`: if specified, **backplane** ignores the `path` argument and tries to install the application by cloning the repository from the given source to `~/.backplane/contexts/default/apps/$NAME`, where `$NAME` equals to the `NAME` argument (if given) or defaults to the name of the git repository

  **local directory, custom name**:
  ```bash
  backplane install --name my-awesome-app-beta --from $HOME/development/my-awesome-app
  ```
  - sets the application name to `my-awesome-app-beta`
  - installs the application from `$HOME/development/my-awesome-app`
  **remote git repository, default name**:
  ```bash
  backplane install --from https://github.com/backplane-apps/registry
  ```
  - clones `https://github.com/backplane-apps/registry` to `~/.backplane/contexts/default/apps/registry`
  - installs the application from `~/.backplane/contexts/default/apps/registry`
  **local git repository, default name**:
  ```bash
  backplane install --from $HOME/development/my-awesome-app
  ```
  - clones `$HOME/development/my-awesome-app` to `~/.backplane/contexts/default/apps/my-awesome-app`
  - installs the application from `~/.backplane/contexts/default/apps/my-awesome-app`
  This mechanism is used by the `backplane` service running alongside Traefik and Portainer. This service enables you to `git push` to your **backplane**. Read more about this in the next section.
  **backplane app registry, default name**:
  We're building a central registry for backplane-comtatible applications on [GitHub](https://github.com/backplane-apps). Installing one of those is as easy as running:
  ```bash
  backplane install loki
  ```
  - clones `https://github.com/backplane-apps/loki` to `~/.backplane/contexts/default/apps/loki`
  - installs the application from `~/.backplane/contexts/default/apps/loki`
  Our plan is to keep these apps compatible to Portainer's templating system to make them available as one-click installations from within the Portainer UI. One issue we currently face with this is that Portainer templates are only compatible with docker-compose configuration version "2".

  **backplane** contains a small Git Repository service with a dead-simple CI/CD workflow for your applications. The following section explains how to push your code to a remote **backplane** where it then will be automatically built and deployed according to the workflows described in the previous sections.
  This might also make sense on local development machines, but is primarily meant as a method to deploy your applications to remote **backplane** hosts in a safe way. For the following parts we assume that you have a server somewhere in the internet that you have access to via SSH (public-key authentication) and you want to use **backplane** to deploy and run your Docker Compose services on that server.
  Let's assume our remote **backplane** has the following attributes:
  - ip: 1.2.3.4
  - backplane-domain: 1-2-3-4.ns0.co
  - https: enabled
  > **ATTENTION**: the Git Repository service uses `~/.ssh` of the user that initialized **backplane** (i.e. `backplane init`) to determine the `authorized_keys` that are eligible to push to **backplane** via git. Make sure to add all relevant public keys to `~/.ssh/authorized_keys` on your **backplane** host
  > **TIP**: `cat ~/.ssh/id_rsa.pub | pbcopy` copies your SSH public key to your clipboard

  Add the following to your local `~/.ssh/config` file. This allows you to reach your remote **backplane** under `backplane` without further configuration.
  ```bash
  Host backplane
      HostName 1.2.3.4
      User backplane
      Port 2222
  ```
  **Wrapup**:
  - our remote **backplane** (on 1.2.3.4) is now available as `backplane` when connecting with ssh
  - **backplane** runs on port 2222; ports ins git remote-urls can cause problems which is why we *mask* port and ip behind the `backplane` hostname
  > **NOTE**: replace the value of "HostName" with your server's IP or hostname. For convenience, we're using [ns0](https://ns0.co) here to provide wildcard DNS on IP basis

  Assuming your application repository is called `whoami`, this is how you add your remote **backplane** to your git remotes:
  ```bash
  git remote add origin "git@backplane:whoami"
  ```
  **Wrapup**:
  - our previously configured remote **backplane** becomes our new git remote-url
  - we're connecting as user `git`
  - our repository on the remote it called `whoami`

  > **HINT**: as you see, we're using the [Conventional Commit](https://www.conventionalcommits.org/en/v1.0.0/) format here. This will likely be a part of backplane's future roadmap in the form of automated versioning based on commits. Just FYI.
  ```bash
  git commit -am "feat: figured out who I am"
  git push backplane master
  ```
  That's it! **backplane** will build and deploy your application and expose it automatically as `https://whoami.1-2-3-4.ns0.co`.

  **backplane** consists of 3 main services running as Docker containers on your host:
  - [Traefik](https://doc.traefik.io/traefik/), a very popular, cloud-native reverse-proxy
  - [Portainer](https://www.portainer.io/), a very popular management interface for Docker
  - [backplane](https://github.com/wearep3r/backplane), this software
  It aims to provide simple access to core prerequisites of modern app development:
  - Endpoint exposure
  - Container management
  - Deployment workflows
  To develop and run modern web-based applications you need a few core ingredients, like a reverse-proxy handling request routing, a way to manage containers and a way to deploy your code. **backplane** offers this for local development as well as on production nodes in a seemless way.
  **backplane** makes it easy to bypass long CI pipelines and deploy your application to a remote backplane host with ease.
  **backplane** is mainly aimed at small to medium sized development teams or solo-developers that don't require complex infrastructure. Use it for rapid prototyping or simple deployment scenarios where the full weight of modern CI/CD and PaaS offerings just isn't bearable.
  You can migrate from local development to production with a simple `git push` when using **backplane** on both ends. Think of it as a micro-PaaS that you can use locally.

  - a PaaS solution; backplane only provides a well-configured reverse-proxy and a management interface for containers
  - meant for production use. You can, though, but at your own risk

  **backplane** is only a thin wrapper around Traefik and Portainer. If you require more complex routing scenarios or have more complex service setups (e.g. multiple domains per container), simply use Traefik's label-based configuration.
  [Read more](https://doc.traefik.io/traefik/) in the docs.

  **backplane** expects your services to listen to port 80 inside their containers. If that is not the case, you need to tell the backplane about it. Add the following additional labels to tell backplane your service is accessible on port 9000:
  ```yaml
  labels:
    - backplane.enabled=true
    - "traefik.http.services.custom-http.loadbalancer.server.port=9000"
  ```

  In the [examples](examples) directory you'll find examples showing how to integrate backplane with your existing services
  Change to any of the example folders and run `backplane install`. The example's `README` will hold additional information on how to use it.


  ```bash
  pip install poetry
  poetry shell
  poetry install
  ```

  ```bash
  poetry build
  ```

  ```bash
  docker build --build-arg BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ') --build-arg BUILD_VERSION=$(backplane --version) --build-arg VCS_REF=$(git rev-parse --short HEAD) -t wearep3r/backplane .
  docker tag wearep3r/backplane wearep3r/backplane:$(backplane --version)
  docker push wearep3r/backplane:$(backplane --version)
  docker tag wearep3r/backplane wearep3r/backplane:latest
  docker push wearep3r/backplane:latest
  ```

  ```bash
  docker buildx ls
  docker buildx create --name wearep3r --use
  docker buildx inspect --bootstrap
  docker buildx build --platform linux/amd64,linux/arm64
  ```

  ```bash
  semantic-release version
  ```

  ```bash
  semantic-release publish
  ```

  Fabian Peter, [p3r.](https://www.p3r.one/)


pkgId: 73d70a4606c65103ffb179a26c40a07b7b218919a6abdb1ce1a5e5c2e75ed0ef
name: python-backports-datetime-fromisoformat
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Backport of Python 3.11's datetime.fromisoformat
url: https://github.com/movermeyer/backports.datetime_fromisoformat
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backports-datetime-fromisoformat-2.0.2-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2018 Michael Overmeyer  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: 89321cdc2d3b974e1f86b48f26f70501e75e30013ede4122c6fc51c0f0249569
name: python-backports.shutil-copytree
arch: src
version: 0.0.1.0
epoch: 0
release: 1
summary: backports shutil copytree (mainly for Python2)
url: https://github.com/cielavenir/backports.shutil_copytree
rpm_license: PSF
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backports.shutil-copytree-0.0.1.0-1.src.rpm
checksum_type: sha256
description:
  ```py
  try:
      from inspect import signature
  except ImportError:
      try:
          from funcsigs import signature
      except ImportError:
          signature = None

  from shutil import copytree
  if 'dirs_exist_ok' not in signature(copytree).parameters:
      from backports.shutil_copytree import copytree
  ```



  - symlink stat is not copied when Python<3.3
  - directory junctions check on Windows Python<3.8 is done via pywin32, which is less-tested.


pkgId: 4d2b4cc98cbd76cad2b66425f0fd32adb46758032630a98a4c4aa51a6fb10574
name: python-backports.shutil_get_terminal_size
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A backport of the get_terminal_size function from Python 3.3's shutil.
url: https://github.com/chrippa/backports.shutil_get_terminal_size
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backports.shutil_get_terminal_size-1.0.0-1.src.rpm
checksum_type: sha256
description:
  A backport of the `get_terminal_size`_ function from Python 3.3's shutil.
  Unlike the original version it is written in pure Python rather than C,
  so it might be a tiny bit slower.


pkgId: 63ccff62a01e0388f22f53ea782041956994490fa61c06df6e82de57874c6f5b
name: python-backports.shutil_which
arch: src
version: 3.5.2
epoch: 0
release: 1
summary: Backport of shutil.which from Python 3.3
url: https://github.com/minrk/backports.shutil_which
rpm_license: Python Software Foundation License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backports.shutil_which-3.5.2-1.src.rpm
checksum_type: sha256
description:
  Use Python 3 shutil.which on Python 2::

      try:
          from shutil import which
      except ImportError:
          from backports.shutil_which import which


pkgId: e88de4b8e2dc597a6b02e5526188753a9c4fe82d91cc817eb3e99916933b2607
name: python-backports.ssl_match_hostname
arch: src
version: 3.7.0.1
epoch: 0
release: 1
summary: The ssl.match_hostname() function from Python 3.5
url: http://bitbucket.org/brandon/backports.ssl_match_hostname
rpm_license: Python Software Foundation License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backports.ssl_match_hostname-3.7.0.1-1.src.rpm
checksum_type: sha256
description:
  The Secure Sockets Layer is only actually *secure*
  if you check the hostname in the certificate returned
  by the server to which you are connecting,
  and verify that it matches to hostname
  that you are trying to reach.
  But the matching logic, defined in `RFC2818`_,
  can be a bit tricky to implement on your own.
  So the ``ssl`` package in the Standard Library of Python 3.2
  and greater now includes a ``match_hostname()`` function
  for performing this check instead of requiring every application
  to implement the check separately.
  This backport brings ``match_hostname()`` to users
  of earlier versions of Python.
  Simply make this distribution a dependency of your package,
  and then use it like this::
      from backports.ssl_match_hostname import match_hostname, CertificateError
      [...]
      sslsock = ssl.wrap_socket(sock, ssl_version=ssl.PROTOCOL_SSLv23,
                                cert_reqs=ssl.CERT_REQUIRED, ca_certs=...)
      try:
          match_hostname(sslsock.getpeercert(), hostname)
      except CertificateError, ce:
  Brandon Craig Rhodes is merely the packager of this distribution;
  the actual code inside comes from Python 3.7 with small changes for
  portability.


pkgId: 01dfd4882618b8841b23f5fd1c92798ae6e20ee85f8d91b6269c50ed3f5434cc
name: python-backports.tarfile
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Backport of CPython tarfile module
url: https://github.com/jaraco/backports.tarfile
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backports.tarfile-1.2.0-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/backports.tarfile.svg
     :target: https://pypi.org/project/backports.tarfile

  .. image:: https://img.shields.io/pypi/pyversions/backports.tarfile.svg

  .. image:: https://github.com/jaraco/backports.tarfile/actions/workflows/main.yml/badge.svg
     :target: https://github.com/jaraco/backports.tarfile/actions?query=workflow%3A%22tests%22
     :alt: tests

  .. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
      :target: https://github.com/astral-sh/ruff
      :alt: Ruff

  .. .. image:: https://readthedocs.org/projects/backportstarfile/badge/?version=latest
  ..    :target: https://backportstarfile.readthedocs.io/en/latest/?badge=latest

  .. image:: https://img.shields.io/badge/skeleton-2024-informational
     :target: https://blog.jaraco.com/skeleton


pkgId: 2c374d7f60826c6236411d06eddfd947014cb76a7a02a664586ac07f7c5b0537
name: python-backprop
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Backprop
url: https://github.com/backprop-ai/backprop
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backprop-0.1.3-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
     <a href="https://backprop.co">
        <img src=".github/header.png" width="300" alt="Backprop"/>
     </a>
  </h1>

  <p align="center">
     <a href="https://pypi.org/project/backprop/"><img src="https://img.shields.io/pypi/v/backprop"/></a> <img src="https://img.shields.io/pypi/pyversions/backprop"/> <a href="https://www.apache.org/licenses/LICENSE-2.0"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg"/></a>
  </p>

  <p align="center">
  Backprop makes it simple to use, finetune, and deploy state-of-the-art ML models.
  </p>

  <p align="center">
     <img src=".github/example.png" width="600"/>
  </p>

  Solve a variety of tasks with pre-trained models or finetune them in one line for your own tasks.

  Out of the box tasks you can solve with Backprop:

  - Conversational question answering in English
  - Text Classification in 100+ languages
  - Image Classification
  - Text Vectorisation in 50+ languages
  - Image Vectorisation
  - Summarisation in English
  - Emotion detection in English
  - Text Generation

  For more specific use cases, you can adapt a task with little data and a single line of code via finetuning.

  | ⚡ [Getting started](#getting-started)                | Installation, few minute introduction                      |
  | :---------------------------------------------------- | :-------------------------------------------------------- |
  | 💡 [Examples](#examples)                              | Finetuning and usage examples                              |
  | 📙 [Docs](https://backprop.readthedocs.io/en/latest/) | In-depth documentation about task inference and finetuning |
  | ⚙️ [Models](https://backprop.co/hub)                   | Overview of available models                              |





  Install Backprop via PyPi:

  ```bash
  pip install backprop
  ```



  Tasks act as interfaces that let you easily use a variety of supported models.

  ```python
  import backprop

  context = "Take a look at the examples folder to see use cases!"

  qa = backprop.QA()


  answer = qa("Where can I see what to build?", context)

  print(answer)

  "the examples folder"
  ```

  You can run all tasks and models on your own machine, or in production with our inference [API](https://backprop.co), simply by specifying your `api_key`.

  See how to use [all available tasks](https://backprop.readthedocs.io/en/latest/Tasks.html).



  Each task implements finetuning that lets you adapt a model for your specific use case in a single line of code.

  A finetuned model is easy to upload to production, letting you focus on building great applications.

  ```python
  from backprop.models import T5
  from backprop import TextGeneration

  tg = TextGeneration(T5)


  inp = ["I really liked the service I received!", "Meh, it was not impressive."]
  out = ["positive", "negative"]


  tg.finetune({"input_text": inp, "output_text": out})


  prediction = tg("I enjoyed it!")

  print(prediction)

  "positive"



  name = "t5-sentiment"
  description = "Predicts positive and negative sentiment"

  tg.upload(name=name, description=description, api_key="abc")
  ```

  See [finetuning for other tasks](https://backprop.readthedocs.io/en/latest/Finetuning.html).



  1. No experience needed

     - Entrance to practical AI should be simple
     - Get state-of-the-art performance in your task without being an expert

  2. Data is a bottleneck

     - Solve real world tasks without any data
     - With transfer learning, even a small amount of data can adapt a task to your niche requirements

  3. There are an overwhelming amount of models

     - We offer a curated selection of the best open-source models and make them simple to use
     - A few general models can accomplish more with less optimisation

  4. Deploying models cost effectively is hard work
     - If our models suit your use case, no deployment is needed: just call our API
     - Adapt and deploy your own model with just a few lines of code
     - Our API scales, is always available, and you only pay for usage



  - Solve any text based task with Finetuning ([Github](https://github.com/backprop-ai/backprop/blob/main/examples/Finetuning_GettingStarted.ipynb), [Colab](https://colab.research.google.com/github/backprop-ai/backprop/blob/main/examples/Finetuning_GettingStarted.ipynb))
  - Search for images using text ([Github](https://github.com/backprop-ai/backprop/blob/main/examples/ImageVectorisation.ipynb))
  - Finding answers from text ([Github](https://github.com/backprop-ai/backprop/blob/main/examples/Q%26A.ipynb))
  - [More finetuning and task examples](https://github.com/backprop-ai/backprop/tree/main/examples)



  Check out our [docs](https://backprop.readthedocs.io/en/latest/) for in-depth task inference and finetuning.



  Curated list of [state-of-the-art models](https://backprop.co/hub).



  Zero-shot image classification with [CLIP](https://clip.backprop.co).



  Backprop relies on many great libraries to work, most notably:

  * [PyTorch](https://github.com/pytorch/pytorch)
  * [PyTorch Lightning](https://github.com/PyTorchLightning/pytorch-lightning)
  * [Transformers](https://github.com/huggingface/transformers)
  * [Sentence Transformers](https://github.com/UKPLab/sentence-transformers)
  * [EfficientNet PyTorch](https://github.com/lukemelas/EfficientNet-PyTorch)
  * [CLIP](https://github.com/openai/CLIP)



  Found a bug or have ideas for new tasks and models? Open an [issue](https://github.com/backprop-ai/backprop/issues).


pkgId: 7de58fe6c97e50700c0de7f13551eb489316d7d98b3f49888596a5e9d1e8ef59
name: python-backrefs
arch: src
version: 5.7.post1
epoch: 0
release: 1
summary: A wrapper around re and regex that adds additional back references.
url: https://github.com/facelessuser/backrefs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backrefs-5.7.post1-1.src.rpm
checksum_type: sha256
description:
  [![Donate via PayPal][donate-image]][donate-link]
  [![Discord][discord-image]][discord-link]
  [![Build][github-ci-image]][github-ci-link]
  [![Coverage Status][codecov-image]][codecov-link]
  [![PyPI Version][pypi-image]][pypi-link]
  [![PyPI Downloads][pypi-down]][pypi-link]
  [![PyPI - Python Version][python-image]][pypi-link]
  ![License][license-image-mit]



  Backrefs is a wrapper around Python's built-in [Re][re] and the 3rd party [Regex][regex] library.  Backrefs adds various
  additional back references (and a couple other features) that are known to some regular expression engines, but not to
  Python's Re and/or Regex.  The supported back references actually vary depending on the regular expression engine being
  used as the engine may already have support for some.

  ```python
  from backrefs import bre
  >>> pattern = bre.compile(r'(\p{Letter}+)')
  >>> pattern.sub(r'\C\1\E', 'sometext')
  'SOMETEXT'
  ```



  https://facelessuser.github.io/backrefs/



  MIT

  [github-ci-image]: https://github.com/facelessuser/backrefs/workflows/build/badge.svg?branch=master&event=push
  [github-ci-link]: https://github.com/facelessuser/backrefs/actions?query=workflow%3Abuild+branch%3Amaster
  [discord-image]: https://img.shields.io/discord/678289859768745989?logo=discord&logoColor=aaaaaa&color=mediumpurple&labelColor=333333
  [discord-link]:https://discord.gg/TWs8Tgr
  [codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/backrefs/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
  [codecov-link]: https://codecov.io/github/facelessuser/backrefs
  [pypi-image]: https://img.shields.io/pypi/v/backrefs.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-down]: https://img.shields.io/pypi/dm/backrefs.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-link]: https://pypi.python.org/pypi/backrefs
  [python-image]: https://img.shields.io/pypi/pyversions/backrefs?logo=python&logoColor=aaaaaa&labelColor=333333
  [license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
  [donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
  [donate-link]: https://www.paypal.me/facelessuser

  [re]: https://docs.python.org/3/library/re.html
  [regex]: https://pypi.python.org/pypi/regex


pkgId: 32592f8237347308a50f36f2d0f85ad3b6cb05ff65ed8fc4e5f7574d22b16fa8
name: python-backscatter
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Client to interact with Backscatter.io services.
url: https://backscatter.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backscatter-0.2.4-1.src.rpm
checksum_type: sha256
description:
  This is an abstract python library built on top of the `Backscatter`_ service. It is preferred that users use this library when implementing integrations or plan to use Backscatter within their code. The library includes a small client to interact with the API.


pkgId: a7353030e49e3ec6445c172377cd2da1b312801bcf9c9e5c4a27fc2bf0acf81d
name: python-backslant
arch: src
version: 0.3.8
epoch: 0
release: 1
summary: Python template engine.
url: https://github.com/Deepwalker/backslant/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backslant-0.3.8-1.src.rpm
checksum_type: sha256
description:
  Is a template engine built in completely other way then before.
  First - you can use all python and you must use it if you want something more
  then just tags.
  Second - it completely iterative. You can feed iterators or generators as input and get iterative output.
  Third - it works through imports. If you want to get template just import it and use. If you want include
  other template - import it. If you want template in some dir, import it! Like ```from . import other_template```.
  Use absolute or relative imports.
  So, with this principles in mind, you can try backslant:
      import backslant
      
      sys.meta_path.insert(0, backslant.BackslantFinder())
      from mypkg.templates.home import index
      for chunk in index.render(title='The Real Thing'):
          print(chunk)
  Or, if you want send rendered html to browser:
      from backslant import to_string
      to_string(index.render(title='The Real Thing'))
  And templates/home/index.bs:
      html
          head
              title
                  = options['title']
          body
              div.content#content
                  h1#header "Header"
  You can define a function:
      - def render_form(method):
          form(method=method)
              input(type="text" value="123")
  End call it:
      h1
          == render_form('POST')
  Yes, its this simple, you just use python constructions. There `==` is shotrcut for `- yield from`.
  And `=` is a shortcut for `- yield`.
  And for now inheritance of templates you can made just with function.
  base.bs:
      !doctype/ html
      html
      head
          title "Page Title"
      body
          h1{'class': ' '.join(['main', 'content'], 'ng-app': 'Application'}
              | Page Header
          div.content
              == options['content_block']()
          div.footer
              | Backslant © 2015
  index.bs:
      - from . import base
      - def content():
          - for i in range(10):
              p
                  = 'Paragraph {}'.format(i)
      == base.render(content_block=content)
  I think about adding something like ruby blocks or something to made this a bit more simpler, but
  what can be more simple then functions define and call?
  But we have syntax sugar for this:
              - for i in range(10):
                  p
                      = 'Paragraph {}'.format(i)
              p "Index page"


pkgId: 6f4ed37c42c8a21a4c32a96a147c26861ac3c9de6926a88c5c96e65bab3176e4
name: python-backstrip
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: backstrip adds color-coordinated fill behind matplotlib boxplots.
url: https://pypi.org/project/backstrip/
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backstrip-0.2.4-1.src.rpm
checksum_type: sha256
description:
  ```python3
  from backstrip import backplot
  from matplotlib import pyplot as plt
  import seaborn as sns
  g = backplot(
      data=sns.load_dataset("titanic"),
      x="class",
      y="age",
      hue="alive",
      col="who",
      style="alone",  # hatches by this column
  )
  plt.show()
  ```
  ![example](docs/assets/test_backplot_v_facet.png)


  ```python3
  def backstrip(
      ax: plt.Axes,
      alpha: float = 0.5,
      hue: typing.Optional[typing.Iterable[str]] = None,
      hatch: typing.Optional[typing.Iterable[str]] = None,
      hatch_color: typing.Union[str, typing.Iterable[str]] = "white",
      orient: typing.Literal["v", "h"] = "v",
      **kwargs,
  ) -> None:
  """
  Draws background strips behind boxplot patches on a matplotlib Axes
  object to enhance the visual identifiability of hue-keyed groups.
  This function iterates over PathPatch objects (representing boxes) within a
  matplotlib Axes, and draws semi-transparent rectangles (strips) in the
  background.
  These strips can be customized in color (`hue`), pattern (`hatch`), and
  orientation (`orient`).


pkgId: 5e9e7d53ee4298b41ab410f7c6a44c3db1ebb3cd89a0503727ec325eb122ce12
name: python-backtest
arch: src
version: 0.7.8
epoch: 0
release: 1
summary: Backtest engine for algorithmic trading
url: https://github.com/yoonbae81/backtest
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backtest-0.7.8-1.src.rpm
checksum_type: sha256
description:
  [![Python version](https://img.shields.io/pypi/pyversions/backtest.svg)](https://pypi.org/project/backtest/)
  [![PyPI version](https://img.shields.io/pypi/v/backtest.svg)](https://pypi.org/project/backtest/)
  [![Test](https://github.com/yoonbae81/backtest/workflows/test/badge.svg)](https://github.com/yoonbae81/backtest/actions?query=workflow%3Atest)
  [![Build](https://github.com/yoonbae81/backtest/workflows/build/badge.svg)](https://github.com/yoonbae81/backtest/actions?query=workflow%3Abuild)
  [![Coverage](https://codecov.io/gh/yoonbae81/backtest/graph/badge.svg)](http://codecov.io/gh/yoonbae81/backtest)
  [![Docs](https://readthedocs.org/projects/backtest/badge/?version=latest)](https://backtest.readthedocs.io/latest)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

  A [backtest](https://en.wikipedia.org/wiki/Backtesting) engine for developing [algorithmic trading](https://en.wikipedia.org/wiki/Algorithmic_trading) strategy.




  - [Backtest](#backtest)
    - [Table of Contents](#table-of-contents)
    - [Installation](#installation)
    - [Usage](#usage)
    - [Support](#support)
    - [Contributing](#contributing)
    - [Testing](#testing)




      $ pip install backtest




  Fetching symbols of KOSPI and KOSDAQ exchanges:


      $ python -m backtest.utils.symbols_krx symbols.json
      Fetched 2,820 symbols
      Saved in symbols.json




  The following will execute the backtest after loading configuration file, `config.json` in same directory.

      python -m backtest

  Sample content of `config.json`
  ```json
  {
    "cash": 1000000,
    "ticks_dir": "ticks",
    "ledger_dir": "ledger",
    "symbols_file": "symbols.json",
    "strategy": "strategy",
    "exchanges": [
      "backtest.exchanges.kospi",
      "backtest.exchanges.kosdaq"
    ]
  }
  ```




  Please [open an issue](https://github.com/yoonbae82/backtest/issues/new) for support.




  Please contribute using [Github Flow](https://guides.github.com/introduction/flow/). Create a branch, add commits, and [open a pull request](https://github.com/yoonbae/backtest/compare/).




  Test codes are prepared in _tests/_ based on [PyTest](https://docs.pytest.org/en/latest/) framework.


pkgId: 2c4fa4ea197bd258b66a7e18fca8d2b41eb03fe479fe1bbbe458ae148a5b2c2a
name: python-backtest-ape
arch: src
version: 0.1.0a16
epoch: 0
release: 1
summary: Backtesting and forward-testing (via Monte Carlo sims) for DeFi strategies.
url: https://pypi.org/project/backtest-ape/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backtest-ape-0.1.0a16-1.src.rpm
checksum_type: sha256
description:
  Backtesting and forward-testing (via Monte Carlo sims) for DeFi strategies.



  ```sh
  hatch build
  hatch shell
  (backtest-ape) $ ape plugins install .
  ```



  ```sh
  (backtest-ape) $ ape compile --size
  ```



  ```sh
  (backtest-ape) $ ape test -s
  ```



  ```sh
  (backtest-ape) $ ape run backtester
  INFO: Starting 'anvil' process.
  You are connected to provider network ethereum:mainnet-fork:foundry.
  Runner type (BaseRunner, BaseCurveV2Runner, BaseUniswapV3Runner, CurveV2LPRunner, UniswapV3LPRunner): CurveV2LPRunner
  Runner kwarg (ref_addrs): {"pool": "0xD51a44d3FaE010294C616388b506AcdA1bfAAE46"}
  Runner kwarg (num_coins): 3
  Runner kwarg (amounts): [1000000000000, 5946382600, 820567784927637667840]
  Deploying mock ERC20 tokens ...
  Start block number: 16219691
  Stop block number [-1]:
  Step size [1]:
  Initializing state of mocks from block number 16219691 ...
  Iterating from block number 16219692 to 16270201 with step size 1 ...
  Processing block 16219692 ...
  State of refs at block 16219692: {'balances': [49753542730360, 299470579545, 42256392553951116624718], 'D': 149811847101739918524603074, 'A_gamma': [183752478137306770270222288013175834186240000, 581076037942835227425498917514114728328226821, 1633548703, 0], 'prices': [16693207875853529503168, 1185215639716509143580], 'total_supply': 179765246450053705933358}
  Backtester value at block 16219692: 2981325191662
  ```



  [Curve Tricrypto2 LP position](scripts/results/CurveV2LPRunner_16048833_-1_300.csv)
  from block 16048833 to 16273534:

  ![](notebook/assets/curve/v2/lp.png)

  [Gearbox V2 stETH strategy (5x leverage)](scripts/results/GearboxV2STETHRunner_backtest_14805946_15078047_300.csv)
  from block 14805946 to 15078047:

  ![](notebook/assets/gearbox/v2/steth.png)


pkgId: 1d2ba1781756cf500c08492e00b45ce958cfea7583c275c25bebad13aa79e2a1
name: python-backtest-equities
arch: src
version: 0.3.5
epoch: 0
release: 1
url: https://github.com/JackMartinDev/backtest_equities
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backtest-equities-0.3.5-1.src.rpm
checksum_type: sha256
summary:
  A tool for simulating trading strategies against historical market data to evaluate performance and refine approaches before live trading.

description:
  A Python package for backtesting and analyzing trading strategies over various time periods. This package allows users to easily split data, run backtests, optimize strategies, and perform equity curve analysis.



  - **Split Data Periods**: Split time series data into yearly, monthly, or custom periods.
  - **Backtest**: Run backtests on trading strategies across different periods.
  - **Equity Curve Analysis**: Analyze and visualize equity curves for deeper insight into performance.
  - **Monte Carlo Simulation**: Perform Monte Carlo simulations to evaluate strategy robustness.
  - **Parameter Optimization**: Optimize strategy parameters for better performance.


  You can install the package using pip:
  pip install backtest_equities





  import backtest_equities as bt

  1. Split Data into Periods
  You can split your time series data (such as stock price data) into periods for different types of analysis.

  import pandas as pd



  df = pd.read_csv('your-data.csv', index_col='Date', parse_dates=True)



  split_data = bt.split_periods(df, periods_for_split='yearly')

  2. Run a Backtest Over Periods
  Run a backtest on the split data for different periods.



  side = 'long'
  SL_type = 'fixed'
  SL = 0.02
  SL_spike_out = False
  TP = 0.05
  TS = 0.03



  backtest_results = bt.backtest_over_periods(split_data, side, SL_type, SL, SL_spike_out, TP, TS)



  for result in backtest_results:
      print(result)

  3. Optimize Strategy Parameters
  You can optimize your strategy by testing different parameters.



  param_ranges = {
      'SL': [0.01, 0.02, 0.03],
      'TP': [0.03, 0.05, 0.07]
  }



  optimal_params = bt.optimize_parameters(df, param_ranges)
  print("Optimal Parameters:", optimal_params)

  4. Equity Curve Analysis
  Visualize and analyze the equity curves from the backtest.



  bt.equity_curve_analysis(backtest_results)

  5. Monte Carlo Simulation
  Run a Monte Carlo simulation to assess the strategy’s robustness.



  bt.monte_carlo_simulation(backtest_results, iterations=1000)


  Here’s a full workflow example of using the package to split data, backtest, and analyze results.

  import pandas as pd
  import your_package_name as bt



  df = pd.read_csv('your-data.csv', index_col='Date', parse_dates=True)



  split_data = bt.split_periods(df, periods_for_split='yearly')



  backtest_results = bt.backtest_over_periods(split_data, side='long', SL_type='fixed', SL=0.02, SL_spike_out=False, TP=0.05, TS=0.03)



  bt.equity_curve_analysis(backtest_results)



  bt.monte_carlo_simulation(backtest_results, iterations=1000)


  Contributions are welcome! Please fork the repository, create a branch for your changes, and submit a pull request.


  This project is dedicated to the public domain under the Unlicense. You can freely use, modify, and distribute this software without any restrictions.


  For any issues or support, please reach out via the GitHub repository or email at jack.martin.codes@gmail.com.


  - **Overview**: General introduction to the package features.
  - **Installation**: Instructions on how to install the package using pip.
  - **Usage**: Step-by-step examples showing how to split periods, backtest, optimize parameters, and perform equity analysis.
  - **Example Workflow**: A full example that combines everything.
  - **Contributing** and **License** sections provide information for contributors and license details.


pkgId: ccf60064effa5c9aa88f7f6f7b1093192f65ceb33c630a4edee7169e2cad2ba1
name: python-backtracepython
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Backtrace.io error reporting tool for Python
url: https://backtrace.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backtracepython-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [Backtrace](http://backtrace.io/) error reporting tool for Python.



  https://docs.saucelabs.com/error-reporting/language-integrations/python/





  This module supports Python 2, Python 3, and PyPy.

  ```bash
  python -m pip install backtracepython
  ```



  ```bash
  import backtracepython as bt
  bt.initialize(
      endpoint="https://submit.backtrace.io/{universe}/{token}/json"
  )
  ```



  By default, the `backtracepython` module automatically captures unhandled exceptions and creates and sends error reports from them. This behavior can be adjusted with the `disable_global_handler` option in `bt.initialize` (see below).



  You can also send error reports manually in your code. However, to get a correct callstack and source code context, you must send an error with a Python exception context. To do this, you can raise a Python exception and then immediately send a report using the `send_last_exception` call. Here's an example:

  ```python
  try:
      raise Exception("This report was sent manually.")
  except:
      bt.send_last_exception()
  ```







  - endpoint  - Required. Example: https://yourcompany.sp.backtrace.io:6098 or https://submit.backtrace.io/{universe}/{token}/json.  Sets the HTTP/HTTPS endpoint that error reports will be sent to. If submit.backtrace.io url is provided, the token argument is not required.
    token  -  Required only if endpoint is not set to submit.backtrace.io. Example: 51cc8e69c5b62fa8c72dc963e730f1e8eacbd243aeafc35d08d05ded9a024121  Sets the token that will be used for authentication when sending an error report.
  - attributes  - Dictionary that contains additional attributes to be sent along with every error report. These can be overridden on an individual report with report.set_attribute  Example: { 'application': "ApplicationName", 'serverId': "foo" }. Attributes values should be set to a primitive value such as boolean, integer or string.
  - attachments - A list of file paths that will be sent with each report.
  - ignore_ssl_certificate - Defaults to False. If True, ssl verification will be ignored during HTTP submission.
  - timeout  - Defaults to 4. Maximum amount of seconds to wait for error report processing and sending before concluding it failed.
  - debug_backtrace - Defaults to False . Set to True to have an error during collecting the report raise an exception, and to print some debugging information to stderr.
  - disable_global_handler - Defaults to False. If this is False  this module will insert itself in the sys.excepthook chain and report those errors automatically before re-raising the exception. Set to True  to disable this. Note that in this case the only way error reports will be reported is if you manually create and send them.
  - context_line_count  - Defaults to 200 . When an error is reported, this many lines above and below each stack function are included in the report.
  - tab_width  - Defaults to 8.  If there are any hard tabs in the source code, it is unclear how many spaces they should be indented to correctly display the source code. Therefore the error report can override this number to specify how many spaces a hard tab should be represented by when viewing source code.
  - collect_source_code - Default to True. By default Backtrace client collects corresponded source code and send it with the report. If set to False, the source code will not be collected.
  - exit_timeout - Default to 4. Backtrace sends data asynchronously in the background thread. The exit_timeout describes how many time the thread has to finish working before application exit.



  Create a report object that you can later choose whether or not to send. This may be useful to track something like a request.

  `report.set_attribute(key, value)`
  Adds an attribute to a specific report. Valid types for value are str, float, int, and bool.
  Attributes are indexed and searchable. See also `addAnnotation`

  `report.set_dict_attributes(dict)`

  Adds all key-value pairs of dict into the report recursively.

  `report.get_attributes()`

  Returns all report attributes.

  `report.set_annotation(key, value)`

  Adds an annotation to a specific report. Annotations, unlike attributes, are not indexed and searchable. However, they are available for inspection when you view a specific report.

  key - String which is the name of the annotation.
  value - Any type which is JSON-serializable.

  `report.set_dict_annotations(dict)`

  Adds all key-value pairs of dict into the report.

  `report.add_attachment(attachment_path)`

  Adds an attachment to the report.

  `report.get_attachments()`

  Returns a list of attachment paths.

  `report.set_exception(ExceptionType, exception, traceback)`

  error  is an Error object. Backtrace will extract information from this object such as the error message and stack trace and send this information along with the report.

  `report.capture_last_exception()`

  This is the same as report.set_exception(\*sys.exc_info())

  `report.log(line)`

  Adds a timestamped log message to the report. Log output is available when you view a report.

  `report.send()`

  Sends the error report to the endpoint specified in initialize.



  - attributes  - dictionary of attributes to add to the report. See report.set_dict_attributes
  - annotations  - dictionary of annotations to add to the report. See report.set_dict_annotations



  To run the test suite:

  ```bash
  pytest
  ```

  Since all of these implementations of Python are supported, be sure to run the
  test suite with all of them:

  - Python 2
  - Python 3
  - PyPy



  1. Make sure all tests pass (see above).
  2. Update version number in backtracepython module.
  3. Tag the version in git.

  ```bash
  python3 setup.py bdist_wheel --universal
  twine upload dist/*
  ```


pkgId: 942d300e03dbee45a4012e5f68742dd2f3b80517510a146b6b0761c9d0761e8a
name: python-backtracks
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Python package to fit relative astrometry with background star motion tracks.
url: https://github.com/wbalmer/backtracks
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backtracks-0.5.0-1.src.rpm
checksum_type: sha256
description:
  `backtracks` is a python package to fit relative astrometry with background helical motion tracks, to discern directly imaged planets from contaminant sources
  The code is written and developed by Gilles Otten (@gotten), William Balmer (@wbalmer), and Tomas Stolker (@tomasstolker).


pkgId: 4563ffbf9e2cb2e084055255b16b7f6c1bae4d4849dce1126ae1ff732597151b
name: python-backtrader
arch: src
version: 1.9.78.123
epoch: 0
release: 1
summary: BackTesting Engine
url: https://github.com/mementum/backtrader
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backtrader-1.9.78.123-1.src.rpm
checksum_type: sha256
description:
  **Yahoo API Note**:
    [2018-11-16] After some testing it would seem that data downloads can be
    again relied upon over the web interface (or API ``v7``)
  **Tickets**
    The ticket system is (was, actually) more often than not abused to ask for
    advice about samples.
  For **feedback/questions/...** use the `Community <https://community.backtrader.com>`_
  Here a snippet of a Simple Moving Average CrossOver. It can be done in several
  different ways. Use the docs (and examples) Luke!
    from datetime import datetime
    import backtrader as bt
    class SmaCross(bt.SignalStrategy):
        def __init__(self):
            sma1, sma2 = bt.ind.SMA(period=10), bt.ind.SMA(period=30)
            crossover = bt.ind.CrossOver(sma1, sma2)
            self.signal_add(bt.SIGNAL_LONG, crossover)
    cerebro = bt.Cerebro()
    cerebro.addstrategy(SmaCross)
    data0 = bt.feeds.YahooFinanceData(dataname='MSFT', fromdate=datetime(2011, 1, 1),
                                      todate=datetime(2012, 12, 31))
    cerebro.adddata(data0)
    cerebro.run()
    cerebro.plot()
  Including a full featured chart. Give it a try! This is included in the samples
  as ``sigsmacross/sigsmacross2.py``. Along it is ``sigsmacross.py`` which can be
  parametrized from the command line.


pkgId: d80091bb1c2dff15151f285aac639de5e2bbc2a9f4fa11b2dcebe6ea69cdddb2
name: python-backtrader-binance
arch: src
version: 2.0.5
epoch: 0
release: 1
summary: Binance API integration with Backtrader
url: https://github.com/WISEPLAT/backtrader_binance
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backtrader-binance-2.0.5-1.src.rpm
checksum_type: sha256
description:
  Интеграция Binance API с [Backtrader](https://github.com/WISEPLAT/backtrader ).
  С помощью этой интеграции вы можете делать:
  - Тестирование вашей стратегии на исторических данных с биржи [Binance](https://accounts.binance.com/register?ref=200640624 ) + [Backtrader](https://github.com/WISEPLAT/backtrader )
  - Запускать торговые системы для автоматической торговли на бирже [Binance](https://accounts.binance.com/register?ref=200640624 ) + [Backtrader](https://github.com/WISEPLAT/backtrader )
  - Загружать исторические данные по криптовалютам с биржи [Binance](https://accounts.binance.com/register?ref=200640624 )
  Для подключения к API мы используем библиотеку [python-binance](https://github.com/sammchardy/python-binance ).
  **Можно сказать Спасибо:**
  USDT (Tron TRC20): TEHaXZX7KLjAm4eLWdf4VKfsqRUQpv8fTT
  или по [**Binance**](https://accounts.binance.com/register?ref=200640624 ) **ID** **200640624** через биржу (без комиссии)
  или по [**Bybit**](https://www.bybit.com/invite?ref=KXLXXE%230 ) **UID** **112927970** через биржу (без комиссии)

  1) Самый простой способ:
  ```shell
  pip install backtrader_binance
  ```
  или
  ```shell
  git clone https://github.com/WISEPLAT/backtrader_binance
  ```
  или
  ```shell
  pip install git+https://github.com/WISEPLAT/backtrader_binance.git
  ```
  2) Пожалуйста, используйте backtrader из моего репозитория (так как вы можете размещать в нем свои коммиты). Установите его:
  ```shell
  pip install git+https://github.com/WISEPLAT/backtrader.git
  ```
  -- Могу ли я использовать ваш интерфейс binance с оригинальным backtrader?
  -- Да, вы можете использовать оригинальный backtrader, так как автор оригинального backtrader одобрил все мои изменения.
  Вот ссылка: [mementum/backtrader#472](https://github.com/mementum/backtrader/pull/472)
  3) У нас есть некоторые зависимости, вам нужно их установить:
  ```shell
  pip install python-binance backtrader pandas matplotlib
  ```
  или
  ```shell
  pip install -r requirements.txt
  ```

  Чтобы было легче разобраться как всё работает, сделано множество примеров в папках **DataExamplesBinance_ru** и **StrategyExamplesBinance_ru**.
  Перед запуском примера, необходимо получить свой API ключ и Secret ключ, и прописать их в файле **ConfigBinance\Config.py:**
  ```python

  class Config:
      BINANCE_API_KEY = "YOUR_API_KEY"
      BINANCE_API_SECRET = "YOUR_SECRET_KEY"
  ```

  1. Зарегистрируйте свой аккаунт на [Binance](https://accounts.binance.com/register?ref=200640624 )
  2. Перейдите в раздел ["Управление API"](https://www.binance.com/en/my/settings/api-management?ref=CPA_004RZBKQWK )
  3. Затем нажмите кнопку "Создать API" и выберите "Сгенерированный системой".
  4. В разделе "Ограничения API" включите "Включить спотовую и маржинальную торговлю".
  5. Скопируйте и вставьте в файл **ConfigBinance\Config.py** полученные **"Ключ API"** и **"Секретный ключ"**

  В папке **DataExamplesBinance_ru** находится код примеров по работе с биржевыми данными через API интерфейс [Binance](https://accounts.binance.com/register?ref=200640624 ).
  * **01 - Symbol.py** - торговая стратегия для получения исторических и "живых" данных одного тикера по одному таймфрейму
  * **02 - Symbol data to DF.py** - экспорт в csv файл исторических данных одного тикера по одному таймфрейму
  * **03 - Symbols.py** - торговая стратегия для нескольких тикеров по одному таймфрейму
  * **04 - Resample.py** - торговая стратегия для получения данных одного тикера по разным таймфреймам методом конвертации меньшего таймфрейма в больший
  * **05 - Replay.py** - запуск торговой стратегии на меньшем таймфрейме, с обработкой на большем и выводом графика большего интервала
  * **06 - Rollover.py** - запуск торговой стратегии на склейке данных из файла с историческими данными и последней загруженной истории с брокера
  * **07 - Get Asset Balance.py** - получение баланса тикера напрямую через API Binance
  * **08 - Timeframes.py** - торговая стратегия для одного тикера по разным таймфреймам
  * **09 - Get Asset Info.py** - получение информации об активе: баланс, размер лота, минимальный шаг цены, минимальная стоимость покупки и т.д.
  * **09 - Get Asset Info - no Decimal.py** - получение информации об активе: баланс, размер лота, минимальный шаг цены, минимальная стоимость покупки и т.д.
  * **09 - Get Asset Info - through client.py** - получение информации об активе: баланс, размер лота, минимальный шаг цены, минимальная стоимость покупки и т.д.
  * **10 - Get Historical Data.py** - получение исторических данных через клиент binance для актива.
  * **Strategy.py** - Пример торговой стратегии, которая только выводит данные по тикеру/тикерам OHLCV
  В папке **StrategyExamplesBinance_ru** находится код примеров стратегий.
  * **01 - Live Trade - Just Buy and Sell.py** - Пример торговой стратегии в live режиме для ETH на базовом тикере USDT.
    * В стратегии показано как выставлять Ордер по Рынку и Лимитный ордер и как отменять ордер.
    * Пример выставления заявок на биржу Binance и их снятие.
      * Пожалуйста, имейте в виду! Это live режим - если на рынке произойдет значительное изменение цены в сторону понижения более чем на 5% - ордер может быть выполнен....
      * Пожалуйста, имейте в виду! Для ордера по Рынку - он будет выполнен....
      * **Не забудьте после теста снять с биржи выставленные заявки!**
  * **01 - Live Trade.py** - Пример торговой стратегии в live режиме для двух тикеров BTC и ETH на базовом тикере USDT.
    * В стратегии показано как применять индикаторы (SMA, RSI) к нескольким тикерам одновременно.
    * Пример выставления заявок на биржу Binance и их снятие.
      * Пожалуйста, имейте в виду! Это live режим - если на рынке произойдет значительное изменение цены в сторону понижения более чем на 5% - ордер может быть выполнен....
      * **Не забудьте после теста снять с биржи выставленные заявки!**
  * **02 - Live Trade MultiPortfolio.py** - Пример торговой стратегии в live режиме для множества тикеров, которые можно передавать в стратегию списком (BTC, ETH, BNB) на базовом тикере USDT.
    * В стратегии показано как применять индикаторы (SMA, RSI) к нескольким тикерам одновременно.
    * Пример выставления заявок на биржу Binance и их снятие.
      * Пожалуйста, имейте в виду! Это live режим - если на рынке произойдет значительное изменение цены в сторону понижения более чем на 5% - ордер может быть выполнен....
      * **Не забудьте после теста снять с биржи выставленные заявки!**
  * **03 - Live Trade ETH.py** - Пример торговой стратегии в live режиме для двух тикеров BNB и XMR на базовом тикере ETH.
    * В стратегии показано как применять индикаторы (SMA, RSI) к нескольким тикерам одновременно.
    * Пример выставления заявок на биржу Binance и их снятие.
      * Пожалуйста, имейте в виду! Это live режим - если на рынке произойдет значительное изменение цены в сторону понижения более чем на 5% - ордер может быть выполнен....
      * **Не забудьте после теста снять с биржи выставленные заявки!**
  * **04 - Offline Backtest.py** - Пример торговой стратегии для теста на истории - не live режим - для двух тикеров BTC и ETH на базовом тикере USDT.
    * В стратегии показано как применять индикаторы (SMA, RSI) к нескольким тикерам одновременно.
      * Не live режим - для тестирования стратегий без отправки заявок на биржу!
  * **05 - Offline Backtest MultiPortfolio.py** - Пример торговой стратегии для теста на истории - не live режим - для множества тикеров, которые можно передавать в стратегию списком (BTC, ETH, BNB) на базовом тикере USDT.
    * В стратегии показано как применять индикаторы (SMA, RSI) к нескольким тикерам одновременно.
      * Не live режим - для тестирования стратегий без отправки заявок на биржу!
  * **06 - Live Trade Just Buy and Close by Market.py** - Пример торговой стратегии в live для тикера ETH на базовом тикере USDT.
    * Стратегия показывает, как покупать по цене закрытия и продавать по рыночной небольшое количество ETH через 3 бара.
    * Пример размещения ордеров на бирже Binance.
      * **Не забудьте отменить выставленные ордера с биржи после тестирования!**
  * **07 - Offline Backtest Indicators.py** - Пример торговой стратегии для теста на истории с использованием индикаторов SMA и RSI - не live режим - для двух тикеров BTC и ETH на базовом тикере USDT.
    * В стратегии показано как применять индикаторы (SMA, RSI) к нескольким тикерам одновременно.
      * генерит 177% дохода на момент записи видео ))
      * Не live режим - для тестирования стратегий без отправки заявок на биржу!
  * **08 - Offline Backtest Margin Trade with Leverage 50x - Linear Trade.py** - Пример торговой стратегии с использованием маржинального плеча 50x для исторического бэктеста с использованием индикаторов SMA - не в режиме реального времени - для двух тикеров BTC и ETH на основе тикера USDT.
    * Стратегия показывает, как применять индикаторы SMA к нескольким тикерам одновременно.
      * генерирует 792% дохода на момент публикации файла
      * Не live режим - для тестирования стратегий без отправки ордеров на биржу!!
    * Стратегия показывает, как использовать маржинальную торговлю с кредитным плечом 50x для тестирования на исторических рыночных данных для криптовалют.
  ```commandline
  $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  Was money: 2000.00
  Ending Portfolio Value: 17853.46
  Remaining available funds: 4887.38
  Assets in the amount of: 12966.08
  2000.00 ==> 17853.46 ==> +792.67%
  SQN:  AutoOrderedDict([('sqn', 1.0031776139642996), ('trades', 4)])
  VWR:  OrderedDict([('vwr', 25.613023915870777)])
  TDD:  OrderedDict([('maxdrawdown', 65.77087178559279), ('maxdrawdownperiod', 304)])
  DD:  AutoOrderedDict([('len', 6), ('drawdown', 20.46618403019286), ('moneydown', 229.70872494394746), ('max', AutoOrderedDict([('len', 304), ('drawdown', 65.77087178559279), ('moneydown', 295.8359186842)]))])
  AR:  OrderedDict([(2021, 0.0), (2022, -0.42822236821405035), (2023, 4.540830244681184), (2024, 1.8176719585784271)])
  Profitability:  OrderedDict([('rtot', 2.1890502317806253), ('ravg', 0.0022178827069712515), ('rnorm', 0.7487590850582526), ('rnorm100', 74.87590850582527)])
  $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  ```

  - backtrader: очень простая и классная библиотека!
  - [python-binance](https://github.com/sammchardy/python-binance ): Для создания оболочки Binance API, сокращающей большую часть работы.
  - lindomar-oliveira за некоторый код

  Исправление ошибок, доработка и развитие библиотеки осуществляется автором и сообществом!
  **Пушьте ваши коммиты!**

  Библиотека backtrader_binance позволяющая делать интеграцию Backtrader и Binance API - это **Программа** созданная исключительно для удобства работы.
  При использовании **Программы** Пользователь обязан соблюдать положения действующего законодательства Российской Федерации или своей страны.
  Использование **Программы** предлагается по принципу «Как есть» («AS IS»). Никаких гарантий, как устных, так и письменных не прилагается и не предусматривается.
  Автор и сообщество не дает гарантии, что все ошибки **Программы** были устранены, соответственно автор и сообщество не несет никакой ответственности за
  последствия использования **Программы**, включая, но, не ограничиваясь любым ущербом оборудованию, компьютерам, мобильным устройствам,
  программному обеспечению Пользователя вызванным или связанным с использованием **Программы**, а также за любые финансовые потери,
  понесенные Пользователем в результате использования **Программы**.
  Никто не ответственен за потерю данных, убытки, ущерб, включаю случайный или косвенный, упущенную выгоду, потерю доходов или любые другие потери,
  связанные с использованием **Программы**.
  **Программа** распространяется на условиях лицензии [MIT](https://choosealicense.com/licenses/mit).


pkgId: 1a18d51e24cee3c7d6fe008e853ddba39b584cdaddd95cb44c5419057a081504
name: python-backup-reporter
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Collect and show info about various backups
url: https://pypi.org/project/backup-reporter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backup-reporter-0.4.5-1.src.rpm
checksum_type: sha256
description:
  This repository contains source code for backup reporter tool. That tool can
  collect backup information, upload it to S3 buckets, then collect bunch of
  backup information files, get them together into one csv file and upload it to
  google spreadsheet.

  Backup reporter has two working modes: reporter and collector.



  To install backup-reporter to some machine (either in reporter or collector
  mode), ensure you have a python 3.8+ installed on that machine. If so, simply
  run `pip3 install backup-reporter` and wait to the end of setup process. After
  installation will be completed, run `backup-reporter -h` to get further steps
  help.



  Beware that standard python packages installations which are ran by mean user,
  won't install console scripts to the PATH, so ensure to do so manually - or run
  installation as root.





  Reporter can be configured with two ways: script arguments or configuration
  file. Possible configuration options you can find by typing `backup-reporter
  -h`. To use config file just pass `--config your_config_file.yml` as script
  argument.
  All options from cli-help are same for config-file. As example following
  command:
  - `python3 main.py --bucket="{'s3_path':
    's3://bucket_name/in_bucket_path/metadata_file_name.txt',
    'aws_access_key_id': 'key', 'aws_secret_access_key': 'key', 'aws_region':
    'region'}" --docker_postgres`

  can be written in file:
  ```
  docker_postgres: true
  bucket:
      - s3_path: s3://bucket_name/in_bucket_path/metadata_file_name.txt
        aws_access_key_id: key
        aws_secret_access_key: key
        aws_region: region
        customer: "Customer name"
  ```

  More examples can be found at `docs/config-examples/reporter-*.conf`



  Collector can be configured the same way as reporter - with arguments passed to
  executable file or with config file (which, though, has to be passed as
  argument too). Example of config for collector with comments:

  ```

  sheet_owner: s@example.com



  google_spreadsheet_credentials_path: ~/Development/personal/backupreporter_key.json


  spreadsheet_name: "Backup-Reports"


  worksheet_name: Customers

  bucket:
      - s3_path: s3://bucket/metadata/metadata.json
        aws_access_key_id: access-key
        aws_secret_access_key: secret-key
        aws_region: ru-1
        aws_endpoint_url: https://s3.ru-1.storage.selcloud.ru
        customer: Personal
  ```



  Owner transfership in case of spreadsheets is a two-step process. First,
  collector will set flag on spreadsheet which will indicate that permission have
  to be transferred. After that user which should became an owner has to accept
  that by write `pendingowner:me` in his google drive, find according spreadsheet
  and get the ownership. One can read some details at
  https://support.google.com/docs/answer/2494892?hl=en&co=GENIE.Platform%3DDesktop.



  Install poetry first, then simply run `poetry install` in repository root - and
  start to develop. To run, run `poetry run`. To publish new version, change
  version in `pyproject.toml` and run `poetry build && poetry publish`.


pkgId: f6eecb27c41962c1259a3cc0e831a54b8a7cb0fb909a46889b467069a1b15a5d
name: python-backup-utils
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: The goal of the project is to simplify backup creation.
url: https://gitlab.com/Oprax/backup-utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backup-utils-2.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://drone.oprax.fr/api/badges/Oprax/backup-utils/status.svg)](https://drone.oprax.fr/Oprax/backup-utils)
  [![codecov](https://codecov.io/gl/Oprax/backup-utils/branch/master/graph/badge.svg?token=V9T1OFP3JO)](https://codecov.io/gl/Oprax/backup-utils)
  [![Documentation Status](https://readthedocs.org/projects/backup-utils/badge/?version=latest)](https://backup-utils.readthedocs.io/en/latest/?badge=latest)
  [![PyPI - License](https://img.shields.io/pypi/l/backup-utils.svg)](https://gitlab.com/Oprax/backup-utils/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/backup-utils.svg)](https://pypi.org/project/backup-utils/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/backup-utils.svg)](https://pypi.org/project/backup-utils/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  The goal of this project is to create a front to a backup program like Borg.
  Indeed, Borg is a really great tool for backup,
  but I always write a bash script to specify directories I want to save.
  I also use Rclone to synchronize my backup to a remote.
  And finally, I need to backup my database.
  There are three steps to backup :
  1. Database export
  2. Archiving
  3. Synchronize
  For each step, you can use multiple drivers for multiple tools.
  Also if something goes wrong, all Exceptions are catches to send a notification.
  By default, database export use **mysql**, archiving **borg**, and synchronize **rclone**.
  Visit [documentation](https://backup-utils.readthedocs.io/) for more details.


pkgId: 5d38591794edaf8b53fe705ce7cfcfa036e2ce6fd46b260e3286a2ee691a30f6
name: python-backup_warden
arch: src
version: 1.0.13
epoch: 0
release: 1
summary: Streamline your backup management with ease and simplicity
url: https://pypi.org/project/backup_warden/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backup_warden-1.0.13-1.src.rpm
checksum_type: sha256
description:
  In today's digital landscape, every business is taking backups of their data (hopefully). These backups can be challenging as they often require substantial disk space and/or cloud storage that can lead to significant financial expenses. If you're in search of a solution to handle your backups and retain only the necessary ones according to your retention policies, look no further! With Backup Warden, it will supervise and maintain your backups simplifying your overall data life cycle and enabling you to have smarter resource utilization.

  Thanks to xolox for his work on [rotate-backups](https://github.com/xolox/python-rotate-backups) that gave me a lot of inspiration for this project!



  | Option                      | Description                                                                            | Default Value            |
  |-----------------------------|----------------------------------------------------------------------------------------|--------------------------|
  | `--minutely`                | Number of minutely backups to preserve                                                 | `0`                      |
  | `--hourly`                  | Number of hourly backups to preserve                                                   | `72`                     |
  | `--daily`                   | Number of daily backups to preserve                                                    | `7`                      |
  | `--weekly`                  | Number of weekly backups to preserve                                                   | `6`                      |
  | `--monthly`                 | Number of monthly backups to preserve                                                  | `12`                     |
  | `--yearly`                  | Number of yearly backups to preserve                                                   | `always`                 |
  | `-c`, `--config`            | Location of the config file                                                            | `/etc/backup_warden.ini` |
  | `-s`, `--source`            | Source of where the backups are stored. Select from: `local`, `ssh`, `s3`              | `local`                  |
  | `-b`, `--bucket`            | Name of the AWS S3 bucket                                                              |                          |
  | `-p`, `--path`              | Specify a path to traverse all directories it contains for granular retention policies |                          |
  | `-e`, `--environment`       | Environment the backups are rotated in (used for Slack alert only)                     |                          |
  | `-t`, `--timestamp-pattern` | The timestamp pattern using a regex expression to parse out of filenames               |                          |
  | `-l`, `--log-file`          | Enable logging to this file path                                                       |                          |
  | `-I`, `--include-list`      | Include backups based on their directory path and/or filename (separated by comma)     |                          |
  | `-E`, `--exclude-list`      | Exclude backups based on their directory path and/or filename (separated by comma)     |                          |
  | `-H`, `--ssh-host`          | SSH host/alias to use                                                                  |                          |
  | `--ssh-sudo`                | Wrap SSH commands with sudo for escalated privileges                                   | `False`                  |
  | `--filestat`                | Use the file's last modified date instead of parsing timestamp from filename           | `False`                  |
  | `--prefer-recent`           | Keep the most recent backup in each time slot instead of oldest                        | `False`                  |
  | `--s3-only-prefixes`        | When used with an S3 bucket, only prefixes will be considered (not individual objects) | `False`                  |
  | `--relaxed`                 | Time windows are not enforced                                                          | `False`                  |
  | `--utc`                     | Use UTC timezone instead of local machine's timezone for timestamps                    | `False`                  |
  | `--syslog`                  | Use syslog                                                                             | `False`                  |
  | `--debug`                   | Log debug messages that can help troubleshoot                                          | `False`                  |
  | `--delete`                  | Commit to deleting backups (DANGER ZONE)                                               | `False`                  |
  | `-V`, `--version`           | Display version and exit                                                               |                          |
  | `-h`, `--help`              | Show this help message and exit                                                        |                          |

  **Note**: Boolean options such as `--filestat` can be specified as `yes`/`no`, `true`/`false`, or `1`/`0` in the config





  - These options determine the number of backups to retain for each respective frequency
  - You have the flexibility to provide an expression that will be evaluated to calculate a value. For example, using `--hourly=5+2` would result in 7
  - Alternatively, you can specify "always" as the value to preserve all backups for that particular frequency


  There are currently three available sources, each functioning differently when scanning directories to find backups.

  - `local`

  This option is straightforward and doesn't really require any additional explanation. It is a simple method for locating backups

  - `ssh`

  To use this source, you need to configure the SSH config file (`~/.ssh/config`) with the relevant host information. It also supports aliases defined in the SSH config, as well as jump hosts

  - `s3`

  One thing to note is the `s3_endpoint_url` option. This lets you specify an endpoint other than the default to be able to use an alternative like DigitalOcean Spaces (i.e. `https://nyc3.digitaloceanspaces.com`)



  **Using Config File**

  When `path` is used under the `[main]` section in config, it significantly alters Backup Warden's functionality. In this case, Backup Warden will traverse through every directory and file under the given path until it locates a backup. Once a backup is found, it associates the backup with a config section using `fnmatch` for pattern matching that defines its retention policy. If there isn't a config section that matches all possibilities of a path found, it's ignored. If `path` is not specified, Backup Warden will only scan the path defined in each config section.

  Using the `path` option provides granular control over retention policies and allows for flexible path name conventions. It enables you to define custom retention rules based on very specific paths.

  **Using Parameters**

  `--path` is the same as using `path` under `[main]` section in config.

  **Note**: Specifying a `path` may result in a performance impact if there are a lot of non-backup directories/files within the specified path. This shouldn't be an issue though unless your setup is very abnormal. You can use `exclude-list` to assist in this scenario, along with `s3-only-prefixes` if you are working with S3 storage.



  The `timestamp-pattern` option provides the flexibility to customize the regular expression used for extracting timestamps from filenames. The value for this option should be a Python-compatible regular expression that includes the named capture groups 'year', 'month', and 'day'. Additionally, it can optionally include the groups 'hour', 'minute', and 'second'. 'unixtime' is also supported (see below for how to use it)

  Here is an example of the default regular expression:

  ```r

  (?P<year>\d{4} ) \D?
  (?P<month>\d{2}) \D?
  (?P<day>\d{2}  ) \D?
  (?:
      
      (?P<hour>\d{2}  ) \D?
      (?P<minute>\d{2}) \D?
      (?P<second>\d{2})?
  )?
  ```

  Regular expressions are compiled using the [re.VERBOSE](https://docs.python.org/3/library/re.html#re.VERBOSE) flag which ignores whitespace, including newlines.

  If your backups utilize Unix timestamps instead of standard timestamps, you can specify a pattern like:

  ```r
  (?P<unixtime>\d+)
  ```



  In cases where your backup files do not contain a timestamp, you have the option to use the last modified time of the backup instead. However, it is important to note that when utilizing this parameter, you will also need to modify the `timestamp-pattern` to accurately identify which directories/files are considered backups. For example, if all of your backups have filenames starting with "backup-", you would change the `timestamp-pattern` to `backup-\S+`.

  If your backup file names are not standardized and do not follow a specific pattern, this feature is currently not supported.



  Backup Warden offers the `--relaxed` option to modify its default rotation behavior. By default, Backup Warden enforces strict time windows for each rotation scheme. However, with the `--relaxed` option, you can relax this enforcement. Here's a clear explanation/example of the difference between strict and relaxed rotation:

  - **Strict Rotation**: When the number of hourly backups to preserve is set to three, only backups created within the relevant time window (the hour of the most recent backup and the two hours leading up to it) will match the hourly frequency. Choose this option if your backups are created at regular intervals without any missed intervals

  - **Relaxed Rotation**: With the `--relaxed` option enabled, the three most recent backups will all match the hourly frequency and be preserved, regardless of the calculated time window. Choose this option if your backups are created at irregular intervals, as it allows for the preservation of more backups



  With the `--s3-only-prefixes` option, only prefixes (not individual objects) will be considered for rotation. This drastically improves performance when the bucket contains a large number of objects, but only works if your backups are nested under timestamped prefixes.



  These options utilize `fnmatch`, allowing the use of asterisks as wildcards. This enables precise definition of which backups should be excluded from deletion. Include and exclude can be used together for fine-grained control.

  For example, to exclude the `cluster1` from Backup Warden's operations, you can use the `--exclude-list="*cluster1*"` argument. This ensures that any directories/files containing `cluster1` in their names will be excluded.

  To further expand the exclusion criteria, you can exclude backups from the year 2022 by using `--exclude-list="*cluster1*, *2022*"`.

  The same concept applies to the `exclude_list` option under each section in the config file:

  ```ini
  [/path/backups/*/logical]
  hourly = 72
  daily = 7
  weekly = 6
  monthly = 12
  yearly = always
  include_list =
  exclude_list = *cluster1*, *2022*
  ```

  Include functions in the opposite manner. If you want to only include specific backups, you can utilize this feature. It can be used as a command-line argument using `--include-list`, or as the `include_list` option in a config path section.



  Must be using Python 3.8+

  Using PyPi:
  ```shell
  pip install backup-warden

  backup-warden --config config/example.ini
  ```

  Using Poetry:
  ```shell
  curl -sSL https://install.python-poetry.org | python3 -

  poetry install

  poetry run backup-warden --config config/example.ini
  ```

  Using Docker:
  ```shell
  docker build -t backup-warden .

  docker run --volume=/my/backup/dir:/my/backup/dir --volume=$PWD/config:/config backup-warden --config /config/example.ini
  ```



  Backup Warden offers two methods for setting it up: parameters and a config file. The recommended approach is to use a config file, which allows customization of directory paths and their respective retention policies. You can find examples of the config file [here](https://github.com/charles-001/backup-warden/tree/main/example_configs)

  With a config file, each section represents a specific path containing backups to be rotated. Within each section, you can define the rotation scheme and other options. Please refer to the above information for detailed instructions on how to utilize pattern matching effectively when using the `path` option.

  **Note**: If you specify a config file along with config path(s), command-line parameters will have no effect. The methods are not interchangeable.

  Under the `[main]` section in the config file, you can set the following options:

  - `bucket`
  - `path`
  - `source`
  - `environment`
  - `ssh_host`
  - `ssh_sudo`
  - `syslog`
  - `log_file`
  - `s3_endpoint_url`
  - `s3_access_key_id`
  - `s3_secret_access_key`
  - `s3_only_prefixes`
  - `slack_webhook`

  For each config `[path]` section, you can set the following options:

  - `minutely`, `hourly`, `daily`, `weekly`, `monthly`, `yearly`
  - `timestamp_pattern`
  - `include_list`/`exclude_list`
  - `filestat`
  - `relaxed`
  - `prefer_recent`
  - `utc`

  You can also set the following options using environment variables, which will override the corresponding config values:

  - `S3_ENDPOINT_URL`
  - `AWS_ACCESS_KEY_ID`
  - `AWS_SECRET_ACCESS_KEY`
  - `AWS_SESSION_TOKEN`
  - `SLACK_WEBHOOK`



  When the `path` parameter is omitted under the `[main]` section, Backup Warden does not accept wildcarding for config sections. In this scenario, Backup Warden will solely scan the specified config sections without traversing through additional directories.

  This means that instead of scanning the entire file system or applying wildcards to match multiple paths, Backup Warden will focus solely on the directories specified within the config sections. It will not explore subdirectories or perform any recursive scanning.

  By adhering to this behavior, Backup Warden provides a targeted approach, limiting the scope of its backup scanning and rotation operations to the explicitly defined directories within the config sections.

  **Directory structure**
  ```shell
  /path/backups/logical/$backups
  /path/backups/physical/$backups
  ```

  **Config**
  ```ini
  [/path/backups/logical]
  hourly = 15
  daily = 3
  weekly = 5
  monthly = 12
  yearly = always

  [/path/backups/physical]
  hourly = 10
  daily = 7
  weekly = 4
  monthly = 12
  yearly = always
  ```
  This is a basic setup and works as you expect.



  When the `path` option is used under the `[main]` section, Backup Warden allows wildcarding to be applied flexibly within the config sections.

  By specifying the `path` option, you gain the ability to use wildcards to define the directories or files that Backup Warden should scan for backups. This enables a more dynamic and versatile approach. Backup Warden will effectively traverse through the specified paths, including subdirectories if necessary, to locate the backups based on the wildcard patterns provided.

  **Directory structure**
  ```shell
  /path/backups/cluster1/logical/$backups
  /path/backups/cluster2/logical/$backups
  /path/backups/cluster1/physical/$backups
  /path/backups/cluster2/physical/$backups
  ```

  **Config**
  ```ini
  [main]
  path=/path/backups

  [/path/backups/*/logical]
  hourly = 15
  daily = 3
  weekly = 5
  monthly = 12
  yearly = always

  [/path/backups/*/physical]
  hourly = 10
  daily = 7
  weekly = 4
  monthly = 12
  yearly = always
  ```
  Backup Warden's design incorporates hierarchical directory structure awareness, allowing for precise configuration and retention policies.

  By defining `/path/backups/*/logical` as a config section, Backup Warden acknowledges the wildcard (`*`) as a placeholder that matches any subdirectory under `/path/backups/` and assigns it to the `logical` config section.

  When a retention policy is set for a broader path, such as `path/backups`, it will not override or take precedence over a more specific path like `/path/backups/cluster1/logical`. Backup Warden's scanning and rotation operations respect the defined hierarchy, ensuring that retention policies are accurately applied to the corresponding backup directories without unintentionally affecting others.




  Backup Warden offers a convenient Slack integration feature that allows you to stay informed about your backups if you specify a Slack Webhook URL. Benefit from the following alerts:

  1. **Non-Backup Alert**: Get notified if a path doesn't have a backup in the past 24 hours
  2. **Success Alert**: Receive notification after a successful execution, along with detailed statistics about what it did
  3. **Failure Alert**: In case of a failed execution, be promptly notified to address any potential issues




  Backup Warden employs the following steps to carry out the backup rotation process:
  1. **Specify Paths**: You need to provide a `path` and/or use config sections for paths to inform Backup Warden about the locations where the backups are stored
  2. **Scan for Backups**: Backup Warden scans each specified path to locate backups. These backups can be in the form of either directories or files. Backup Warden identifies backups by searching for timestamps in their names. If you're using `filestat`, it will not look for a timestamp, but what you specify in place of it
  3. **Apply Rotation Scheme**: Backup Warden applies the defined rotation scheme to the identified backups. If the outcome doesn't align with your expectations, you can experiment with the `relaxed` and/or `prefer-recent` options to achieve the desired behavior
  4. **Backup Deletion**: Backups that are determined to be rotated based on the rotation scheme will be deleted if the `delete` option is passed. If it isn't, Backup Warden will skip the deletion step and preserve the rotated backups



  <img width="1598" alt="Screenshot 2023-07-01 at 3 50 57 AM" src="https://github.com/charles-001/backup-warden/assets/13244625/eda58941-605f-482a-8800-77f3a1086838">


pkgId: f498ffaee15d23da7ec758102b3d4f5204d8e6ec66d8b6f9d3f521d2a14990c4
name: python-backup_warden
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Streamline your backup management with ease and simplicity
url: https://pypi.org/project/backup_warden/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backup_warden-1.0.8-1.src.rpm
checksum_type: sha256
description:
  In today's digital landscape, every business is taking backups of their data (hopefully). These backups can be challenging as they often require substantial disk space and/or cloud storage that can lead to significant financial expenses. If you're in search of a solution to handle your backups and retain only the necessary ones according to your retention policies, look no further! With Backup Warden, it will supervise and maintain your backups simplifying your overall data life cycle and enabling you to have smarter resource utilization.

  Thanks to xolox for his work on [rotate-backups](https://github.com/xolox/python-rotate-backups) that gave me a lot of inspiration for this project!



  | Option                      | Description                                                                                    | Default Value            |
  | --------------------------- | ---------------------------------------------------------------------------------------------- | ------------------------ |
  | `--minutely`                | Number of minutely backups to preserve                                                         | `0`                      |
  | `--hourly`                  | Number of hourly backups to preserve                                                           | `72`                     |
  | `--daily`                   | Number of daily backups to preserve                                                            | `7`                      |
  | `--weekly`                  | Number of weekly backups to preserve                                                           | `6`                      |
  | `--monthly`                 | Number of monthly backups to preserve                                                          | `12`                     |
  | `--yearly`                  | Number of yearly backups to preserve                                                           | `always`                 |
  | `-c`, `--config`            | Location of the config file                                                                    | `/etc/backup_warden.ini` |
  | `-s`, `--source`            | Source of where the backups are stored. Select from: `local`, `ssh`, `s3`                      | `local`                  |
  | `-b`, `--bucket`            | Name of the AWS S3 bucket                                                                      |                          |
  | `-p`, `--path`              | Specify a path to traverse all directories it contains for granular retention policies         |                          |
  | `-e`, `--environment`       | Environment the backups are rotated in (used for Slack alert only)                             |                          |
  | `-t`, `--timestamp-pattern` | The timestamp pattern using a regex expression to parse out of filenames                       |                          |
  | `-l`, `--log-file`          | Enable logging to this file path                                                               |                          |
  | `-I`, `--include`           | Include backups based on their directory path and/or filename (separated by comma)             |                          |
  | `-E`, `--exclude`           | Exclude backups based on their directory path and/or filename (separated by comma)             |                          |
  | `-H`, `--ssh-host`          | SSH host/alias to use                                                                          |                          |
  | `--ssh-sudo`                | Wrap SSH commands with sudo for escalated privileges                                           | `False`                  |
  | `--filestat`                | Use the file's last modified date instead of parsing timestamp from filename                   | `False`                  |
  | `--prefer-recent`           | Keep the most recent backup in each time slot instead of oldest                                | `False`                  |
  | `--relaxed`                 | Time windows are not enforced                                                                  | `False`                  |
  | `--utc`                     | Use UTC timezone instead of local machine's timezone for timestamps                            | `False`                  |
  | `--syslog`                  | Use syslog                                                                                     | `False`                  |
  | `--debug`                   | Log debug messages that can help troubleshoot                                                  | `False`                  |
  | `--delete`                  | Commit to deleting backups (DANGER ZONE)                                                       | `False`                  |
  | `-V`, `--version`           | Display version and exit                                                                       |                          |
  | `-h`, `--help`              | Show this help message and exit                                                                |                          |

  **Note**: Boolean options such as `--filestat` can be specified as `yes`/`no`, `true`/`false`, or `1`/`0` in the config





  - These options determine the number of backups to retain for each respective frequency
  - You have the flexibility to provide an expression that will be evaluated to calculate a value. For example, using `--hourly=5+2` would result in 7
  - Alternatively, you can specify "always" as the value to preserve all backups for that particular frequency


  There are currently three available sources, each functioning differently when scanning directories to find backups.

  - `local`

  This option is straightforward and doesn't really require any additional explanation. It is a simple method for locating backups

  - `ssh`

  To use this source, you need to configure the SSH config file (`~/.ssh/config`) with the relevant host information. It also supports aliases defined in the SSH config, as well as jump hosts

  - `s3`

  One thing to note is the `s3_endpoint_url` option. This lets you specify an endpoint other than the default to be able to use an alternative like DigitalOcean Spaces (i.e. `https://nyc3.digitaloceanspaces.com`)



  **Using Config File**

  When `path` is used under the `[main]` section in config, it significantly alters Backup Warden's functionality. In this case, Backup Warden will traverse through every directory and file under the given path until it locates a backup. Once a backup is found, it associates the backup with a config section using `fnmatch` for pattern matching that defines its retention policy. If there isn't a config section that matches all possibilities of a path found, it's ignored. If `path` is not specified, Backup Warden will only scan the path defined in each config section.

  Using the `path` option provides granular control over retention policies and allows for flexible path name conventions. It enables you to define custom retention rules based on very specific paths.

  **Using Parameters**

  `--path` is the same as using `path` under `[main]` section in config.

  **Note**: Specifying a `path` may result in a performance impact if there are a lot of non-backup directories/files within the specified path. This shouldn't be an issue though unless your setup is very abnormal. You can use `exclude_list` to help out if this is a scenario.



  The `timestamp-pattern` option provides the flexibility to customize the regular expression used for extracting timestamps from filenames. The value for this option should be a Python-compatible regular expression that includes the named capture groups 'year', 'month', and 'day'. Additionally, it can optionally include the groups 'hour', 'minute', and 'second'. 'unixtime' is also supported (see below for how to use it)

  Here is an example of the default regular expression:

  ```r

  (?P<year>\d{4} ) \D?
  (?P<month>\d{2}) \D?
  (?P<day>\d{2}  ) \D?
  (?:
      
      (?P<hour>\d{2}  ) \D?
      (?P<minute>\d{2}) \D?
      (?P<second>\d{2})?
  )?
  ```

  Regular expressions are compiled using the [re.VERBOSE](https://docs.python.org/3/library/re.html#re.VERBOSE) flag which ignores whitespace, including newlines.

  If your backups utilize Unix timestamps instead of standard timestamps, you can specify a pattern like:

  ```r
  (?P<unixtime>\d+)
  ```



  In cases where your backup files do not contain a timestamp, you have the option to use the last modified time of the backup instead. However, it is important to note that when utilizing this parameter, you will also need to modify the `timestamp-pattern` to accurately identify which directories/files are considered backups. For example, if all of your backups have filenames starting with "backup-", you would change the `timestamp-pattern` to `backup-\S+`.

  If your backup file names are not standardized and do not follow a specific pattern, this feature is currently not supported.



  Backup Warden offers the `--relaxed` option to modify its default rotation behavior. By default, Backup Warden enforces strict time windows for each rotation scheme. However, with the `--relaxed` option, you can relax this enforcement. Here's a clear explanation/example of the difference between strict and relaxed rotation:

  - **Strict Rotation**: When the number of hourly backups to preserve is set to three, only backups created within the relevant time window (the hour of the most recent backup and the two hours leading up to it) will match the hourly frequency. Choose this option if your backups are created at regular intervals without any missed intervals

  - **Relaxed Rotation**: With the `--relaxed` option enabled, the three most recent backups will all match the hourly frequency and be preserved, regardless of the calculated time window. Choose this option if your backups are created at irregular intervals, as it allows for the preservation of more backups



  These options utilize `fnmatch`, allowing the use of asterisks as wildcards. This enables precise definition of which backups should be excluded from deletion. Include and exclude can be used together for fine-grained control.

  For example, to exclude the `cluster1` from Backup Warden's operations, you can use the `--exclude-list="*cluster1*"` argument. This ensures that any directories/files containing `cluster1` in their names will be excluded.

  To further expand the exclusion criteria, you can exclude backups from the year 2022 by using `--exclude-list="*cluster1*, *2022*"`.

  The same concept applies to the `exclude-list` option under each section in the config file:

  ```ini
  [/path/backups/*/logical]
  hourly = 72
  daily = 7
  weekly = 6
  monthly = 12
  yearly = always
  include_list =
  exclude_list = *cluster1*, *2022*
  ```

  Include functions in the opposite manner. If you want to only include specific backups, you can utilize this feature. It can be used as a command-line argument using `--include-list`, or as the `include_list` option in a config path section.



  Must be using Python 3.8+

  Using PyPi:
  ```shell
  pip install backup-warden

  backup-warden --config config/example.ini
  ```

  Using Poetry:
  ```shell
  curl -sSL https://install.python-poetry.org | python3 -

  poetry install

  poetry run backup-warden --config config/example.ini
  ```



  Backup Warden offers two methods for setting it up: parameters and a config file. The recommended approach is to use a config file, which allows customization of directory paths and their respective retention policies. You can find examples of the config file [here](https://github.com/charles-001/backup-warden/tree/main/example_configs)

  With a config file, each section represents a specific path containing backups to be rotated. Within each section, you can define the rotation scheme and other options. Please refer to the above information for detailed instructions on how to utilize pattern matching effectively when using the `path` option.

  **Note**: If you specify a config file along with config path(s), command-line parameters will have no effect. The methods are not interchangeable.

  Under the `[main]` section in the config file, you can set the following options:

  - `bucket`
  - `path`
  - `source`
  - `environment`
  - `ssh_host`
  - `ssh_sudo`
  - `syslog`
  - `log_file`
  - `s3_endpoint_url`
  - `s3_access_key_id`
  - `s3_secret_access_key`
  - `slack_webhook`

  For each config `[path]` section, you can set the following options:

  - `minutely`, `hourly`, `daily`, `weekly`, `monthly`, `yearly`
  - `timestamp_pattern`
  - `include_list`/`exclude_list`
  - `filestat`
  - `relaxed`
  - `prefer_recent`
  - `utc`

  You can also set the following options using environment variables, which will override the corresponding config values:

  - `S3_ENDPOINT_URL`
  - `AWS_ACCESS_KEY_ID`
  - `AWS_SECRET_ACCESS_KEY`
  - `AWS_SESSION_TOKEN`
  - `SLACK_WEBHOOK`



  When the `path` parameter is omitted under the `[main]` section, Backup Warden does not accept wildcarding for config sections. In this scenario, Backup Warden will solely scan the specified config sections without traversing through additional directories.

  This means that instead of scanning the entire file system or applying wildcards to match multiple paths, Backup Warden will focus solely on the directories specified within the config sections. It will not explore subdirectories or perform any recursive scanning.

  By adhering to this behavior, Backup Warden provides a targeted approach, limiting the scope of its backup scanning and rotation operations to the explicitly defined directories within the config sections.

  **Directory structure**
  ```shell
  /path/backups/logical/$backups
  /path/backups/physical/$backups
  ```

  **Config**
  ```ini
  [/path/backups/logical]
  hourly = 15
  daily = 3
  weekly = 5
  monthly = 12
  yearly = always

  [/path/backups/physical]
  hourly = 10
  daily = 7
  weekly = 4
  monthly = 12
  yearly = always
  ```
  This is a basic setup and works as you expect.



  When the `path` option is used under the `[main]` section, Backup Warden allows wildcarding to be applied flexibly within the config sections.

  By specifying the `path` option, you gain the ability to use wildcards to define the directories or files that Backup Warden should scan for backups. This enables a more dynamic and versatile approach. Backup Warden will effectively traverse through the specified paths, including subdirectories if necessary, to locate the backups based on the wildcard patterns provided.

  **Directory structure**
  ```shell
  /path/backups/cluster1/logical/$backups
  /path/backups/cluster2/logical/$backups
  /path/backups/cluster1/physical/$backups
  /path/backups/cluster2/physical/$backups
  ```

  **Config**
  ```ini
  [main]
  path=/path/backups

  [/path/backups/*/logical]
  hourly = 15
  daily = 3
  weekly = 5
  monthly = 12
  yearly = always

  [/path/backups/*/physical]
  hourly = 10
  daily = 7
  weekly = 4
  monthly = 12
  yearly = always
  ```
  Backup Warden's design incorporates hierarchical directory structure awareness, allowing for precise configuration and retention policies.

  By defining `/path/backups/*/logical` as a config section, Backup Warden acknowledges the wildcard (`*`) as a placeholder that matches any subdirectory under `/path/backups/` and assigns it to the `logical` config section.

  When a retention policy is set for a broader path, such as `path/backups`, it will not override or take precedence over a more specific path like `/path/backups/cluster1/logical`. Backup Warden's scanning and rotation operations respect the defined hierarchy, ensuring that retention policies are accurately applied to the corresponding backup directories without unintentionally affecting others.




  Backup Warden offers a convenient Slack integration feature that allows you to stay informed about your backups if you specify a Slack Webhook URL. Benefit from the following alerts:

  1. **Non-Backup Alert**: Get notified if a path doesn't have a backup in the past 24 hours
  2. **Success Alert**: Receive notification after a successful execution, along with detailed statistics about what it did
  3. **Failure Alert**: In case of a failed execution, be promptly notified to address any potential issues




  Backup Warden employs the following steps to carry out the backup rotation process:
  1. **Specify Paths**: You need to provide a `path` and/or use config sections for paths to inform Backup Warden about the locations where the backups are stored
  2. **Scan for Backups**: Backup Warden scans each specified path to locate backups. These backups can be in the form of either directories or files. Backup Warden identifies backups by searching for timestamps in their names. If you're using `filestat`, it will not look for a timestamp, but what you specify in place of it
  3. **Apply Rotation Scheme**: Backup Warden applies the defined rotation scheme to the identified backups. If the outcome doesn't align with your expectations, you can experiment with the `relaxed` and/or `prefer-recent` options to achieve the desired behavior
  4. **Backup Deletion**: Backups that are determined to be rotated based on the rotation scheme will be deleted if the `delete` option is passed. If it isn't, Backup Warden will skip the deletion step and preserve the rotated backups



  <img width="1598" alt="Screenshot 2023-07-01 at 3 50 57 AM" src="https://github.com/charles-001/backup-warden/assets/13244625/eda58941-605f-482a-8800-77f3a1086838">


pkgId: 0ce29c886d91390015221eb7bc3a6844f3a3a6dbbcfe947d29a5d6123e22a31f
name: python-backupmaster
arch: src
version: 1.2.19
epoch: 0
release: 1
summary: Backup import files across entire disk
url: https://pypi.org/project/backupmaster/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backupmaster-1.2.19-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/backupmaster.svg)](https://badge.fury.io/py/backupmaster)
  ![PyPI downloads](https://img.shields.io/pypi/dm/backupmaster)
  ![Python version](https://img.shields.io/badge/python-3.10+-brightgreen)
  ![Operating system](https://img.shields.io/badge/os-linux-brightgreen)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)

  Back up import files across entire disk
  - Scale to huge number of files
  - Detailed configuration possibilities to maximize performance
  - Perfect for files that are too volatile for a VCS like GIT and too important to lose



  Run
  ```shell
  backup
  ```

  ```shell
  pip install backupmaster
  ```


pkgId: 553929add3ace0ddf359825097b4e8b8968a6f40bd5f19bce29bef5aee741c8e
name: python-backupper-lf23
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Un semplice Python script per gestire i backups
url: https://github.com/lucaf23/backupper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-backupper-lf23-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Backupper è uno strumento Python per la gestione dei backup in formato ZIP o TAR



  Per installare Backupper, usa pip:

  ``` bash
  pip install backupper
  ```


  - Creazione di archivi ZIP e TAR.
  - Estrazione di archivi compressi ZIP o TAR.
  - Cancellazione di archivi, partendo dal meno recente.
  - Supporto per archivi solo ZIP protetti da password.


  ```
  Crea un backup della directory corrente in formato ZIP (default):
  backupper -c .

  Crea un backup della directory corrente in formato TAR:
  backupper -c -f tar .

  Estrai un archivio dalla directory corrente con nome corrispondente alla directory corrente e data più recente:
  backupper -x .

  Cancella un archivio specificando il formato tar, con nome directory corrente:
  backupper -d -f tar .
  ```


  Questo progetto è distribuito sotto licenza MIT. Vedi il file LICENSE per maggiori dettagli.


pkgId: 916de4e6ed2516000513af13befd0c8891516c2dbd0c5463b1a8a055ff4fb276
name: python-bacolonyzer
arch: src
version: 2.0.9
epoch: 0
release: 1
summary: Analyse timeseries of QFA images
url: https://github.com/judithbergada/bacolonyzer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bacolonyzer-2.0.9-1.src.rpm
checksum_type: sha256
description:
  BaColonyzer is a software to quantify the cell density of bacterial cultures
  from timecourse pictures. It uses image analysis tools to determine the fitness
  of spotted cultures of bacteria grown on solid agar.


pkgId: c6ebaf9725442d7366cd50c7a16f07d9b1c8bcd85f1a37da400cb54e485cd986
name: python-bacon-net
arch: src
version: 0.2.1
epoch: 0
release: 1
url: https://github.com/Haishi2016/bacon-net
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bacon-net-0.2.1-1.src.rpm
checksum_type: sha256
summary:
  A neural network architecture for building fully explainable neural network for arithmetic and gradient logic expression approximation.

description:
  **Bacon-Net** is a neural network architecture for building fully explainable neural network for arithmetic and gradient logic expression approximation. A Bacon-Net network can be used to discover an arithmetical or a logical expression that approximates the given dataset. And the result network is precisely explainable.

  This repository contains a family of 2-variable Bacon-Net implementations. Multiple Bacon-Net can be used together to expand the search space; And Bacon-Net can be stacked into a **Bacon-Stack** that handles arbitrary number of variables.

  The following table presents a list of famous formulas in different fields that are re-discovered using Bacon-Net using synthetic training data. All networks in this repository are implemented using [Keras](https://keras.io/) and Python.



  **Bacon-Poly2** can be used to discover 1-variable or 2-variable quadratic polynomials or linear polynomials. The following table lists some samples of Bacon-Poly2 re-discovering some of the well-known geometric formulas and physics formulas.

  > **NOTE**: Coefficients and constant terms will vary a little in different runs.

  | Formula                                               | Expression                                                                       | Bacon-Poly2 Explanation                                        |
  | ----------------------------------------------------- | -------------------------------------------------------------------------------- | -------------------------------------------------------------- |
  | Area of a circle                                      | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/circle-area.png)     | `z = 3.1416x^2`                                                |
  | Area of a ellipse                                     | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/ellipse-area.png)    | `z = 3.1416xy `                                                |
  | Newton's equation of motion (displacement)            | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/motion-equation.png) | `z = 4.905x^2 + 5.0x` _(initial speed = 5, acceleration=9.81)_ |
  | An arbitary 2-degree 2-variable polynomial expression | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/polynomial.png)      | `z = 1.0x^2 + 4.0xy + 4.0y^2 + 5.0`                            |
  | Einstein's mass-energy equivalence                    | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/e-mc2.png)           | `z = 0.0899x ` _(with c normalized to 0.299792458 m/s)_        |
  | Simple intergal                                       | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/intergal.png)        | `z = 0.5x^2 + <C>` _(C is determined by training data)_        |



  **Bacon-LSP3** evaluates four possible gradient logic relationships between two variables in space _I = [0, 1]_: full conjunction, full disjunction, product t-norm (medium hyperconjunction) and neutrality.

  Bacon-LSP3 can be used to reason the logic behind some simple decisions, like “a face image needs to show 2 eye features AND a mouth feature”

  | Relationship     | Plot                                                                       | Bacon-LSP3 Explanation |
  | ---------------- | -------------------------------------------------------------------------- | ---------------------- |
  | Full conjunction | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/lsp3-0.png)    | `min(A, B)`            |
  | Product t-norm   | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/lsp3-1_25.png) | `A * B `               |
  | Neutrality       | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/lsp3-0_5.png)  | `(A + B) / 2`          |
  | Full disjunction | ![](https://github.com/Haishi2016/bacon-net/raw/main/images/lsp3-1.png)    | `max(A, B)`            |



  Bacon-Stack expands on Bacon-Net and allows arbitrary number of variables. See [Back-Stack Architecture](#bacon-stack-architecture) for more details on Bacon-Stack design.



  Run the following command to install:

  ```python
  pip install bacon-net
  ```



  ```python
  from bacon.net import dataCreator
  from bacon.nets.poly2 import poly2


  net = poly2()



  x, y = dataCreator.create(1000, 1, lambda x: math.pi * x[0] * x[0], params=1)


  net.fit(x[0], x[1], y)


  m = net.explain(singleVariable=True)
  print("f(x) = " + m.string(4))


  p = net.predict(2.4)


  p = net.predict([1.0, 2.3, 4.3])
  ```



  To install Bacon-Net, along with the tools you need to develop and run tests, run the following command:

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

  To run all test cases, run the following command from the project's root folder:

  ```python
  pytest
  ```

  Please see [here](./docs/define-bacon-net.md) for instructions on creating a new Bacon-Net network.



  The idea behind Bacon-Net is simple: to construct a network that can do linear interpolation among a group of selected terms like _min(x,y)_ and _sin(x^2)_, as shown in the following diagram:

  ![](https://github.com/Haishi2016/bacon-net/raw/main/images/bacon-net.png)

  - **Input layer** contains two variables. For gradient logic expressions.
  - **Expansion layer** defines the search space. Each node in this layer represents a candidate expression for the final approximation. Obviously, it’s desirable to have minimum overlaps among the function curves.

  - **Interpolation layer** creates a linear interpolation of candidate terms from the expansion layer by adjusting weights associated with candidates.

  - **Aggregation layer** calculate the interpolation result, which is compared to the training data.

  It's also to feed the inputs to a family of Bacon-Net networks to search multiple expression spaces in parallel. A 1-active **Selection layer** is added on top to select the appropriate Bacon-Net in this case, as shown in the following diagram:

  ![](https://github.com/Haishi2016/bacon-net/raw/main/images/bacon-net-selection.png)



  A Bacon-Stack is recursively defined: a Bacon-Stack that handles _n_ variables (denoted as _B(n)_) is constructed by feeding variable _x(i)_ and the result of a _B(n-1)_ into a _B(2)_ network, which is a Bacon-Net, as shown in the following diagram:

  ![](https://github.com/Haishi2016/bacon-net/raw/main/images/bacon-stack.png)

  The following diagram illustrates how a 5-variable Bacon-Stack is implemented using Keras custom layers and multi-input features.

  ![](https://github.com/Haishi2016/bacon-net/raw/main/images/5-variable-stack.png)

  Bacon-Stack doesn't assume variables to be commutative. To explore permutation of variable orders, a **Permutation layer** is added at the bottom of the Bacon-Stack, as shown in the following diagram:

  ![](https://github.com/Haishi2016/bacon-net/raw/main/images/bacon-stack-selection.png)

  > **NOTE**: Before the permutation layer is implemented, Bacon-Stack is constrained to handle expressions that can be rewrite as binary trees with ordered parameters. For example, the network will have difficulties to understand `(a+b)*c+d*e`, but will be fine with `(a+b)*c+d+e`.



  When I was in high school in encountered with a BASIC program that used a brute-force method to discover a arithmetical expression to approximate a given dataset. I remembered the program was called “BACON”. However, it’s been unfruitful to find such references in Internet, so my memory may have failed me. Regardless, I’ve been wanting to recreate “BACON” all these years, and I finally got around to do it just now during my week off.

  As I research into explainable AI, I see an opportunity to combine “BACON” with AI so that we can build some precisely explainable AI networks, plus the benefit of implementing a parallelable, GPU-accelerated BACON using modern technologies.



  - **Bacon-Poly3**

    For degree 3 polynomial expressions

  - **Bacon-Trig2**

    For degree 2 trigonometic functions

  - **Bacon-LSP6**

    Explainable gradient logic network for decision making

  - **Bacon-CNN**

    Explainability layer on top of a CNN network

  - **Bacon-H1**

    A combination of selected Bacon-Net networks

  - **Bacon-Cal1**

    A simple calculus solver



  - Twitter: [@HaishiBai2010](https://twitter.com/HaishiBai2010)
  - LinkedIn: [Haishi Bai](https://www.linkedin.com/in/haishi/)


pkgId: 595008d06cf522c1ca46dd15a080335d5651a33d37f4e37327a26fd0f41a8e77
name: python-bacpypes3
arch: src
version: 0.0.98
epoch: 0
release: 1
summary: BACnet Communications Library
url: https://github.com/JoelBender/bacpypes3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bacpypes3-0.0.98-1.src.rpm
checksum_type: sha256
description:
  BACpypes3 provides a BACnet application layer and network layer written in Python3 for daemons, scripting, and graphical interfaces.


pkgId: 7e87fc2b8f8aff3675c7402e5fd464aba2f605a282059159ca1c6a0e3d6f4ad7
name: python-bacs
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Bundle Adjustment For Camera Systems
url: https://github.com/zauberzeug/bacs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bacs-0.1.11-1.src.rpm
checksum_type: sha256
description:
  This is a Python implementation of BACS, a bundle adjustment for camera systems with points at infinity.
  It was originally written in Matlab and published by Johannes Schneider, Falko Schindler, Thomas Läbe, and Wolfgang Förstner in 2012.



  Run

  ```bash
  python3 -m pip install bacs
  ```

  to install the library.
  Have a look at the [doc string](https://github.com/zauberzeug/bacs/blob/main/bacs/bacs.py#L47-L92) for explanation of the parameters.



  Make sure you have NumPy and SciPy installed:

  ```bash
  python3 -m pip install numpy scipy
  ```

  By running the provided examples with

  ```bash
  python3 main.py
  ```

  you can verify that BACS is working correctly (eg. there is no `git diff` in the results folder after execution).

  By pushing a new tag "vX.Y.Z" to the repository, the package will be automatically built and uploaded to PyPI.



  Further explanation and visualization can be found on the [BACS project page](https://www.ipb.uni-bonn.de/data-software/bacs/), the corresponding [Matlab demo](https://www.ipb.uni-bonn.de/html/software/bacs/v0.1/demo-v0.1.html) as well as the original [publication](https://www.isprs-ann-photogramm-remote-sens-spatial-inf-sci.net/I-3/75/2012/isprsannals-I-3-75-2012.pdf).


pkgId: a6106bef6c45702df6fc2d1d895256b7ba904c10a3bfcf1cd7377fad94beac1a
name: python-bactfit
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Coordinate transformations for bacterial cell masks
url: https://pypi.org/project/bactfit/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bactfit-0.1.6-1.src.rpm
checksum_type: sha256
description:
  [![License BSD-3](https://img.shields.io/pypi/l/bactfit.svg?color=green)](https://github.com/piedrro/bactfit/raw/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/bactfit.svg?color=green)](https://pypi.org/project/bactfit)
  [![Python Version](https://img.shields.io/pypi/pyversions/bactfit.svg?color=green)](https://python.org)

  A package for fitting the shape of rod shaped bacterial cells to an ideal cell model.
  This is an analogue of colicoords, but using allowing cells to have multiple bends as the cell midline can be an N degree polynomial.

  Once the cell model(s) have been generated, SMLM localisations can be transformed to an ideal cell model.
  This allows for the generation of heatmaps and cell renders that are representative of the cells in the dataset.

  Bactfit is compatible with binary masks and Picasso localisation data, see examples.
  Bactfit Cells and CellLists can be saved/loaded from hdf5 files.
  Multiple CellLists can also be combined and saved as a single CellList.

  BactFit has been integrated into **napari-moltrack** and **napari-bacseg**.

  Author: Piers Turner, Kapanidis Group, University of Oxford.



  Create new conda environment (or venv) and activate it:

      conda create -name bactfit python=3.9
      conda activate bactfit

  You can install `BactFit` via [pip]:

      pip install bactfit

  To update `BactFit` to the latest version, use:

      pip install bactfit --upgrade

  To install latest development version from [GitHub]:

      pip install git+https://github.com/piedrro/BactFit.git



  The cell models consist of polynomial midline and a cell radius.
  1) An initial midline is generated using a Voronoi diagram to the contour/outline of each cell.
  2) By buffering the midline using Shapely, a cell model is generated.
  3) This model is then optimised such that the directed hausdorff distance between the model and the cell contour/outline is minimised.



  The BactFit heatmap is generated by transforming the localisation coordinates to the ideal cell model.
  Heatmaps can be generated if the localisations include X and Y coordinates.
  This heatmap was made from 700 localisations originating from 800 cells, see example.

  ![Feature Image](examples/heatmap.png)



  The BactFit cell render is generated by transforming the localisation coordinates to the ideal cell model.
  Heatmaps can be generated using Picasso SMLM rendering so must include Picasso fit metrics alongside X and Y coordinates.
  This render was made from 700 localisations originating from 800 cells, see example.

  ![Feature Image](examples/render.png)

rpm_license:
  Copyright (c) 2024, Piers Turner All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * 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.  * Neither the name of 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: 4749bbfa63bd37175bc7bdeb0fdecd2fa4cbaddfdd7a5205be27148635a4b358
name: python-badam
arch: src
version: 1.2.2
epoch: 0
release: 1
url: https://github.com/Ledzy/BAdam
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-badam-1.2.2-1.src.rpm
checksum_type: sha256
summary:
  Package which implements the algorithm proposed by "BAdam: A Memory Efficient Full Parameter Training Method for Large Language Models".

description:
  Apache License
                             Version 2.0, January 2004
                          http://www.apache.org/licenses/

     TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

     1. Definitions.

        "License" shall mean the terms and conditions for use, reproduction,
        and distribution as defined by Sections 1 through 9 of this document.

        "Licensor" shall mean the copyright owner or entity authorized by
        the copyright owner that is granting the License.

        "Legal Entity" shall mean the union of the acting entity and all
        other entities that control, are controlled by, or are under common
        control with that entity. For the purposes of this definition,
        "control" means (i) the power, direct or indirect, to cause the
        direction or management of such entity, whether by contract or
        otherwise, or (ii) ownership of fifty percent (50%) or more of the
        outstanding shares, or (iii) beneficial ownership of such entity.

        "You" (or "Your") shall mean an individual or Legal Entity
        exercising permissions granted by this License.

        "Source" form shall mean the preferred form for making modifications,
        including but not limited to software source code, documentation
        source, and configuration files.

        "Object" form shall mean any form resulting from mechanical
        transformation or translation of a Source form, including but
        not limited to compiled object code, generated documentation,
        and conversions to other media types.

        "Work" shall mean the work of authorship, whether in Source or
        Object form, made available under the License, as indicated by a
        copyright notice that is included in or attached to the work
        (an example is provided in the Appendix below).

        "Derivative Works" shall mean any work, whether in Source or Object
        form, that is based on (or derived from) the Work and for which the
        editorial revisions, annotations, elaborations, or other modifications
        represent, as a whole, an original work of authorship. For the purposes
        of this License, Derivative Works shall not include works that remain
        separable from, or merely link (or bind by name) to the interfaces of,
        the Work and Derivative Works thereof.

        "Contribution" shall mean any work of authorship, including
        the original version of the Work and any modifications or additions
        to that Work or Derivative Works thereof, that is intentionally
        submitted to Licensor for inclusion in the Work by the copyright owner
        or by an individual or Legal Entity authorized to submit on behalf of
        the copyright owner. For the purposes of this definition, "submitted"
        means any form of electronic, verbal, or written communication sent
        to the Licensor or its representatives, including but not limited to
        communication on electronic mailing lists, source code control systems,
        and issue tracking systems that are managed by, or on behalf of, the
        Licensor for the purpose of discussing and improving the Work, but
        excluding communication that is conspicuously marked or otherwise
        designated in writing by the copyright owner as "Not a Contribution."

        "Contributor" shall mean Licensor and any individual or Legal Entity
        on behalf of whom a Contribution has been received by Licensor and
        subsequently incorporated within the Work.

     2. Grant of Copyright License. Subject to the terms and conditions of
        this License, each Contributor hereby grants to You a perpetual,
        worldwide, non-exclusive, no-charge, royalty-free, irrevocable
        copyright license to reproduce, prepare Derivative Works of,
        publicly display, publicly perform, sublicense, and distribute the
        Work and such Derivative Works in Source or Object form.

     3. Grant of Patent License. Subject to the terms and conditions of
        this License, each Contributor hereby grants to You a perpetual,
        worldwide, non-exclusive, no-charge, royalty-free, irrevocable
        (except as stated in this section) patent license to make, have made,
        use, offer to sell, sell, import, and otherwise transfer the Work,
        where such license applies only to those patent claims licensable
        by such Contributor that are necessarily infringed by their
        Contribution(s) alone or by combination of their Contribution(s)
        with the Work to which such Contribution(s) was submitted. If You
        institute patent litigation against any entity (including a
        cross-claim or counterclaim in a lawsuit) alleging that the Work
        or a Contribution incorporated within the Work constitutes direct
        or contributory patent infringement, then any patent licenses
        granted to You under this License for that Work shall terminate
        as of the date such litigation is filed.

     4. Redistribution. You may reproduce and distribute copies of the
        Work or Derivative Works thereof in any medium, with or without
        modifications, and in Source or Object form, provided that You
        meet the following conditions:

        (a) You must give any other recipients of the Work or
            Derivative Works a copy of this License; and

        (b) You must cause any modified files to carry prominent notices
            stating that You changed the files; and

        (c) You must retain, in the Source form of any Derivative Works
            that You distribute, all copyright, patent, trademark, and
            attribution notices from the Source form of the Work,
            excluding those notices that do not pertain to any part of
            the Derivative Works; and

        (d) If the Work includes a "NOTICE" text file as part of its
            distribution, then any Derivative Works that You distribute must
            include a readable copy of the attribution notices contained
            within such NOTICE file, excluding those notices that do not
            pertain to any part of the Derivative Works, in at least one
            of the following places: within a NOTICE text file distributed
            as part of the Derivative Works; within the Source form or
            documentation, if provided along with the Derivative Works; or,
            within a display generated by the Derivative Works, if and
            wherever such third-party notices normally appear. The contents
            of the NOTICE file are for informational purposes only and
            do not modify the License. You may add Your own attribution
            notices within Derivative Works that You distribute, alongside
            or as an addendum to the NOTICE text from the Work, provided
            that such additional attribution notices cannot be construed
            as modifying the License.

        You may add Your own copyright statement to Your modifications and
        may provide additional or different license terms and conditions
        for use, reproduction, or distribution of Your modifications, or
        for any such Derivative Works as a whole, provided Your use,
        reproduction, and distribution of the Work otherwise complies with
        the conditions stated in this License.

     5. Submission of Contributions. Unless You explicitly state otherwise,
        any Contribution intentionally submitted for inclusion in the Work
        by You to the Licensor shall be under the terms and conditions of
        this License, without any additional terms or conditions.
        Notwithstanding the above, nothing herein shall supersede or modify
        the terms of any separate license agreement you may have executed
        with Licensor regarding such Contributions.

     6. Trademarks. This License does not grant permission to use the trade
        names, trademarks, service marks, or product names of the Licensor,
        except as required for reasonable and customary use in describing the
        origin of the Work and reproducing the content of the NOTICE file.

     7. Disclaimer of Warranty. Unless required by applicable law or
        agreed to in writing, Licensor provides the Work (and each
        Contributor provides its Contributions) on an "AS IS" BASIS,
        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
        implied, including, without limitation, any warranties or conditions
        of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
        PARTICULAR PURPOSE. You are solely responsible for determining the
        appropriateness of using or redistributing the Work and assume any
        risks associated with Your exercise of permissions under this License.

     8. Limitation of Liability. In no event and under no legal theory,
        whether in tort (including negligence), contract, or otherwise,
        unless required by applicable law (such as deliberate and grossly
        negligent acts) or agreed to in writing, shall any Contributor be
        liable to You for damages, including any direct, indirect, special,
        incidental, or consequential damages of any character arising as a
        result of this License or out of the use or inability to use the
        Work (including but not limited to damages for loss of goodwill,
        work stoppage, computer failure or malfunction, or any and all
        other commercial damages or losses), even if such Contributor
        has been advised of the possibility of such damages.

     9. Accepting Warranty or Additional Liability. While redistributing
        the Work or Derivative Works thereof, You may choose to offer,
        and charge a fee for, acceptance of support, warranty, indemnity,
        or other liability obligations and/or rights consistent with this
        License. However, in accepting such obligations, You may act only
        on Your own behalf and on Your sole responsibility, not on behalf
        of any other Contributor, and only if You agree to indemnify,
        defend, and hold each Contributor harmless for any liability
        incurred by, or claims asserted against, such Contributor by reason
        of your accepting any such warranty or additional liability.

     END OF TERMS AND CONDITIONS

     APPENDIX: How to apply the Apache License to your work.

        To apply the Apache License to your work, attach the following
        boilerplate notice, with the fields enclosed by brackets "[]"
        replaced with your own identifying information. (Don't include
        the brackets!)  The text should be enclosed in the appropriate
        comment syntax for the file format. We also recommend that a
        file or class name and description of purpose be included on the
        same "printed page" as the copyright notice for easier
        identification within third-party archives.

     Copyright [2024] [Qijun Luo]

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

         http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.


pkgId: 8f7f3fadfc8eafb92c3e79b2d264a01b29fa8203646e841c0ae04bf5a1448e32
name: python-badapted
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Bayesian ADAPTive Experimental Design
url: https://github.com/drbenvincent/badapted
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-badapted-0.0.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/badapted.svg?color=green)](https://pypi.org/project/badapted/)

  **Status: Working code, but still under development 🔥**

  Run efficient Bayesian adaptive experiments.

  This code relates to the following pre-print. But, the pre-print is likely to appear in quite a different form when finally published.
  > Vincent, B. T., & Rainforth, T. (2017, October 20). The DARC Toolbox: automated, flexible, and efficient delayed and risky choice experiments using Bayesian adaptive design. Retrieved from psyarxiv.com/yehjb




  Below we outline how the `badapted` package can be used to run adaptive experiments. On it's own, this `badapted` package will not do anything. It also requires a few classes (and probably some helper functions) that a developer must create for their particular experimental paradigm. This forms a 'toolbox' which will allow adaptive experiments to be run in a particular experimental domain.

  The best (first) example of this is our [DARC Toolbox](https://github.com/drbenvincent/darc_toolbox) which allows adaptive experiments for Delayed And Risky Choice tasks.

  But below we outline how to go about creating a new 'toolbox' for your experimental domain of interest.




  First we create a pandas dataframe called `designs` using a function we write to do this. Each column is a design variable. Each row is a particular design.

  ```python
  def build_my_design_space(my_arguments):
      designs = # CREATE PANDAS DATAFRAME OF THE DESIGN SPACE HERE
      return designs
  ```



  In order to generate your own design generator that uses Bayesian Adaptive Design (in your experimental domain) then you need to create a class which subclasses `badapted.BayesianAdaptiveDesignGenerator`. You will also need to implement some methods specific to your experimental domain, notably:
  - `add_design_response_to_dataframe`
  - `df_to_design_tuple`

  For the moment, we will just provide the example we use in the DARC Toolbox. Firstly, our concrete design generator class is defined as:

  ```python
  from badapted.designs import BayesianAdaptiveDesignGenerator

  class BayesianAdaptiveDesignGeneratorDARC(DARCDesignGenerator, BayesianAdaptiveDesignGenerator):
      '''This will be the concrete class for doing Bayesian adaptive design
      in the DARC experiment domain.'''

      def __init__(self, design_space,
                   max_trials=20,
                   allow_repeats=True,
                   penalty_function_option='default',
                   λ=2):

          
          BayesianAdaptiveDesignGenerator.__init__(self, design_space,
                   max_trials=max_trials,
                   allow_repeats=allow_repeats,
                   penalty_function_option=penalty_function_option,
                   λ=λ)

          DARCDesignGenerator.__init__(self)
  ```

  Note that this has mulitple inheritance, so we also have a class `DARCDesignGenerator` which just includes DARC specific methods (`add_design_response_to_dataframe`, `df_to_design_tuple`). This is defined as:

  ```python
  from badapted.designs import DesignGeneratorABC
  from darc_toolbox import Prospect, Design


  class DARCDesignGenerator(DesignGeneratorABC):
      '''This adds DARC specific functionality to the design generator'''

      def __init__(self):
          
          DesignGeneratorABC.__init__(self)

          
          data_columns = ['RA', 'DA', 'PA', 'RB', 'DB', 'PB', 'R']
          self.data = pd.DataFrame(columns=data_columns)

      def add_design_response_to_dataframe(self, design, response):
          '''
          This method must take in `design` and `reward` from the current trial
          and store this as a new row in self.data which is a pandas data frame.
          '''

          trial_data = {'RA': design.ProspectA.reward,
                      'DA': design.ProspectA.delay,
                      'PA': design.ProspectA.prob,
                      'RB': design.ProspectB.reward,
                      'DB': design.ProspectB.delay,
                      'PB': design.ProspectB.prob,
                      'R': [int(response)]}
          self.data = self.data.append(pd.DataFrame(trial_data))
          
          self.data['R'] = self.data['R'].astype('int64')
          self.data = self.data.reset_index(drop=True)
          return

      @staticmethod
      def df_to_design_tuple(df):
          '''User must impliment this method. It takes in a design in the form of a
          single row of pandas dataframe, and it must return the chosen design as a
          named tuple.
          Convert 1-row pandas dataframe into named tuple'''
          RA = df.RA.values[0]
          DA = df.DA.values[0]
          PA = df.PA.values[0]
          RB = df.RB.values[0]
          DB = df.DB.values[0]
          PB = df.PB.values[0]
          chosen_design = Design(ProspectA=Prospect(reward=RA, delay=DA, prob=PA),
                              ProspectB=Prospect(reward=RB, delay=DB, prob=PB))
          return chosen_design
  ```

  We only did this multiple inheritance because we wanted other (non Bayesian Adaptive) design generators which worked in the DARC domain, but did not have any of the Bayesian Adaptive Design components. In most situations just focussing on Bayesian Adaptive Design, you could just define the `add_design_response_to_dataframe`, `df_to_design_tuple` classes in your one single concrete design generator class.




  You must provide a model class which inherits from `Model`. You must also provide the following methods:

  - `__init__`
  - `predictive_y`

  Here is an example of a minimal implimentation of a user-defined model:

  ```python
  from badapted.model import Model
  from badapted.choice_functions import CumulativeNormalChoiceFunc, StandardCumulativeNormalChoiceFunc
  from scipy.stats import norm, halfnorm, uniform
  import numpy as np


  class MyCustomModel(Model):
      '''My custom model which does XYZ.'''

      def __init__(self, n_particles,
                   prior={'logk': norm(loc=-4.5, scale=1),
                          'α': halfnorm(loc=0, scale=2)}):
          '''
          INPUTS
          - n_particles (integer).
          - prior (dictionary). The keys provide the parameter name. The values
          must be scipy.stats objects which define the prior distribution for
          this parameter.

          We provide choice functions in `badapted.choice_functions.py`. In this
          example, we define it in the __init__ but it is not necessary to happen
          here.
          '''
          self.n_particles = int(n_particles)
          self.prior = prior
          self.θ_fixed = {'ϵ': 0.01}
          self.choiceFunction = CumulativeNormalChoiceFunc

      def predictive_y(self, θ, data):
          '''
          INPUTS:
          - θ = parameters
          - data =

          OUTPUT:
          - p_chose_B (float) Must return a value between 0-1.
          '''

          
          k = np.exp(θ['logk'].values
          VA = data['RA'].values * 1 / (1 + k * data['DA'].values)
          VB = data['RB'].values * 1 / (1 + k * data['DB'].values)
          decision_variable = VB - VA

          
          p_chose_B = self.choiceFunction(decision_variable, θ, self.θ_fixed)
          return p_chose_B
  ```



  This is pretty straight-forward and there doesn't need to be any major customisation here.

  ```python
  def run_experiment(design_generator, model, max_trials):
      '''Run an adaptive experiment
      INPUTS:
      - design_generator: a class
      '''

      for trial in range(max_trials):
          design = design_generator.get_next_design(model)
          if design is None:
              break
          response = get_response(design)
          design_generator.enter_trial_design_and_response(design, response)
          model.update_beliefs(design_generator.data)

      return model
  ```

  Note that the `response = get_response(design)` line is up to you to impliment. What you do here depends on whether you are simulating responses or getting real responses from PsychoPy etc. The `run_experiment` function is just an example of how the various parts of the code work together. When running _actual_ experiments using PsychoPy, it is best to refer to the demo psychopy files we provide in the [DARC Toolbox](https://github.com/drbenvincent/darc_toolbox) as examples to see how this is done.



  ```python
  designs = build_my_design_space(my_arguments)
  design_generator = MyCustomDesignGenerator(designs, max_trials=max_trials)
  model = MyCustomModel()

  model = run_experiment(design_generator, model, max_trials)
  ```

  Note that use of the `run_experiment` function is just a demonstration of the logic of how things fit together. As mentioned, please refer to PsychoPy example experiments in the [DARC Toolbox](https://github.com/drbenvincent/darc_toolbox) to see how this all comes together in a PsychoPy experiment.



  - [DARC Toolbox](https://github.com/drbenvincent/darc_toolbox) for adpative Delayed and Risky Choice tasks.
  - [Adaptive Psychophysics Toolbox](https://github.com/drbenvincent/adaptive_psychophysics_toolbox) for psychophysical experiments. _[Note: still under active development.]_


pkgId: 44a9e3b7eb231bbbea93c2d14ade21410258c073ce5b1c66d42352da5ab24971
name: python-badbyte
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Deal with bad characters easily during exploit writing with badchars.
url: https://github.com/C3l1n/badbyte
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-badbyte-0.1.11-1.src.rpm
checksum_type: sha256
description:
  ![logo](https://raw.githubusercontent.com/C3l1n/badbyte/main/assets/logo.png)

  Deal with bad characters easily during exploit writing with badchars.



  1. [Installation](#Instalation)
  2. [Usage](#Usage)
     * [Cyclic pattern generate](#Cyclic-pattern-generate)
     * [Search for offset in cyclic pattern](#Search-for-offset-in-cyclic-pattern)
     * [Generate payload to check all characters](#Generate-payload-to-check-all-characters)
     * [Analyze memory dumped after trigger](#Analyze-memory-dumped-after-trigger)
  3. [Programatically use](#Programatically-use)



  using pip:
  ```bash
  pip3 install badbyte
  ```

  or from repo:
  ```bash
  git clone git@github.com:C3l1n/badbyte.git
  cd badbyte
  pip3 install .
  ```



  You can always use:
  ```bash
  badbyte --help
  ```



  It is useful to search for offset at which you should put your
  sniper shot constants. For example return address: you generate
  pattern with this function, trigger vulnerability  with
  generated payload. EIP value (remember about little ending in x86)
  has uniq part of pattern and offset of that part could be calculated
  with badbyte parse (see next chapter).

  ```bash
  badbyte c -u 4 -l 100 --bad "61 62"
  ```
  ![cyclegenerate](https://raw.githubusercontent.com/C3l1n/badbyte/main/assets/cyclegenerate.png)



  Search for offset of provided part in --pattern argument.
  ```
  badbyte o -u 4 -l 100 --bad "61 62" -p cocc
  ```
  ![cyclesearch](https://raw.githubusercontent.com/C3l1n/badbyte/main/assets/cyclesearch.png)


  ```bash
  badbyte g --bad "3d 26 25 0d" --pre START --post STOP
  ```

  ![generate-payloag](https://raw.githubusercontent.com/C3l1n/badbyte/main/assets/usage.png)

  use:
  * --bad to supply hexascii values of bad characters
  * --pre to set string for marking start point (or leave default)
  * --post to set string for marking stop point (or leave default)

  Then use payload in your exploit and fire it.



  Copy hexascii from memory dump of your favourite debugger i.e. windbg:

  ![dump-copy](https://raw.githubusercontent.com/C3l1n/badbyte/main/assets/windbg.png)

  remember to skip addresses and ascii representation. I use vim and column select or visual studio code and alt+shift select.

  ![select-hexdump](https://raw.githubusercontent.com/C3l1n/badbyte/main/assets/vscode.png)

  Fire badbyte to analyze output:

  ```bash
  badbyte p -c --pre START --post STOP
  ```

  ![analyze](https://raw.githubusercontent.com/C3l1n/badbyte/main/assets/analyze.png)



  Documentation not made (feel free to read code) but you can find in example/programatically_generate_payload.py example of payload generation in exploit.


pkgId: 22a82e6255ef003cc19ba7ddec1468b31857e68f65206695c8c04d79df98739a
name: python-baddns
arch: src
version: 1.1.869
epoch: 0
release: 1
summary: Check subdomains for subdomain takeovers and other DNS tomfoolery
url: https://github.com/blacklanternsecurity/baddns
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-baddns-1.1.869-1.src.rpm
checksum_type: sha256
description:
  Check subdomains for subdomain takeovers and other DNS tomfoolery

  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  ![License](https://img.shields.io/badge/license-GPLv3-f126ea.svg)
  [![tests](https://github.com/blacklanternsecurity/baddns/actions/workflows/tests.yaml/badge.svg)](https://github.com/blacklanternsecurity/baddns/actions/workflows/tests.yaml)
  [![codecov](https://codecov.io/gh/blacklanternsecurity/baddns/branch/main/graph/badge.svg)](https://codecov.io/gh/blacklanternsecurity/baddns)
  [![Pypi Downloads](https://img.shields.io/pypi/dm/baddns)](https://pypi.org/project/baddns)

  <p align="left"><img width="300" height="300" src="https://github.com/blacklanternsecurity/baddns/assets/24899338/2ca1fe25-e834-4df8-8b02-8bf8f60f6e31"></p>

  BadDNS is a standalone tool and [BBOT](https://github.com/blacklanternsecurity/bbot) module for detecting domain/subdomain takeovers of all kinds, including other DNS issues like NSEC walks and Subdomain Takeovers.

  Check out the [introductory blog](https://blog.blacklanternsecurity.com/p/introducing-baddns) on the BLS substack!



  We have a [pypi](https://pypi.org/project/baddns/) package, so you can just do `pip install baddns` to make use of the library.

  Or use pipx: `pipx install git+https://github.com/blacklanternsecurity/baddns`



  After installing with pip, you can just run `baddns` from the command line.

  ```
  usage: baddns [-h] [-n CUSTOM_NAMESERVERS] [-c CUSTOM_SIGNATURES] [-l] [-s] [-m MODULES] [-d] [target]

  Check subdomains for subdomain takeovers and other DNS tomfoolery

  positional arguments:
    target                subdomain to analyze

  options:
    -h, --help            show this help message and exit
    -n CUSTOM_NAMESERVERS, --custom-nameservers CUSTOM_NAMESERVERS
                          Provide a list of custom nameservers separated by comma.
    -c CUSTOM_SIGNATURES, --custom-signatures CUSTOM_SIGNATURES
                          Use an alternate directory for loading signatures
    -l, --list-modules    List available modules and their descriptions.
    -s, --silent          Show only vulnerable targets
    -m MODULES, --modules MODULES
                          Comma separated list of module names to use. Ex: module1,module2,module3
    -d, --debug           Enable debug logging

  ```

  |  Name      | Description |
  | ----------- | ----------- |
  | cname      | Check for dangling CNAME records and interrogate them for subdomain takeover opportunities |
  | ns   | Check for dangling NS records, and interrogate them for takeover opportunities |
  | mx   | Check for dangling MX records and assess their base domains for availability |
  | nsec | Enumerate subdomains by NSEC-walking |
  | references | Check HTML content for links or other references that contain a hijackable domain |
  | txt | Check TXT record contents for hijackable domains |
  | zonetransfer | Attempt a DNS zone transfer |



  * Simple check
  ```
  baddns subdomaintocheck.example.com
  ```
  * Specify Module(s)
  ```
  baddns -m CNAME subdomaintocheck.example.com
  baddns -m CNAME,NS subdomaintocheck.example.com
  ```
  * List available Modules
  ```
  baddns -l
  ```
  * Custom Nameservers
  ```
  baddns -n 1.1.1.1 subdomaintocheck.example.com
  ```


  Please visit our full [documentation](https://www.blacklanternsecurity.com/baddns) for many more details, including information about specific BadDNS modules.



  BadDNS Signatures are sourced primarily from [Nuclei Templates](https://github.com/projectdiscovery/nuclei-templates) and from [dnsReaper](https://github.com/punk-security/dnsReaper) by [Punk Security](https://punksecurity.co.uk/), although many have been modified or updated in BadDNS. Much of the research contained in the signatures was originally discussed on the issues page of [can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz).


pkgId: f1d66f8fafe936cf2c348091adb36b080a6f70d12e528046c90bb57837521492
name: python-badges-gitlab
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Generate badges for Gitlab Projects in Public and Private Repositories
url: https://pypi.org/project/badges-gitlab/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-badges-gitlab-1.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Pypi Version](https://img.shields.io/pypi/v/badges-gitlab)
  ![Status](https://img.shields.io/pypi/status/badges-gitlab)
  ![Python Version](https://img.shields.io/pypi/pyversions/badges-gitlab)
  ![License](https://gitlab.com/felipe_public/badges-gitlab/-/jobs/artifacts/main/raw/public/badges/license_name.svg?job=badges)
  ![Coverage](https://gitlab.com/felipe_public/badges-gitlab/badges/main/coverage.svg?job=coverage)
  ![Pipeline](https://gitlab.com/felipe_public/badges-gitlab/badges/main/pipeline.svg)
  [![Documentation Status](https://readthedocs.org/projects/badges-gitlab/badge/?version=latest)](https://badges-gitlab.readthedocs.io/en/latest/?badge=latest)




  This project was created to generate badges for Gitlab in CI jobs, mainly for private repositories where
  other common methods are not available (direct API Calls, shields.io, etc...).

  By default, Gitlab supports only two types of badges: pipeline and test coverage.

  These badges are better detailed at: [Gitlab Project Badges](https://docs.gitlab.com/ee/user/project/badges.html).



  You can install this package from pypi using pip.

  ```bash
  $ pip install badges-gitlab
  ```


  ```console
  usage: badges-gitlab [-h] [-p PATH] [-t TOKEN] [--junit-xml FILE_PATH] [-s LABEL MESSAGE COLOR]
  [-lb URLS [URLS ...]] [-V]

  Generate Gitlab Badges using JSON files and API requests. Program version v0.0.0.

  optional arguments:
    -h, --help            show this help message and exit
    -p TEXT, --path TEXT  path where json and badges files will be generated/located (default: ./public/badges/)
    -t TEXT, --token TEXT specify the private-token in command line (default: ${PRIVATE_TOKEN})
    --junit-xml TEXT      specifies the path of a JUnit XML file for parsing the test results
    -s LABEL MESSAGE COLOR, --static-badges LABEL MESSAGE COLOR
                          specify static badges in command line using lists
   -lb URLS [URLS ...], --link-badges URLS [URLS ...]
                          specify shields.io urls to download badges
    -V, --version         returns the package version
  ```


  Felipe Pinheiro Silva



  Benjamin Maréchal (irmo322)



  Slowly moving documentation to [ReadTheDocs](https://badges-gitlab.readthedocs.io/).


pkgId: d6c7aa4189621ecb0da552666dd1216897aa01df289030c3d6e66007167d2c11
name: python-badi-users
arch: src
version: 3.0.7
epoch: 0
release: 1
summary: Python Django Users
url: https://github.com/BadiDesign/badi_utils
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-badi-users-3.0.7-1.src.rpm
checksum_type: sha256
description:
  This is a package of users. You can use
  [BadiUsers github](https://github.com/BadiDesign/badi_users)
  to write your content.


pkgId: 96c3db5587a66794ef6f911795d0b459fe6e7e0dce504596de7e1d027c90a2cb
name: python-badkeys
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: Check cryptographic keys for known weaknesses
url: https://badkeys.info/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-badkeys-0.0.12-1.src.rpm
checksum_type: sha256
description:
  Tool and library to check cryptographic public keys for known vulnerabilities



  badkeys checks public keys in various formats for known vulnerabilities. A web version
  can be found at [badkeys.info](https://badkeys.info/).



  badkeys can be installed [via pip](https://pypi.org/project/badkeys/):
  ```
  pip3 install badkeys
  ```

  You may want to use a virtual environment. For details about different installation
  options, please [check the official Python documentation](
  https://packaging.python.org/en/latest/tutorials/installing-packages/). Alternatively,
  you can directly call _./badkeys-cli_ directly from the git repository.



  Before using badkeys, you need to download the blocklist data:
  ```
  badkeys --update-bl
  ```

  After that, you can call _badkeys_ and pass files with cryptographic public keys as the
  parameter:
  ```
  badkeys test.crt my.key
  ```

  It will automatically try to detect the file format. Supported are public and private
  keys in PEM format (both PKCS #1 and PKCS #8), X.509 certificates, certificate signing
  requests (CSRs) and SSH public keys. You can find some test keys in the _tests/data_
  directory.

  By default, badkeys will only output information about vulnerable keys, meaning no
  output will be generated if no vulnerabilities are found. The _-a_ parameter creates
  output for all keys.



  badkeys can scan SSH and TLS hosts and automatically check their public keys. This can
  be enabled with the parameters _-s_ (SSH) and _-t_ (TLS). By default, SSH will be
  scanned on port 22 and TLS will be scanned on several ports for common protocols
  (https/443, smtps/465, ldaps/636, ftps/990, imaps/993, pop3s/995 and 8443, which is
  commonly used as a non-standard https port).

  Alternative ports can be configured with _--tls-ports_ and _--ssh-ports_.

  TLS and SSH scanning can be combined:
  ```
  badkeys -ts example.org
  ```

  Note that the scanning modes have limitations. It is often more desirable to use other
  tools to collect TLS/SSH keys and scan them locally with badkeys.

  SSH scanning needs [paramiko](https://www.paramiko.org/) as an additional dependency.

  TLS scanning can't detect multiple certificates on one host (e.g. ECDSA and RSA). This
  is a [limitation of Python's ssl.get_server_certificate() function](
  https://bugs.python.org/issue31892).



  badkeys can also be used as a Python module. However, currently the software is in beta
  state and the API may change regularly.



  badkeys was written by [Hanno Böck](https://hboeck.de).

  This work was initially funded in 2022 by Industriens Fond through the CIDI project
  (Cybersecure IOT in Danish Industry) and the [Center for Information Security and Trust
  (CISAT)](https://cisat.dk/) at the IT University of Copenhagen, Denmark.


pkgId: 3494f1d3b8395587dba1b94f395157b2c5313bc93669ee3568a6b44c9c68a5e0
name: python-badsecrets
arch: src
version: 0.5.509
epoch: 0
release: 1
summary: About
url: https://pypi.org/project/badsecrets/
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-badsecrets-0.5.509-1.src.rpm
checksum_type: sha256
description:
  <p align="left"><img width="300" height="300" src="https://user-images.githubusercontent.com/24899338/223151619-6859bc93-1fe2-47c7-86a6-ecaa6b495ece.png"></p>

  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  ![License](https://img.shields.io/badge/license-GPLv3-f126ea.svg)
  ![Tests](https://github.com/blacklanternsecurity/badsecrets/actions/workflows/tests.yaml/badge.svg?branch=main)
  [![codecov](https://codecov.io/gh/blacklanternsecurity/badsecrets/branch/main/graph/badge.svg?token=2PAE7NUM07)](https://codecov.io/gh/blacklanternsecurity/badsecrets)
  [![Pypi Downloads](https://img.shields.io/pypi/dm/badsecrets)](https://pypi.org/project/badsecrets)


  A pure python library for identifying the use of known or very weak cryptographic secrets across a variety of platforms. The project is designed to be both a repository of various "known secrets" (for example, ASP.NET machine keys found in examples in tutorials), and to provide a language-agnostic abstraction layer for identifying their use.

  Knowing when a 'bad secret' was used is usually a matter of examining some cryptographic product in which the secret was used: for example, a cookie which is signed with a keyed hashing algorithm. Things can get complicated when you dive into the individual implementation oddities each platform provides, which this library aims to alleviate.

  Check out our full [blog post](https://blog.blacklanternsecurity.com/p/introducing-badsecrets) on the Black Lantern Security blog!

  Inspired by [Blacklist3r](https://github.com/NotSoSecure/Blacklist3r), with a desire to expand on the supported platforms and remove language and operating system dependencies.



  | Name     | Description |
  | ----------- | ----------- |
  | ASPNET_Viewstate      | Checks the viewstate/generator against a list of known machine keys. |
  | Telerik_HashKey   | Checks patched (2017+) versions of Telerik UI for a known Telerik.Upload.ConfigurationHashKey |
  | Telerik_EncryptionKey   | Checks patched (2017+) versions of Telerik UI for a known Telerik.Web.UI.DialogParametersEncryptionKey |
  | Flask_SignedCookies  | Checks for weak Flask cookie signing password. Wrapper for [flask-unsign](https://github.com/Paradoxis/Flask-Unsign) |
  | Peoplesoft_PSToken  | Can check a peoplesoft PS_TOKEN for a bad/weak signing password |
  | Django_SignedCookies   | Checks django's session cookies (when in signed_cookie mode) for known django secret_key |
  | Rails_SecretKeyBase   | Checks Ruby on Rails signed or encrypted session cookies (from multiple major releases) for known secret_key_base |
  | Generic_JWT | Checks JWTs for known HMAC secrets or RSA private keys |
  | Jsf_viewstate | Checks Both Mojarra and Myfaces implimentations of Java Server Faces (JSF) for use of known or weak secret keys |
  | Symfony_SignedURL | Checks symfony "_fragment" urls for known HMAC key. Operates on Full URL, including hash |
  | Express_SignedCookies_ES | Checks express.js express-session middleware for signed cookies and session cookies for known 'session secret' |
  | Express_SignedCookies_CS | Checks express.js cookie-session middleware for signed cookies and session cookies for known secret |
  | Laravel_SignedCookies | Checks 'laravel_session' cookies for known laravel 'APP_KEY' |
  | ASPNET_Vstate      | Checks for a once popular custom compressed Viewstate [code snippet](https://blog.sorcery.ie/posts/higherlogic_rce/) vulnerable to RCE|



  We have a [pypi](https://pypi.org/project/badsecrets/) package, so you can just do `pip install badsecrets` to make use of the library.



  The best way to use Badsecrets is by simply running `badsecrets` after doing a pip install:

  ```
  pip install badsecrets
  badsecrets eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo
  ```

  Under the hood, it's using the  `cli.py` example. The CLI can also be accessed manually without a pip installation:



  ```bash
  git clone https://github.com/blacklanternsecurity/badsecrets.git
  cd badsecrets
  python ./badsecrets/examples/cli.py eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo
  ```




  To use the examples, after doing the pip install just `git clone` the repo and `cd` into the `badsecrets` directory:

  ```
  git clone https://github.com/blacklanternsecurity/badsecrets.git
  cd badsecrets
  ```

  The commands in the example section below assume you are in this directory.

  If you are using the Badsecrets [BBOT](https://github.com/blacklanternsecurity/bbot) module, you don't need to do anything else - BBOT will install the package for you.




  Bad secrets includes an [example CLI](https://github.com/blacklanternsecurity/badsecrets/blob/dev/examples/cli.py) for convenience when manually checking secrets. As mentioned above, it is also accessible by just executing `badsecrets`, after a successful pip install.



  ```
  usage: badsecrets [-h] [-nc] [-u URL] [-nh] [-c CUSTOM_SECRETS] [-p PROXY] [-a USER_AGENT] [product ...]

  Check cryptographic products against badsecrets library

  positional arguments:
    product               Cryptographic product to check for known secrets

  options:
    -h, --help            show this help message and exit
    -nc, --no-color       Disable color message in the console
    -u URL, --url URL     Use URL Mode. Specified the URL of the page to access and attempt to check for secrets
    -nh, --no-hashcat     Skip the check for compatable hashcat commands when secret isn't found
    -c CUSTOM_SECRETS, --custom-secrets CUSTOM_SECRETS
                          include a custom secrets file to load along with the default secrets
    -p PROXY, --proxy PROXY
                          In URL mode, Optionally specify an HTTP proxy
    -a USER_AGENT, --user-agent USER_AGENT
                          In URL mode, Optionally set a custom user-agent

  ```

  * Basic usage - checking a crytographic product for a known secret (against all modules):

  ```bash
  badsecrets eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo
  ```
  It has a URL mode, which will connect to a target and attempt to carve for cryptographic products and check any it finds against all modules.

  * URL Mode

  ```bash
  badsecrets --url http://example.com/contains_bad_secret.html
  ```

  You can also set a custom user-agent with `--user-agent "user-agent string"` or a proxy with `--proxy http://127.0.0.1` in this mode.

  Example output:

  ```bash
  $ badsecrets eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo

   __ )              |                                |
   __ \    _` |   _` |   __|   _ \   __|   __|   _ \  __|   __|
   |   |  (   |  (   | \__ \   __/  (     |      __/  |   \__ \
  ____/  \__,_| \__,_| ____/ \___| \___| _|    \___| \__| ____/

  v0.3.337

  Known Secret Found!

  Detecting Module: Generic_JWT

  Product Type: JSON Web Token (JWT)
  Product: eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo
  Secret Type: HMAC/RSA Key
  Location: manual
  Secret: 1234
  Details: {'Issuer': 'Issuer', 'Username': 'BadSecrets', 'exp': 1593133483, 'iat': 1466903083, 'jwt_headers': {'alg': 'HS256'}}
  ```

  * Hashcat

  By default, when a secret is NOT found, the provided product will be checked for potential hashcat matches. If there is a match, a nearly complete hashcat command will be produced (potentially) suitable for cracking the product via hashcat. This can let you get those keys that may not be known, but are weak and still crackable. Not all modules are capable of producing hashcat output. This behavior can be disabled with the `--no-hashcat` option.

  ```
  badsecrets eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.qvkcSLMQPAQdEuRFv0h3aQIRpTfaI57GjXLOWI_6NaE
  ```

  Example output:

  ```
   __ )              |                                |
   __ \    _` |   _` |   __|   _ \   __|   __|   _ \  __|   __|
   |   |  (   |  (   | \__ \   __/  (     |      __/  |   \__ \
  ____/  \__,_| \__,_| ____/ \___| \___| _|    \___| \__| ____/

  v0.3.337

  No secrets found :(

  Potential matching hashcat commands:

  Module: [Flask_SignedCookies] Flask Signed Cookie Command: [hashcat -m 29100 -a 0 eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.qvkcSLMQPAQdEuRFv0h3aQIRpTfaI57GjXLOWI_6NaE <dictionary_file>]
  Module: [Generic_JWT] JSON Web Token (JWT) Algorithm: HS256 Command: [hashcat -m 16500 -a 0 eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.qvkcSLMQPAQdEuRFv0h3aQIRpTfaI57GjXLOWI_6NaE  <dictionary_file>]
  ```
  * Custom Secret Lists

  It is possible to specify a file containing additional secrets. These will be added to the default lists when the check is performed. This is accomplished with the `-c` / `--custom-secrets` flag. The provided value must be a valid file. There is a 100k size limit on the provided file.

  ```
  badsecrets eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.vKxsE0u-TrpoMQ5zmBv1_I-NXSgouq6iZJWMHbHSmgY -c test.txt
  ```

  Example output:

  ```
   __ )              |                                |
   __ \    _` |   _` |   __|   _ \   __|   __|   _ \  __|   __|
   |   |  (   |  (   | \__ \   __/  (     |      __/  |   \__ \
  ____/  \__,_| \__,_| ____/ \___| \___| _|    \___| \__| ____/

  v0.3.337

  Including custom secrets list [test.txt]

  Known Secret Found!

  Detecting Module: Generic_JWT

  Product Type: JSON Web Token (JWT)
  Product: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.vKxsE0u-TrpoMQ5zmBv1_I-NXSgouq6iZJWMHbHSmgY
  Secret Type: HMAC/RSA Key
  Location: manual
  Secret: fake123
  Details: {'sub': '1234567890', 'name': 'John Doe', 'iat': 1516239022, 'jwt_headers': {'alg': 'HS256', 'typ': 'JWT'}}
  ```



  *Note: This is now obsolete, since `cli.py` is now capable of handling machinekeys/generator values. It will remain included for reference.*
  *Example: `badsecrets KLox5XeGYfb7Lo8zFzr1YepUagXuixcxX55lpFht+rrW6VGheZi831vdusH6DCMfxIhsLG1EPU3OuPvqN2XBc/fj0ew15TQ1zBmmKWJVns4= AAAAAAAA`*

  Bad secrets includes a [fully functional CLI example](https://github.com/blacklanternsecurity/badsecrets/blob/dev/badsecrets/examples/blacklist3r.py) which replicates the functionality of [blacklist3r](https://github.com/NotSoSecure/Blacklist3r) in python badsecrets/examples/blacklist3r.


  ```bash
  python ./badsecrets/examples/blacklist3r.py --url http://vulnerablesite/vulnerablepage.aspx
  python ./badsecrets/examples/blacklist3r.py --viewstate /wEPDwUJODExMDE5NzY5ZGQMKS6jehX5HkJgXxrPh09vumNTKQ== --generator EDD8C9AE
  ```



  Fully functional CLI example for identifying known Telerik Hash keys (`Telerik.Upload.ConfigurationHashKey`) and Encryption keys (`Telerik.Web.UI.DialogParametersEncryptionKey`) used with Telerik DialogHandler instances for Post-2017 versions (those patched for CVE-2017-9248), and brute-forcing version / generating exploitation DialogParameters values.

  Currently, this appears to be the only tool capable of building a working exploit URL for "patched" versions of Telerik.

  ```bash
  python ./badsecrets/examples/telerik_knownkey.py --url http://vulnerablesite/Telerik.Web.UI.DialogHandler.aspx
  ```
  Optionally include ASP.NET MachineKeys with --machine-keys (Will SIGNIFICANTLY increase brute-forcing time)

  *Update: This utility will now, in addition to the `Telerik.Web.UI.DialogHandler.aspx` endpoint, also detect known `Telerik.AsyncUpload.ConfigurationEncryptionKey` keys in use via the `Telerik.Web.UI.WebResource.axd` endpoint.*

  ```bash
  python ./badsecrets/examples/telerik_knownkey.py --url http://vulnerablesite/Telerik.Web.UI.WebResource.axd
  ```

  *With a pip install, can now be run directly via the `telerik-knownkey` command*
  ```bash
  python telerik-knownkey --url http://vulnerablesite/Telerik.Web.UI.WebResource.axd
  ```



  Brute-force detection of Symfony known secret key when "\_fragment" URLs are enabled, even when no example URL containing a hash can be located. [Relevent Blog Post](https://www.ambionics.io/blog/symfony-secret-fragment).

  ```bash
  python ./badsecrets/examples/symfony_knownkey.py --url https://localhost/
  ```

  *With a pip install, can now be run directly via the `symfony-knownkey` command*
  ```bash
  python symfony-knownkey --url http://vulnerablesite/Telerik.Web.UI.WebResource.axd
  ```



  One of the best ways to use Badsecrets, especially for the `ASPNET_Viewstate` and `Jsf_viewstate` modules is with the Badsecrets [BBOT](https://github.com/blacklanternsecurity/bbot) module. This will allow you to easily check across thousands of systems in conjunction with subdomain enummeration.

  ```
  bbot -f subdomain-enum -m badsecrets -t evil.corp
  ```

  ![badsecrets](https://user-images.githubusercontent.com/24899338/227044294-59e0408e-c55f-481a-a494-7ee5dd0a39be.png)






  See if a token or other cryptographic product was produced with a known key

  ```python
  from badsecrets import modules_loaded

  Django_SignedCookies = modules_loaded["django_signedcookies"]
  ASPNET_Viewstate = modules_loaded["aspnet_viewstate"]
  Flask_SignedCookies = modules_loaded["flask_signedcookies"]
  Peoplesoft_PSToken = modules_loaded["peoplesoft_pstoken"]
  Telerik_HashKey = modules_loaded["telerik_hashkey"]
  Telerik_EncryptionKey = modules_loaded["telerik_encryptionkey"]
  Rails_SecretKeyBase = modules_loaded["rails_secretkeybase"]
  Generic_JWT = modules_loaded["generic_jwt"]
  Jsf_viewstate = modules_loaded["jsf_viewstate"]
  Symfony_SignedURL = modules_loaded["symfony_signedurl"]
  Express_SignedCookies_ES = modules_loaded["express_signedcookies_es"]
  Express_SignedCookies_CS = modules_loaded["express_signedcookies_cs"]
  Laravel_SignedCookies = modules_loaded["laravel_signedcookies"]
  ASPNET_Vstate = modules_loaded["aspnet_vstate"]

  x = ASPNET_Viewstate()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("AgF5WuyVO11CsYJ1K5rjyuLXqUGCITSOapG1cYNiriYQ6VTKochMpn8ws4eJRvft81nQIA==","EDD8C9AE")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  x = Telerik_HashKey()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("vpwClvnLODIx9te2vO%2F4e06KzbKkjtwmNnMx09D1Dmau0dPliYzgpqB9MnEqhPNe3fWemQyH25eLULJi8KiYHXeHvjfS1TZAL2o5Gku1gJbLuqusRXZQYTNlU2Aq4twXO0o0CgVUTfknU89iw0ceyaKjSteOhxGvaE3VEDfiKDd8%2B9j9vD3qso0mLMqn%2Btxirc%2FkIq5oBbzOCgMrJjkaPMa2SJpc5QI2amffBJ%2BsAN25VH%2BwabEJXrjRy%2B8NlYCoUQQKrI%2BEzRSdBsiMOxQTD4vz2TCjSKrK5JEeFMTyE7J39MhXFG38Bq%2FZMDO%2FETHHdsBtTTkqzJ2odVArcOzrce3Kt2%2FqgTUPW%2BCjFtkSNmh%2FzlB9BhbxB1kJt1NkNsjywvP9j7PvNoOBJsa8OwpEyrPTT3Gm%2BfhDwtjvwpvN7l7oIfbcERGExAFrAMENOOt4WGlYhF%2F8c9NcDv0Bv3YJrJoGq0rRurXSh9kcwum9nB%2FGWcjPikqTDm6p3Z48hEnQCVuJNkwJwIKEsYxJqCL95IEdX3PzR81zf36uXPlEa3YdeAgM1RD8YGlwlIXnrLhvMbRvQW0W9eoPzE%2FjP68JGUIZc1TwTQusIWjnuVubFTEUMDLfDNk12tMwM9mfnwT8lWFTMjv9pF70W5OtO7gVN%2BOmCxqAuQmScRVExNds%2FF%2FPli4oxRKfgI7FhAaC%2Fu1DopZ6vvBdUq1pBQE66fQ9SnxRTmIClCpULUhNO90ULTpUi9ga2UtBCTzI8z6Sb6qyQ52NopNZMFdrn9orzdP8oqFeyYpF%2BQEtbp%2F5AMENkFkWUxHZn8NoSlO8P6G6ubSyDdY4QJPaFS4FxNhhm85WlZC9xfEZ1AGSSBOu9JJVYiKxXnL1yYLqrlWp5mfBHZeUBwEa%2FMjGxZEVYDhXo4PiU0jxN7fYmjaobp3DSgA5H3BcFuNG5d8CUnOlQcEie5b%2BUHOpI9zAk7qcuEUXbaZ5Mvh0t2jXCRALRKYDyBdbHlWAFo10dTIM6L3aSTM5uEz9%2FalXLXoWlMo7dTDpuO5bBfTq7YkoPExL3g3JJX47UhuLq85i3%2Bzxfvd7r%2Fmid69kbD3PnX%2Bj0QxaiShhyOZg6jl1HMeRRXvZap3FPCIfxbCf7j2TRqB5gYefBIIdGYjrdiL6HS8SbjXcROMwh2Fxnt505X4jmkmDcGmneU3z%2B84TSSFewcSpxGEGvHVkkU4OaT6vyFwsxCmdrR187tQZ7gn3ZkAiTps%2FfOPcL5QWXja06Z%2FHT3zboq6Hj9v9NBHzpC1eAK0YN8r4V2UMI3P0%2FsIPQYXhovoeLjJwq6snKZTX37ulE1mbS1uOY%2BZrvFYbLN5DdNL%2B%2Bl%2F%2BcWIpc0RSYBLo19xHpKeoeLjU2sxaYzK%2B92D4zKANdPPvsHPqJD1Y%2FBwCL%2FfZKaJfRK9Bj09ez1Z1ixTEKjIRCwuxijnJGq33faZchbwpMPpTfv43jEriGwXwoqOo9Mbj9ggPAil7O81XZxNT4vv4RoxXTN93V100rt3ClXauL%2BlNID%2BseN2CEZZqnygpTDf2an%2FVsmJGJJcc0goW3l43mhx2U79zeuT94cFPGpvITEbMtjmuNsUbOBuw6nqm5rAs%2FxjIsDRqfQxGQWfS0kuwuU6RRmiME2Ps0NrBENIbZzcbgw6%2BRIwClWkvEG%2BK%2FPdcAdfmRkAPWUNadxnhjeU2jNnzI1yYNIOhziUBPxgFEcAT45E7rWvf8ghT08HZvphzytPmD%2FxuvJaDdRgb6a30TjSpa7i%2BEHkIMxM5eH1kiwhN6xkTcBsJ87epGdFRWKhTGKYwCbaYid1nRs7%2BvQEU7MRYghok8KMTueELipohm3otuKo8V4a7w4TgTSBvPE%2BLPLJRwhM8KcjGlcpzF1NowRo6zeJJhbdPpouUH2NJzDcp7P4uUuUB9Cxt9B986My6zDnz1eyBvRMzj7TABfmfPFPoY3RfzBUzDm%2FA9lOGsM6d9WZj2CH0WxqiLDGmP1Ts9DWX%2FsYyqEGK5R1Xpnp7kRIarPtYliecp50ZIH6nqSkoCBllMCCE6JN%2BdoXobTpulALdmQV0%2Bppv%2FAjzIJrTHgX7jwRGEAeRgAxTomtemmIaH5NtV7xt8XS%2BqwghdJl1D06%2FWhpMtJ1%2FoQGoJ0%2F7ChYyefyAfsiQNWsO66UNVyl71RVPwATnbRO5K5mtxn0M2wuXXpAARNh6pQTcVX%2FTJ4jmosyKwhI6I870NEOsSaWlKVyOdb97C3Bt0pvzq8BagV5FMsNtJKmqIIM0HRkMkalIyfow9iS%2B5xGN5eKM8NE4E6hO4CvmpG%2BH2xFHTSNzloV0FjLdDmj5UfMjhUuEb3rkKK1bGAVaaherp6Ai6N4YJQzh%2FDdpo6al95EZN2OYolzxitgDgsWVGhMvddyQTwnRqRY04hdVJTwdhi4TiCPbLJ1Wcty2ozy6VDs4w77EOAQ5JnxUmDVPA3vXmADJZR0hIJEsuxXfYg%2BRIdV4fzGunV4%2B9jpiyM9G11iiesURK82o%2BdcG7FaCkkun2K2bvD6qGcL61uhoxNeLVpAxjrRjaEBrXsexZ9rExpMlFD8e3NM%2B0K0LQJvdEvpWYS5UTG9cAbNAzBs%3DpDsPXFGf2lEMcyGaK1ouARHUfqU0fzkeVwjXU9ORI%2Fs%3D")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  x = Flask_SignedCookies()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("eyJoZWxsbyI6IndvcmxkIn0.XDtqeQ.1qsBdjyRJLokwRzJdzXMVCSyRTA")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  x = Peoplesoft_PSToken()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("qAAAAAQDAgEBAAAAvAIAAAAAAAAsAAAABABTaGRyAk4AdQg4AC4AMQAwABSpxUdcNT67zqSLW1wY5/FHQd1U6mgAAAAFAFNkYXRhXHicHYfJDUBQAESfJY5O2iDWgwIsJxHcxdaApTvFGX8mefPmAVzHtizta2MSrCzsXBxsnOIt9yo6GvyekZqJmZaBPCUmVUMS2c9MjCmJKLSR/u+laUGuzwdaGw3o")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  x = Django_SignedCookies()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret(".eJxVjLsOAiEURP-F2hAuL8HSfr-BAPciq4ZNlt3K-O9KsoU2U8w5My8W4r7VsHdaw4zswoCdfrsU84PaAHiP7bbwvLRtnRMfCj9o59OC9Lwe7t9Bjb2OtbMkAEGQtQjekykmJy9JZIW-6CgUaCGsA6eSyV65s1Qya_xGKZrY-wPVYjdw:1ojOrE:bfOktjgLlUykwCIRIpvaTZRQMM3-UypscEN57ECtXis")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  x = Rails_SecretKeyBase()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("dUEvRldLekFNcklGZ3ZSbU1XaHJ0ZGxsLzhYTHlNTW43T3BVN05kZXE3WUhQOVVKbVA3Rm5WaSs5eG5QQ1VIRVBzeDFNTnNpZ0xCM1FKbzFZTEJISzhaNzFmVGYzME0waDFURVpCYm5TQlJFRmRFclYzNUZhR3VuN29PMmlkVHBrRi8wb3AwZWgvWmxObkFOYnpkeHR1YWpWZ3lnN0Y4ZW9xSk9LNVlQd0U4MmFsbWtLZUI5VzkzRkM4YXBFWXBWLS15L00xME1nVFp2ZTlmUWcxZVlpelpnPT0=--7efe7919a5210cfd1ac4c6228e3ff82c0600d841")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  x = Generic_JWT()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")


  x = Telerik_EncryptionKey()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("owOnMokk%2F4N7IMo6gznRP56OYIT34dZ1Bh0KBbXlFgztgiNNEBYrgWRYDBkDlX8BIFYBcBztC3NMwoT%2FtNF%2Ff2nCsA37ORIgfBem1foENqumZvmcTpQuoiXXbMWW8oDjs270y6LDAmHhCRsl4Itox4NSBwDgMIOsoMhNrMigV7o7jlgU16L3ezISSmVqFektKmu9qATIXme63u4IKk9UL%2BGP%2Fk3NPv9MsTEVH1wMEf4MApH5KfWBX96TRIc9nlp3IE5BEWNMvI1Gd%2BWXbY5cSY%2Buey2mXQ%2BAFuXAernruJDm%2BxK8ZZ09TNsn5UREutvNtFRrePA8tz3r7p14yG756E0vrU7uBz5TQlTPNUeN3shdxlMK5Qzw1EqxRZmjhaRpMN0YZgmjIpzFgrTnT0%2Bo0f6keaL8Z9TY8vJN8%2BEUPoq%2F7AJiHKm1C8GNc3woVzs5mJKZxMUP398HwGTDv9KSwwkSpHeXFsZofbaWyG0WuNldHNzM%2FgyWMsnGxY6S086%2F477xEQkWdWG5UE%2FowesockebyTTEn3%2B%2FqiVy%2FIOxXvMpvrLel5nVY%2FSouHp5n2URRyRsfo%2B%2BOXJZo7yxKQoYBSSkmxdehJqKJmbgxNp5Ew8m89xAS5g99Hzzg382%2BxFp8yoDVZMOiTEuw0J%2B4G6KizqRW9cis%2FELd0aDE1V7TUuJnFrX%2BlCLOiv100tKpeJ0ePMOYrmvSn0wx7JhswNuj%2BgdKqvCnMSLakGWiOHxu5m9Qqdm3s5sk7nsaxMkh8IqV%2BSzB9A2K1kYEUlY40II1Wun67OSdLlYfdCFQk4ED0N%2BV4kES%2F1xpGiaPhxjboFiiV%2BkvCyJfkuotYuN%2B42CqFyAyepXPA%2BR5jVSThT6OIN2n1UahUnrD%2BwKKGMA9QpVPTSiGLen2KSnJtXISbrl2%2BA2AnQNH%2BMEwYVNjseM0%2BAosbgVfNde2ukMyugo%2FRfrRM27cbdVlE0ms0uXhlgKAYJ2ZN54w1tPWhpGxvZtB0keWpZan0YPh8CBgzsAIMa04HMYLCtgUTqxKqANoKXSy7VIJUzg3fl%2F2WUELjpXK9gRcgexNWDNB1E0rHd9PUo0PvpB4fxSrRpb1LRryipqsuoJ8mrpOVrVMvjracBvtoykK3GrN%2FDUlXkSG%2FAeBQN7HwDJ9QPi3AtEOohp78Op3nmbItXo7IJUSjzBNzUYR8YPj6Ud7Fje9LZSwMBngvgx%2BOKy6HsV4ofOAU2%2FK1%2BfxI0KkCeoSso9NJHWgBD7ijfXUa1Hrc%2FuNU3mTlSSVp3VStQrJbQCkr4paaHYWeeO4pRZCDSBNUzs9qq3TDePwpEQc4QROrw5htdniRk26lFIFm%2Fzk2nC77Pg%2BrkRC1W%2BlRv0lyXsmXVBCe8F1szpWXHCxHNAJwKH%2FBb%2BV1k6AXFXVWPW5vADbXUvRu0s6KLaqu6a0KCB7dt3K2Ni%2FI6O%2FmISYXzknbMrwwakNfajbRF2ibodgR9R9xvoCoCXa3ka7%2Fejr%2BmsZ2HvPKUAffd2fNIWCQrejfpuIoOWiYx6ufN8E41HetCbYfvsI6JQfPOEdOYWI2px%2BLdfO3Nybq99%2BRSQOhjNZakBP54ozlCUfwgpLOmTBwsswZexv1RK5MIi8%2FWtjlJ%2FKjkYxdkFUlwggGS2xDwzcyl2%2FakNCQ5YmxjU8cRY7jZQRMo%2F8uTw5qa2MNZPaQGI18uRgr0i%2FTX3t57fJYCpMLXSaUKIdO7O%2FCQhIyGTS6KrPN%2B3%2FgUb%2BPQ1viGhpnWfGEYF9vhIlK57z8G8G82UQ3DpttD7M8mQ0KsmCOq75ECx9CWrWGk51vADlm%2BLEZ5oWjVMs%2FThki40B7tL7gzFrBuQksWXYeubMzZfFo4ZQ49di4wupHG5kRsyL2fJUzgpaLDP%2BSe6%2FjCnc52C7lZ3Ls0cHJVf9HRwDNXWM%2B4h8donNy5637QWK%2BV7mlH%2FL4xBZCfU9l6sIz%2FWHMtRaQprEem6a%2FRwPRDBiP65I2EwZLKGY8I%2F1uXJncwC8egLu82JY9maweI0VmJSmRcTf0evxqqe7vc9MqpsUlpSVNh4bFnxVIo5E4PGX70kVaTFe0vu1YdGKmFX5PLvkmWIf%2FnwfgPMqYsa0%2F09trboJ5LGDEQRXSBb7ldG%2FwLdOiqocYKAb91SMpn1fXVPBgkPM27QZxHnSAmWVbJR2%2FIhO%2BIVNzkgFAJlptiEPPPTxuBh%2BTT7CaIQE3oZbbJeQKvRkrt4bawTCOzciU%2F1zFGxubTJTSyInjQ8%2F1tVo7KjnxPKqGSfwZQN%2FeWL6R%2FpvCb%2BE6D4pdyczoJRUWsSNXNnA7QrdjgGNWhyOMiKvkDf3RD4mrXbul18WYVTsLyp0hvQsbdwBWOh7VlwfrWdy%2BklsttFi%2B%2BadKR7DbwjLTcxvdNpTx1WJhXROR8jwW26VEYSXPVqWnYvfyZo4DojKHMSDMbAakbuSJdkGP1d5w0AYbKlAcVQOqp9hbAvfwwLy4ErdIsOg0YEeCcnQVRAXwaCI9JvWWmM%2FzYJzE3X45A6lU9Pe7TAbft810MYh7lmV6Keb5HI6qXFiD%2B8khBZqi%2FsK6485k0a86aWLxOb4Eqnoc41x%2BYPv5CWfvP6cebsENo%3D%2BIUg0f64C4y77N4FZ6C82m5wMpvDQIHqx0ZFIHLhwMg%3D")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  x = Jsf_viewstate()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("wHo0wmLu5ceItIi+I7XkEi1GAb4h12WZ894pA+Z4OH7bco2jXEy1RSCWwjtJcZNbWPcvPqL5zzfl03DoeMZfGGX7a9PSv+fUT8MAeKNouAGj1dZuO8srXt8xZIGg+wPCWWCzcX6IhWOtgWUwiXeSojCDTKXklsYt+kzlVbk5wOsXvb2lTJoO0Q==")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")


  x = Symfony_SignedURL()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("https://localhost/_fragment?_path=_controller%3Dsystem%26command%3Did%26return_value%3Dnull&_hash=Xnsvx/yLVQaimEd1CfepgH0rEXr422JnRSn/uaCE3gs=")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")


  x = Express_SignedCookies_ES()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("s%3A8FnPwdeM9kdGTZlWvdaVtQ0S1BCOhY5G.qys7H2oGSLLdRsEq7sqh7btOohHsaRKqyjV4LiVnBvc")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  x = Express_SignedCookies_CS()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("foo=eyJ1c2VybmFtZSI6IkJib3RJc0xpZmUifQ==","zOQU7v7aTe_3zu7tnVuHi1MJ2DU")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")


  x = Laravel_SignedCookies()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("eyJpdiI6IlhlNTZ2UjZUQWZKVHdIcG9nZFkwcGc9PSIsInZhbHVlIjoiRlUvY2grU1F1b01lSXdveXJ0T3N1WGJqeVVmZlNRQjNVOWxiSzljL1Z3RDhqYUdDbjZxMU9oSThWRzExT0YvUmthVzVKRE9kL0RvTEw1cFRhQkphOGw4S2loV1ZrMkkwTHd4am9sZkJQd2VCZ3R0VlFSeFo3ay9wTlBMb3lLSG8iLCJtYWMiOiJkMmU3M2ExNDc2NTc5YjAwMGMwMTdkYTQ1NThkMjRkNTY2YTE4OTg2MzY5MzE5NGZmOTM4YWVjOGZmMWU4NTk2IiwidGFnIjoiIn0%3D")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")


  x = ASPNET_Vstate()
  print(f"###{str(x.__class__.__name__)}###")
  r = x.check_secret("H4sIAAAAAAAEAPvPyJ/Cz8ppZGpgaWpgZmmYAgAAmCJNEQAAAA==")
  if r:
      print(r)
  else:
      print("KEY NOT FOUND :(")

  ```


  An additional layer of abstraction above check_secret, which accepts a python requests.response object or a string

  ```python
  import requests
  from badsecrets import modules_loaded
  Telerik_HashKey = modules_loaded["telerik_hashkey"]

  x = Telerik_HashKey()

  res = requests.get(f"http://example.com/")
  r_list = x.carve(requests_response=res)
  print(r_list)

  telerik_dialogparameters_sample = """
  Sys.Application.add_init(function() {
      $create(Telerik.Web.UI.RadDialogOpener, {"_dialogDefinitions":{"ImageManager":{"SerializedParameters":"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mFauB5rhPHB28+RqBMxN2jCvZ8Kggw1jW3f/h+vLct0=","Width":"770px","Height":"588px","Title":"Image Manager"}
  """

  r_list = x.carve(body=telerik_dialogparameters_sample)
  print(r_list)

  ```


  ```python
  from badsecrets.base import check_all_modules

  tests = [
      "yJrdyJV6tkmHLII2uDq1Sl509UeDg9xGI4u3tb6dm9BQS4wD08KTkyXKST4PeQs00giqSA==",
      "eyJoZWxsbyI6IndvcmxkIn0.XDtqeQ.1qsBdjyRJLokwRzJdzXMVCSyRTA",
      "vpwClvnLODIx9te2vO%2F4e06KzbKkjtwmNnMx09D1Dmau0dPliYzgpqB9MnEqhPNe3fWemQyH25eLULJi8KiYHXeHvjfS1TZAL2o5Gku1gJbLuqusRXZQYTNlU2Aq4twXO0o0CgVUTfknU89iw0ceyaKjSteOhxGvaE3VEDfiKDd8%2B9j9vD3qso0mLMqn%2Btxirc%2FkIq5oBbzOCgMrJjkaPMa2SJpc5QI2amffBJ%2BsAN25VH%2BwabEJXrjRy%2B8NlYCoUQQKrI%2BEzRSdBsiMOxQTD4vz2TCjSKrK5JEeFMTyE7J39MhXFG38Bq%2FZMDO%2FETHHdsBtTTkqzJ2odVArcOzrce3Kt2%2FqgTUPW%2BCjFtkSNmh%2FzlB9BhbxB1kJt1NkNsjywvP9j7PvNoOBJsa8OwpEyrPTT3Gm%2BfhDwtjvwpvN7l7oIfbcERGExAFrAMENOOt4WGlYhF%2F8c9NcDv0Bv3YJrJoGq0rRurXSh9kcwum9nB%2FGWcjPikqTDm6p3Z48hEnQCVuJNkwJwIKEsYxJqCL95IEdX3PzR81zf36uXPlEa3YdeAgM1RD8YGlwlIXnrLhvMbRvQW0W9eoPzE%2FjP68JGUIZc1TwTQusIWjnuVubFTEUMDLfDNk12tMwM9mfnwT8lWFTMjv9pF70W5OtO7gVN%2BOmCxqAuQmScRVExNds%2FF%2FPli4oxRKfgI7FhAaC%2Fu1DopZ6vvBdUq1pBQE66fQ9SnxRTmIClCpULUhNO90ULTpUi9ga2UtBCTzI8z6Sb6qyQ52NopNZMFdrn9orzdP8oqFeyYpF%2BQEtbp%2F5AMENkFkWUxHZn8NoSlO8P6G6ubSyDdY4QJPaFS4FxNhhm85WlZC9xfEZ1AGSSBOu9JJVYiKxXnL1yYLqrlWp5mfBHZeUBwEa%2FMjGxZEVYDhXo4PiU0jxN7fYmjaobp3DSgA5H3BcFuNG5d8CUnOlQcEie5b%2BUHOpI9zAk7qcuEUXbaZ5Mvh0t2jXCRALRKYDyBdbHlWAFo10dTIM6L3aSTM5uEz9%2FalXLXoWlMo7dTDpuO5bBfTq7YkoPExL3g3JJX47UhuLq85i3%2Bzxfvd7r%2Fmid69kbD3PnX%2Bj0QxaiShhyOZg6jl1HMeRRXvZap3FPCIfxbCf7j2TRqB5gYefBIIdGYjrdiL6HS8SbjXcROMwh2Fxnt505X4jmkmDcGmneU3z%2B84TSSFewcSpxGEGvHVkkU4OaT6vyFwsxCmdrR187tQZ7gn3ZkAiTps%2FfOPcL5QWXja06Z%2FHT3zboq6Hj9v9NBHzpC1eAK0YN8r4V2UMI3P0%2FsIPQYXhovoeLjJwq6snKZTX37ulE1mbS1uOY%2BZrvFYbLN5DdNL%2B%2Bl%2F%2BcWIpc0RSYBLo19xHpKeoeLjU2sxaYzK%2B92D4zKANdPPvsHPqJD1Y%2FBwCL%2FfZKaJfRK9Bj09ez1Z1ixTEKjIRCwuxijnJGq33faZchbwpMPpTfv43jEriGwXwoqOo9Mbj9ggPAil7O81XZxNT4vv4RoxXTN93V100rt3ClXauL%2BlNID%2BseN2CEZZqnygpTDf2an%2FVsmJGJJcc0goW3l43mhx2U79zeuT94cFPGpvITEbMtjmuNsUbOBuw6nqm5rAs%2FxjIsDRqfQxGQWfS0kuwuU6RRmiME2Ps0NrBENIbZzcbgw6%2BRIwClWkvEG%2BK%2FPdcAdfmRkAPWUNadxnhjeU2jNnzI1yYNIOhziUBPxgFEcAT45E7rWvf8ghT08HZvphzytPmD%2FxuvJaDdRgb6a30TjSpa7i%2BEHkIMxM5eH1kiwhN6xkTcBsJ87epGdFRWKhTGKYwCbaYid1nRs7%2BvQEU7MRYghok8KMTueELipohm3otuKo8V4a7w4TgTSBvPE%2BLPLJRwhM8KcjGlcpzF1NowRo6zeJJhbdPpouUH2NJzDcp7P4uUuUB9Cxt9B986My6zDnz1eyBvRMzj7TABfmfPFPoY3RfzBUzDm%2FA9lOGsM6d9WZj2CH0WxqiLDGmP1Ts9DWX%2FsYyqEGK5R1Xpnp7kRIarPtYliecp50ZIH6nqSkoCBllMCCE6JN%2BdoXobTpulALdmQV0%2Bppv%2FAjzIJrTHgX7jwRGEAeRgAxTomtemmIaH5NtV7xt8XS%2BqwghdJl1D06%2FWhpMtJ1%2FoQGoJ0%2F7ChYyefyAfsiQNWsO66UNVyl71RVPwATnbRO5K5mtxn0M2wuXXpAARNh6pQTcVX%2FTJ4jmosyKwhI6I870NEOsSaWlKVyOdb97C3Bt0pvzq8BagV5FMsNtJKmqIIM0HRkMkalIyfow9iS%2B5xGN5eKM8NE4E6hO4CvmpG%2BH2xFHTSNzloV0FjLdDmj5UfMjhUuEb3rkKK1bGAVaaherp6Ai6N4YJQzh%2FDdpo6al95EZN2OYolzxitgDgsWVGhMvddyQTwnRqRY04hdVJTwdhi4TiCPbLJ1Wcty2ozy6VDs4w77EOAQ5JnxUmDVPA3vXmADJZR0hIJEsuxXfYg%2BRIdV4fzGunV4%2B9jpiyM9G11iiesURK82o%2BdcG7FaCkkun2K2bvD6qGcL61uhoxNeLVpAxjrRjaEBrXsexZ9rExpMlFD8e3NM%2B0K0LQJvdEvpWYS5UTG9cAbNAzBs%3DpDsPXFGf2lEMcyGaK1ouARHUfqU0fzkeVwjXU9ORI%2Fs%3D",
      "qAAAAAQDAgEBAAAAvAIAAAAAAAAsAAAABABTaGRyAk4AdQg4AC4AMQAwABRhZGwcBykRPNQv++kTK0KePPqVVGgAAAAFAFNkYXRhXHicHYc7DkBQAATnIUqVa3jxLRzApxJBrxA18bmdw1l2k9nZG/Bcxxjt4/An3NnYOVlZOMRL7ld0NAQ9IzUTMy0DeUpMqkYkso+ZGFNiKbRW//Pyb0Guzwtozw4Q",
      ".eJxVjLsOAiEURP-F2hAuL8HSfr-BAPciq4ZNlt3K-O9KsoU2U8w5My8W4r7VsHdaw4zswoCdfrsU84PaAHiP7bbwvLRtnRMfCj9o59OC9Lwe7t9Bjb2OtbMkAEGQtQjekykmJy9JZIW-6CgUaCGsA6eSyV65s1Qya_xGKZrY-wPVYjdw:1ojOrE:bfOktjgLlUykwCIRIpvaTZRQMM3-UypscEN57ECtXis",
      "eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo",
      "dUEvRldLekFNcklGZ3ZSbU1XaHJ0ZGxsLzhYTHlNTW43T3BVN05kZXE3WUhQOVVKbVA3Rm5WaSs5eG5QQ1VIRVBzeDFNTnNpZ0xCM1FKbzFZTEJISzhaNzFmVGYzME0waDFURVpCYm5TQlJFRmRFclYzNUZhR3VuN29PMmlkVHBrRi8wb3AwZWgvWmxObkFOYnpkeHR1YWpWZ3lnN0Y4ZW9xSk9LNVlQd0U4MmFsbWtLZUI5VzkzRkM4YXBFWXBWLS15L00xME1nVFp2ZTlmUWcxZVlpelpnPT0=--7efe7919a5210cfd1ac4c6228e3ff82c0600d841",
      "https://localhost/_fragment?_path=_controller%3Dsystem%26command%3Did%26return_value%3Dnull&_hash=Xnsvx/yLVQaimEd1CfepgH0rEXr422JnRSn/uaCE3gs=",
      "s%3A8FnPwdeM9kdGTZlWvdaVtQ0S1BCOhY5G.qys7H2oGSLLdRsEq7sqh7btOohHsaRKqyjV4LiVnBvc"
  ]

  for test in tests:
      r = check_all_modules(test)
      if r:
          print(r)
      else:
          print("Key not found!")
  ```



  ```python
  import requests
  from badsecrets.base import carve_all_modules



  res = requests.get(f"http://example.com/")
  r_list = carve_all_modules(requests_response=res)
  print(r_list)



  carve_source_text = """
      <html>
  <head>
  <title>Test</title>
  </head>
  <body>
  <p>Some text</p>
  <div class="JWT_IN_PAGE">
  <p>eyJhbGciOiJIUzI1NiJ9.eyJJc3N1ZXIiOiJJc3N1ZXIiLCJVc2VybmFtZSI6IkJhZFNlY3JldHMiLCJleHAiOjE1OTMxMzM0ODMsImlhdCI6MTQ2NjkwMzA4M30.ovqRikAo_0kKJ0GVrAwQlezymxrLGjcEiW_s3UJMMCo</p>
  </div>
  </body>
  </html>
  """

  r_list = carve_all_modules(body=carve_source_text)
  print(r_list)

  ```



  Nothing would make us happier than getting a pull request with a new module! But the easiest way to contribute would be helping to populate our word lists! If you find publicly available keys help us make Badsecrets more useful by submitting a pull request to add them.

  Requests for modules are always very welcome as well!



  - ~~Laravel~~
  - ~~Express~~
  - Research into network devices with default keys that are detectable via a cryptographic product (For example, Palo Alto Global Protect default masterkeys)


pkgId: 275891132c3c395ead6ad7362007b833db26cb080eb9451fdc82f0419dee4f9f
name: python-badwolf
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Docker based continuous integration and code lint review system for BitBucket
url: https://pypi.org/project/badwolf/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-badwolf-0.15.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img src="logo/vertical.png" alt="badwolf" height="150px"></p>



  [![Build Status](https://travis-ci.org/bosondata/badwolf.svg?branch=master)](https://travis-ci.org/bosondata/badwolf)
  [![codecov](https://codecov.io/gh/bosondata/badwolf/branch/master/graph/badge.svg)](https://codecov.io/gh/bosondata/badwolf)
  [![PyPI](https://img.shields.io/pypi/v/badwolf.svg)](https://pypi.python.org/pypi/badwolf)
  [![Docker Image](https://img.shields.io/docker/pulls/messense/badwolf.svg?maxAge=2592000)](https://hub.docker.com/r/messense/badwolf/)

  [What is badwolf](https://en.wikipedia.org/wiki/Bad_Wolf)

  Docker based continuous integration and code lint review system for BitBucket

  Features:

  1. Run tests in Docker container
  2. Supports multiple test scripts
  3. Supports multiple after success/failure scripts
  4. Supports E-mail/Slack notification
  5. Supports code linting



  Documentation can be built using Sphinx in `docs/` directory.



  MIT


pkgId: 37b24614686f9ef91849f91c7e3d59a2f84dd3abe92806d8e47e2f7b19acd06f
name: python-bafcode
arch: src
version: 1.1.7
epoch: 0
release: 1
summary: BafCode Framework CLI
url: https://github.com/aitelabranding/bafcode_cli
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bafcode-1.1.7-1.src.rpm
checksum_type: sha256
description:
  BafCode CLI is a powerful tool designed to streamline the setup and execution of the BafCode Framework. Whether you're a seasoned developer or just getting started, BafCode CLI simplifies the process of creating and developing AI agents.


  Quick Setup: Easily initialize a new BafCode project.
  Smooth Execution: Start the BafCode Framework with a simple command.
  Key Generation: Generate necessary keys for your project.
  Getting Started
  Here are the primary commands you'll use:

  **1. Setting Up a New Project**
  ```bash
  bafcode setup <project_name>
  ```
  **2. Starting the BafCode Framework**
  ```bash
  bafcode start
  ```
  **3. Generating a Key for your Project**
  ```bash
  bafcode generate:key
  ```

  **4. Make a tool file (it will generate api,prompt files and auto importing )**
  ```bash
  bafcode make tool <your_tool_name>
  ```

  **5. Make a prompt file (it will auto import it to __init__.py)**
  ```bash
  bafcode make prompt <your_prompt_name>
  ```

  **6. Make a api file (it will auto import it to __init__.py)**
  ```bash
  bafcode make api <your_api_name>
  ```
  **7. Make a llm file (it will auto import it to __init__.py)**
  ```bash
  bafcode make llm <your_llm_name>
  ```

  **Wrapping Up**
  BafCode CLI is your companion for effective and efficient AI agent development with the BafCode Framework. Dive in and start creating!


pkgId: 86613bad533ce396fff6ee328e201dbae181c575c9257ec51e22b3963a957f1b
name: python-bageltushare
arch: src
version: 0.0.1
epoch: 0
release: 1
url: https://github.com/bagelquant/bageltushare
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bageltushare-0.0.1-1.src.rpm
checksum_type: sha256
summary:
  A package for download China A market stock data using tushare api, and automatically store to a local database

description:
  This package provides two methods for multi-threaded looping downloads:

  ```python
  def date_loop_update(token: str,
                       database: Database,
                       api_name: str,
                       max_workers: int = 10) -> None:
      """
      Loop date update
      """
  ```
  > Initially, this method requires the **trade_cal** table. Use `update_and_replace` to download the **trade_cal** table.
  >
  The function process includes:
  1. Querying the latest `trade_date` in the local database for the corresponding `api_name`.
  2. Downloading data for each `trade_date` until today, using a multi-threading method.
  3. Appending new data to the local database.
  **Best use case:**
  - Use `date_loop_update` data to automatically update price data **(update to today)**
  ```python
  def daily_update():
      """daily update price data"""
      
      date_loop_api_names = (
      'daily',
      'adj_factor',
  		)
  		
      for api_name in date_loop_api_names:
          date_loop_update(token=TUSHARE_TOKEN,
                           database=MYSQL,
                           api_name=api_name)
  ```

  ```python
  def code_loop_update(token: str,
                       database: Database,
                       api_name: str,
                       max_workers: int = 10) -> None:
      """
      Loop code update
      """
  ```
  > Initially, this method requires the **stock_basic** table. Use `update_and_replace` to download the **stock_basic** table.
  >
  The function process includes:
  1. Querying the latest `stock_list` in the local database for the corresponding `api_name`.
  2. Querying the latest `trade_date` in the local database for the corresponding `ts_code`
  3. Downloading data for each `ts_code` using a multi-threading method, latest `trade_date` as start_date, today as end_date
  4. Appending new data to the local database.
  **Best use case:**
  - Use `code_loop_update` data to automatically update fundamental data **(update to today)**
  ```python
  def monthly_update():
      """daily update price data"""
      
      code_loop_api_names = (
      'balancesheet',
      'income',
      'cashflow',
  		)
  		
      for api_name in code_loop_api_names:
          code_loop_update(token=TUSHARE_TOKEN,
                           database=MYSQL,
                           api_name=api_name)
  ```

  - The loop update method will automatically update data to the present day.
  - Both methods use multi-threading; this may exceed Tushare API usage limits per minute. If limits are exceeded, the looping will pause for one minute and then continue.
  - Some Tushare APIs require a 'ts_code' as input. In such cases, use the 'code_loop_update' method. Example: balancesheet.
  - For price data, which doesn't require 'ts_code' as input, use the 'date_loop_update' method.


pkgId: f14545407ba4f2443c688d5876535a054a4296fb94495de311d58e0cc3822d28
name: python-bagit-create
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Create BagIt packages harvesting data from upstream sources
url: https://gitlab.cern.ch/digitalmemory/bagit-create
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bagit-create-0.1.11-1.src.rpm
checksum_type: sha256
description:
  Pre-requisites:
  ```bash

  yum install gcc krb5-devel python3-devel
  ```
  If you just need to run BagIt Create from the command line:
  ```bash

  pip install bagit-create

  bic --version

  bic --recid 2728246 --source cds
  ```

  BagIt-Create can be easily installed and used on LXPLUS (e.g. if you need access to mounted EOS folders):
  ```bash
  pip3 install bagit-create --user
  ```
  Check if `.local/bin` (where pip puts the executables) is in the path. If not `export PATH=$PATH:~/.local/bin`.

  Clone this repository and then install the package with the `-e` flag:
  ```bash

  git clone https://gitlab.cern.ch/digitalmemory/bagit-create
  cd bagit-create

  python -m venv env
  source env/bin/activate

  pip install -e .

  bic --version

  bic --url http://cds.cern.ch/record/2798105 -v

  pip install pytest oais_utils


  export INDICO_KEY=<YOUR_INDICO_KEY>
  export GITLAB_KEY=<YOUR_GITLAB_KEY>
  python -m pytest
  ```
  Code is formatted using **black** and linted with **flake8**. A VSCode settings file is provided for convenience.

  You usually just need to specify the location of the record you are trying to create a package for.
  You can do it by specifying the "Source" (see [supported sources](#supported-sources)) and the Record ID:
  ```bash
  bic --recid 2728246 --source cds
  ```
  or passing an URL (currently only works with CDS, Zenodo and CERN Open Data links):
  ```
  bic --url http://cds.cern.ch/record/2665537
  ```

  GitLab:
  ```
  bic --source gitlab --token <YOUR_TOKEN> --recid 104913 -vv
  ```
  CDS:
  ```bash

  bic --recid 1 --source cds

  bic --recid 1000 --source cds

  bic --recid 1000571 --source cds --dry-run

  bic --recid 2728246 --source cds
  ```
  ilcdoc:
  ```bash

  bic --source ilcdoc --recid 62959 --verbose
  bic --source ilcdoc --recid 34794 --verbose
  ```
  Zenodo
  ```bash
  bic --recid 3911261 --source zenodo --verbose
  bic --recid 3974864 --source zenodo --verbose
  ```
  Indico
  ```bash
  bic --recid 1024767 --source indico
  ```
  CERN Open Data
  ```bash
  bic --recid 1 --source cod --dry-run --verbose
  bic --recid 8884 --source cod --dry-run --verbose --alternate-uri
  bic --recid 8884 --source cod --dry-run --verbose
  bic --recid 5200 --source cod --dry-run --verbose
  bic --recid 8888 --source cod --dry-run --verbose
  bic --recid 10101 --source cod --dry-run --verbose
  bic --recid 10102 --source cod --dry-run --verbose
  bic --recid 10103 --source cod --dry-run --verbose
  bic --recid 10104 --source cod --dry-run --verbose
  bic --recid 10105 --source cod --dry-run --verbose
  bic --recid 10101 --source cod --verbose
  bic --recid 10102 --source cod --verbose
  bic --recid 10103 --source cod --verbose
  bic --recid 10104 --source cod --verbose
  bic --recid 10105 --source cod --verbose
  ```
  Some more advanced recipes can be found in the `examples/` folder.

  ```sh
    --version                       Show the version and exit.
    --recid TEXT                    Record ID of the resource the upstream
                                    digital repository. Required by every
                                    pipeline but local.
    -s, --source [cds|ilcdoc|cod|zenodo|inveniordm|indico|local|ilcagenda]
                                    Select source pipeline from the supported
                                    ones.
    -u, --url TEXT                  Provide an URL for the Record
                                    [Works with CDS, Open Data and Zenodo links]
    -d, --dry-run                   Skip downloads and create a `light` bag,
                                    without any payload.
    -a, --alternate-uri             Use alternative uri instead of https for
                                    fetch.txt (e.g. root endpoints  for CERN
                                    Open Data instead of http).
    -v, --verbose                   Enable basic logging (verbose, 'info'
                                    level).
    -vv, --very-verbose             Enable verbose logging (very verbose,
                                    'debug' level).
    -b, --bibdoc                    [ONLY for Supported Invenio v1 pipelines]
                                    Get metadata for a CDS record from the
                                    bibdocfile utility
                                    (`/opt/cdsweb/bin/bibdocfile` must be
                                    available in the system).
    --bd-ssh-host TEXT              [ONLY for Supported Invenio v1 pipelines]
                                    Specify SSH host to run bibdocfile. Access
                                    must be promptless. (See documentation for
                                    usage and configuration). By default uses
                                    the local machine.
    -t, --target TEXT               Output folder for the generated SIP. By
                                    default uses the same folder  the tool is
                                    being executed from.
    -sp, --source-path TEXT         [Local source ONLY, required] Set path of
                                    the local folder to use as a source.
    -u, --author TEXT               [Local source ONLY] Specify the Author of
                                    data.
    -sbp, --source-base-path TEXT   [Local source ONLY] Specify a part of the
                                    path as  relevant for extracting an
                                    hierachy.
    -ic, --invcookie TEXT           [Invenio v1.x ONLY] Use custom
                                    INVENIOSESSION cookie value to authenticate.
                                    Useful for local accounts.
    -ss, --skipssl                  [Invenio v1.x ONLY] Skip SSL authentication
                                    in HTTP requests. Useful for misconfigured
                                    or deprecated instances.
    -c, --cert TEXT                 [Invenio v1.x ONLY] Full path to the
                                    certificate to use to authenticate. Don't
                                    specify extension, only the file name. A
                                    '.key' and a '.pem' will be loaded. Read
                                    documentation (CERN SSO authentication) to
                                    learn more on how to generate it.
    --help                          Show this message and exit.
  ```


  | Name                 | Source ID | URL                                | Pipeline       |
  | -------------------- | --------- | ---------------------------------- | -------------- |
  | CERN Document Server | cds       | https://cds.cern.ch/               | Invenio v1.x   |
  | ILC Document Server  | ilcdoc    | http://ilcdoc.linearcollider.org   | Invenio v1.x   |
  | CERN Open Data       | cod       | https://opendata.cern.ch/          | CERN Open Data |
  | Zenodo               | zenodo    | https://zenodo.org/                | Invenio v3.x   |
  | CERN Indico          | indico    | https://indico.cern.ch/            | Indico v3.0.x  |
  | ILC Agenda           | ilcagenda | https://agenda.linearcollider.org/ | Indico v3.0.x  |
  | CodiMD               | codimd    | https://codimd.web.cern.ch/        | CodiMD         |
  | GitLab               | gitlab    | https://gitlab.cern.ch/            | GitLab         |
  Additional configuration may be required (e.g. for restricted events).

  Instead of passing Source + Record ID you can just use the record URL with the `--url` option.

  With the `--dry-run` option, BIC can create "light" bags skipping any payload download (i.e. attached files) but generating the same manifest (exposing upstream file locations and URLs), allowing the full bag to be "populated" in the future.

  Some pipelines require additional configuration (e.g. to authenticate).

  To use any Indico pipeline you need an API Token. From your browser, login to the Indico instance, go to "Preferences" and then "API Token". Create new token, name can be anything. Select (at least) `Everything (all methods)` and `Classic API (read only)` as scopes. Note down the token and set the `INDICO_KEY` environement variable to it.
  ```bash
  export INDICO_KEY=<INDICO_API_TOKEN>
  ```
  This will also allow you to run the tool for **restricted** events you have access to.


  BIC can run in a "authenticated" mode for Invenio v1.x pipelines (e.g. CDS) by getting CERN SSO HTTP cookies through the [cern-sso-python](https://gitlab.cern.ch/digitalmemory/cern-sso-python) tool.
  For this, you'll need to provide a Grid User certificate obtained from the [CERN Certification Authority](https://ca.cern.ch/ca/) of an account that has access to the desired restricted record.
  Once you downloaded your `.p12` certificate, you'll need to process the certificate files to remove passwords and separate the key and certificate:
  ```bash
  openssl pkcs12 -clcerts -nokeys -in myCert.p12 -out myCert.pem

  openssl pkcs12 -nocerts -in myCert.p12 -out myCert.tmp.key
  openssl rsa -in ~/private/myCert.tmp.key -out myCert.key
  ```
  > WARNING: openssl rsa.. command removes the passphrase from the private key. Keep it in a secure location.
  Once you have your `myCert.key` and `myCert.pem` files, you can run BagIt-Create with the `--cert` option, providing the path to those files (without extension, as it is assumed that your certificate and key files have the same base name and are located in the same folder, and that the key has the file ending `.key` and the certificate `.pem`). E.g.:
  ```bash
  bic --source cds --recid 2748063 --cert /home/avivace/Downloads/myCert
  ```
  Will make the tool look for "/home/avivace/Downloads/**myCert.key**" and "/home/avivace/Downloads/**myCert.pem**" and the pipeline will run authenticating every HTTP request with the obtained Cookies, producing a SIP of the desired restricted record.
  For more information, check the [cern-sso-python](https://gitlab.cern.ch/digitalmemory/cern-sso-python) docs.

  To authenticate with a local account (i.e. without CERN SSO), login on your Invenio v1.x instance with a browser and what your `INVENIOSESSION` cookie is set to.
  On Firefox, open the Developers tools, go in the "Storage" tab and select "Cookies", you should see an `INVENIOSESSION` cookie. Copy its value and pass it to BagIt Create with the `--token` option:
  ```bash
  bic --source cds --recid 2748063 --token <INVENIOSESSION_value_here>
  ```

  To create packages out of CodiMD documents, go to [https://codimd.web.cern.ch/](https://codimd.web.cern.ch/), authenticate and after the redirect to the main page open your browser developer tools (CTRL+SHIFT+I), go to the "Storage" tab and under cookies copy the value of the `connect.sid` cookie.
  The "Record ID" for CodiMD document is the part of the url that follows the main domain address (e.g. in `https://codimd.web.cern.ch/KabpdG3TTHKOsig2lq8tnw#` the recid is `KabpdG3TTHKOsig2lq8tnw`)
  ```bash
  bic --source codimd --recid vgGgOxGQU --token <connect.sid_value_here>
  ```

  A small script is included in this repository in `examples/codimd_history.py` which will dump your entire CodiMD "history" (the same history you see on the homepage), creating a bag for each document.
  Set the CODIMD_SESSION env variable to the value of the `connect.sid` cookie before running the script:
  ```bash
  CODIMD_SESSION=<connect.sid_value_here> python examples/codimd_history.py
  ```

  To export projects from CERN GitLab you'll need to provide a Personal access token of an user that has at least a "Maintainer" role on the target repository. This token will also be used to clone the repository.
  By default, only files from the default branch will be indexed in the metadata and in the SIP manifest. The exported package will however also contain a full copy of the git repository, including every available branch.
  A package created using the "dry run" flag will not contain the repository copy.


  BIC can easily be run inside other Python scripts. Just import it and use the `process` method with the same parameters you can pass to the CLI.
  E.g., this snippet creates SIP packages for CDS resources from ID 2728246 to 27282700.
  ```python
  import bagit_create
  for i in range(2728246, 27282700):
      result = bagit_create.main.process(
          source="cds", recid=i, loglevel=3
      )
      if result["status"] == 0:
          print("Success")
      else:
          print("Error")
  ```

  If the upstream source you're trying to access is firewalled, you can set up a SOCKS5 proxy via a SSH tunnel through LXPLUS and then run `bic` through it with tools like `proxychains` or `tsocks`. E.g.:
  Bring up the SSH tunnel:
  ```bash
  ssh -D 1337 -q -N -f -C lxplus.cern.ch
  ```
  The proxy will be up at `socks5://localhost:1337`. After having installed `tsocks`, edit the its configuration file (`/etc/tsocks.conf`) as follows:
  ```bash
  [...]
  server = localhost
  server_type = 5
  server_port = 1337
  [...]
  ```
  Now, just run `bic` as documented here but prepend `tsocks` to the command:
  ```bash
  tsocks bic --recid 1024767 --source indico -vv
  ```

  The `bibdocfile` command line utility can be used to get metadata for CDS, exposing internal file paths and hashes normally not available through the CDS API.
  If the executable is available in the path (i.e. you can run `/opt/cdsweb/bin/bibdocfile`) just append `--bibdoc`:
  ```bash
  bic --recid 2751237 --source cds --bibdoc -v
  ```
  If this is not the case, you can pass a `--bd-ssh-host` parameter specifying the name of an SSH configured connection pointing to a machine able to run the command for you. Be aware that your machine must be able to establish such connection without any user interaction (the script will run `ssh <THE_PROVIDED_SSH_HOST> bibdocfile ..args`).
  Since in a normal CERN scenario this can't be possible due to required ProxyJumps/OTP authentication steps, you can use the `ControlMaster` feature of any recent version of OpenSSH, allowing to reuse sockets for connecting:
  Add an entry in `~/.ssh/config` to set up the SSH connection to the remote machine able to run `bibdocfile` for you in the following way:
  ```bash
  Host <SSH_NAME>
    User <YOUR_USER>
    Hostname <HOSTNAME.cern.ch>
    ProxyJump <LXPLUS_or_AIADM>
    ControlMaster auto
    ControlPath ~/.ssh/control:%h:%p:%r
  ```
  Then, run `ssh <SSH_NAME>` in a shell, authenticate and keep it open. OpenSSH will now reuse this socket everytime you run `<SSH_NAME>`, allowing BagItCreate tool to run `bibdocfile` over this ssh connection for you, if you pass the `bd-ssh-host` parameter:
  ```bash
  bic --recid 2751237 --source cds --bibdoc --bd-ssh-host=<SSH_NAME> -v
  ```


pkgId: 9e81bc58362f6a07967ee856dbf13c216c0ae28b8dad32c780fd8ff9a0191046
name: python-bagit-profile
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: This module can be used to validate BagitProfiles.
url: https://github.com/bagit-profiles/bagit-profiles-validator
rpm_license: CC0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bagit-profile-1.3.1-1.src.rpm
checksum_type: sha256
description:
  Description
  ~~~~~~~~~~~
  A simple Python module for validating BagIt profiles. See the `BagIt
  Profiles Specification
  <https://github.com/bagit-profiles/bagit-profiles/blob/master/README.md>`__
  for more information.
  This module is intended for use with
  `bagit-python <https://github.com/LibraryOfCongress/bagit-python>`__ but does not extend it.
  Installation
  ~~~~~~~~~~~~
  ``bagit_profile.py`` is a single-file python module that you can drop into
  your project as needed or you can install globally with:
  1. ``git clone https://github.com/bagit-profiles/bagit-profiles-validator.git``
  2. ``cd bagit-profiles-validator``
  3. ``sudo python setup.py install``
  or:
  ``pip install bagit_profile``
  Usage
  ~~~~~
      import bagit
      import bagit_profile
  Instantiate an existing Bag using
  `bagit <https://github.com/LibraryOfCongress/bagit-python>`__.
  ``python bag = bagit.Bag('mydir')``
  Instantiate a profile, supplying its URI.
  ``python my_profile = bagit_profile.Profile('http://example.com/bagitprofile.json')``
  Validate 'Serialization' and 'Accept-Serialization'. This must be done
  before .validate(bag) is called. 'mydir' is the path to the Bag.
      if my_profile.validate_serialization('mydir'):
          print "Serialization validates"
      else:
          print "Serialization does not validate"
  Validate the rest of the profile.
      if my_profile.validate(bag):
          print "Validates"
      else:
          print "Does not validate"
  Or from the commandline:
  ``bagit_profile.py 'http://uri.for.profile/profile.json' path/to/bag``
  Test suite
  ~~~~~~~~~~
  ``python setup.py test``
  Development
  ~~~~~~~~~~~
  1. `Fork the
     repository <https://help.github.com/articles/fork-a-repo>`__
  2. Do something awesome!
  3. `Submit a pull
     request <https://help.github.com/articles/creating-a-pull-request>`__
     explianing what your code does
  License
  ~~~~~~~
     CC0


pkgId: 30e6d2da1733a8a481cef8af4acfc7e266044cf22f83f977d2def14ac18a251b
name: python-bago
arch: src
version: 0.0.27
epoch: 0
release: 1
summary: LC gradient optimization and evaluation
url: https://github.com/Waddlessss/BAGO
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bago-0.0.27-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Downloads](https://img.shields.io/pypi/dm/bago.svg?label=PyPI%20downloads)](
  https://pypi.org/project/bago/)


  BAGO is a Python package for Bayesian Optimization of Liquid Chromatographic Elution Gradient.

  - **Documentation:** https://bago.readthedocs.io/en/latest/
  - **Source code:** https://github.com/Waddlessss/bago
  - **Bug reports:** https://github.com/Waddlessss/bago/issues

  BAGO enables:

  Highly efficient gradient optimization
      Find an optimal gradient for your LC-MS/MS analysis within 10 runs.
      Wonder why BAGO is efficient? Read more about [acquisition functions](https://bago.readthedocs.io/en/latest/acq-func.html).

  Omics-scale evaluation on compound separation
      Separation efficiency was defined to evaluate the performance of a gradient.
      Wonder how omics-scale evaluation is achieved? Read more about [encodings](https://bago.readthedocs.io/en/latest/encodings.html).

  Broader discovery of chemical space
      Expand your discovery of chemical space by improving identification and quantification.
      Wonder how BAGO can help you? Read more about [applications](https://bago.readthedocs.io/en/latest/applications.html).


pkgId: 10dfe51ef6d851dcdce98a9739b1a721cac08b1831810f3c5c2ffe401766497c
name: python-bagpipes
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Galaxy spectral fitting
url: https://bagpipes.readthedocs.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bagpipes-1.2.0-1.src.rpm
checksum_type: sha256
description:
  **Bayesian Analysis of Galaxies for Physical Inference and Parameter EStimation**

  Bagpipes is a state of the art code for generating realistic model galaxy spectra and fitting these to spectroscopic and photometric observations. For further information please see the Bagpipes documentation at `bagpipes.readthedocs.io <http://bagpipes.readthedocs.io>`_.

  **Installation**

  Bagpipes can be installed with pip:

  .. code::

      pip install bagpipes

  Please note you cannot run the code just by cloning the repository as the large grids of models aren't included.

  **Sampling algorithms within Bagpipes**

  The default sampler (and historically the only option) for fitting models to data is the `MultiNest <https://github.com/JohannesBuchner/MultiNest>`_ code, however this requires separate installation, which can be challenging on some systems. Bagpipes is now also compatible with the pure Python `nautilus <https://github.com/johannesulf/nautilus>`_ nested sampling algorithm, which is now installed by default along with Bagpipes, and will be automatically used for fitting if MultiNest is not installed. Even if you are used to using Bagpipes with Multinest, you may wish to try out Nautlus, as this may yield faster and/or more accurate results in some circumstances. For more information please see the `bagpipes documentation <http://bagpipes.readthedocs.io>`_.

  **Published papers and citing the code**

  Bagpipes is described primarily in Section 3 of `Carnall et al. (2018) <https://arxiv.org/abs/1712.04452>`_, with further development specific to spectroscopic fitting described in Section 4 of `Carnall et al. (2019b) <https://arxiv.org/abs/1903.11082>`_. These papers are the best place to start if you want to understand how the code works.

  If you make use of Bagpipes, please include a citation to `Carnall et al. (2018) <https://arxiv.org/abs/1712.04452>`_ in any publications. You may also consider citing `Carnall et al. (2019b) <https://arxiv.org/abs/1903.11082>`_, particularly if you are fitting spectroscopy.

  Please note development of the code has been ongoing since these works were published, so certain parts of the code are no longer as described. Please inquire if in doubt.


  .. image:: docs/images/sfh_from_spec.png


pkgId: 9d7321b86a58d8500e996197b73acaa55c190099d82acd2ef9cfda10d965f197
name: python-baguetter
arch: src
version: 0.1.1
epoch: 0
release: 1
url: https://pypi.org/project/baguetter/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-baguetter-0.1.1-1.src.rpm
checksum_type: sha256
summary:
  Baguetter is a flexible and efficient search engine library implemented in Python. It supports sparse (traditional), dense (semantic), and hybrid retrieval methods.

description:
  Baguetter is a flexible, efficient, and hackable search engine library implemented in Python. It's designed for quickly benchmarking, implementing, and testing new search methods. Baguetter supports sparse (traditional), dense (semantic), and hybrid retrieval methods.

  **Note:** Baguetter is not built for production use-cases or scale. For such use-cases, please check out other search engine projects.

  Paper: https://arxiv.org/abs/2408.06643



  - Sparse retrieval using BM25 and BMX algorithms
  - Dense retrieval using embeddings
  - Hybrid retrieval combining sparse and dense methods
  - Customizable text preprocessing pipeline
  - Multi-threaded indexing and searching
  - Evaluation tools for benchmarking
  - Easy integration with HuggingFace datasets and models for sharing
  - Hackable interface to quickly implement new methods



  ```bash
  pip install baguetter
  ```



  ```python
  from baguetter.indices import BMXSparseIndex


  idx = BMXSparseIndex()


  docs = [
    "We all love baguette and cheese",
    "Baguette is a great bread",
    "Cheese is a great source of protein",
    "Baguette is a great source of carbs",
  ]
  doc_ids = ["1", "2", "3", "4"]

  idx.add_many(doc_ids, docs, show_progress=True)


  results = idx.search("quick fox")
  print(results)


  results = idx.search_many(["quick fox", "baguette is great"])
  print(results)
  ```



  Baguetter includes tools for evaluating search performance on standard benchmarks:

  ```python
  from baguetter.evaluation import datasets, evaluate_retrievers
  from baguetter.indices import BM25SparseIndex, BMXSparseIndex

  results = evaluate_retrievers(datasets.mteb_datasets_small, {"bm25": BM25SparseIndex, "bmx": BMXSparseIndex})
  results.save("eval_results")
  ```



  For more detailed usage instructions and API documentation, please refer to the [full documentation](https://github.com/mixedbread-ai/baguetter/docs).



  Contributions are welcome! We are using the GitHub Pull Request workflow. Either open an issue first and create a PR or include a comprehensive commit message when opening a PR.

  To get started, please create a clone of the repo (or a fork). We recommend working in a virtual environment.

  ```sh
  python -m pip install -e ".[dev]"

  pre-commit install
  ```

  To test your changes, run:

  ```sh
  pytest
  ```



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



  Baguetter builds upon the work of several open-source projects:

  1. [retriv](https://github.com/AmenRa/retriv) by [AmenRa](https://github.com/AmenRa):
     Baguetter is a fork of retriv, adjusting it to our needs.

  2. [bm25s](https://github.com/xhluca/bm25s) by [xhluca](https://github.com/xhluca):
     Our BM25 implementation is based on this project, which provides an efficient and effective implementation of the BM25 algorithm with different scoring functions.

  3. [USearch](https://github.com/unum-cloud/usearch) by [unum-cloud](https://github.com/unum-cloud) for dense retrival.

  4. [ranx](https://github.com/AmenRa/ranx) by [AmenRa](https://github.com/AmenRa) for evaluation.

  Please check out the respective repositories and show some appreciation to the authors.



  ```
  @article{li2024bmx,
        title={BMX: Entropy-weighted Similarity and Semantic-enhanced Lexical Search},
        author={Xianming Li and Julius Lipp and Aamir Shakir and Rui Huang and Jing Li},
        year={2024},
        eprint={2408.06643},
        archivePrefix={arXiv},
        primaryClass={cs.IR},
        url={https://arxiv.org/abs/2408.06643},
  }
  ```

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  Copyright 2024 mixedbread ai inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 5e356077854eb454028f3d0587de4a71298e2cacfb5d4a025416f7155ff5f068
name: python-bahamut-ani-stat
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Toolkit for Bahamut ani gamer data
url: https://github.com/Lee-W/bahamut_ani_stat
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bahamut-ani-stat-0.8.1-1.src.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
  [![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg?style=flat-square)](https://conventionalcommits.org)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  +[![Github Actions](git@github.com:Lee-W/bahamut_ani_stat.git/actions/workflows/python-check.yaml/badge.svg)](git@github.com:Lee-W/bahamut_ani_stat.git/actions/workflows/python-check.yaml)

  [![PyPI Package latest release](https://img.shields.io/pypi/v/bahamut_ani_stat.svg?style=flat-square)](https://pypi.org/project/bahamut_ani_stat/)
  [![PyPI Package download count (per month)](https://img.shields.io/pypi/dm/bahamut_ani_stat?style=flat-square)](https://pypi.org/project/bahamut_ani_stat/)
  [![Supported versions](https://img.shields.io/pypi/pyversions/bahamut_ani_stat.svg?style=flat-square)](https://pypi.org/project/bahamut_ani_stat/)




  Toolkit for Bahamut ani gamer data




  * [Python](https://www.python.org/downloads/)





  See [Contributing](contributing.md)


  Wei Lee <weilee.rx@gmail.com>


  +Created from [Lee-W/cookiecutter-python-template](https://github.com/Lee-W/cookiecutter-python-template/tree/1.6.0) version 1.6.0


pkgId: 0142e63cd62d320bea5521514239f78599fe6aeb43b06ecaeb32689f075f7316
name: python-bahub
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: Bahub is a File Repository API client that allows to totally automate the backups on your server
url: https://github.com/riotkit-org/file-repository
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bahub-2.0.6-1.src.rpm
checksum_type: sha256
description:
  Bahub (Backup Hub) is a shell client for the `File Repository` API.
  Allows to totally automate the backups on your server - the API is storing, versioning and rotating your backups,
  this client is sending them in a secure, encrypted way.
  Features:
  - Automatically schedule docker volumes backup
  - Encrypt backups with own key
  - Custom backup commands that are producing output to capture
  - MySQL backup examples


pkgId: 228a590bdd9c7cd59ffe1c01b053e48e22bde9084e55a460dfba10dd50618c2b
name: python-bai-file-processor
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: BAI File Parser
url: https://github.com/ankurCES/bai-file-processor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bai-file-processor-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Python module for parsing and writing Bai files.
  Built on top of BAI2 Python package with additional Export features added


pkgId: d7ba1cc61a3508a49816d71444dd4b82a4291b5d70e2e78c0056561b477f7179
name: python-bai2
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: BAI2 Parser
url: https://github.com/ministryofjustice/bai2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bai2-0.14.0-1.src.rpm
checksum_type: sha256
description:
  Python module for parsing and writing `BAI2`_ files.
  **The library is not production ready at the moment** as we don't have enough data to test against, please help us improve it.


pkgId: b8a56750f73e145f605fe3080ef6091e5ff54ed8c38f232e799ac1ec96fffe22
name: python-baidu-serp-api
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: A library to extract data from Baidu SERP and output it as JSON objects
url: https://github.com/ohblue/baidu-serp-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-baidu-serp-api-1.0.8-1.src.rpm
checksum_type: sha256
description:
  [English](#baidu-serp-api) | [中文](#百度SERP-API)



  A Python library to extract data from Baidu Search Engine Results Pages (SERP) and output it as JSON objects.



  ```bash
  pip install baidu-serp-api
  ```



  ```python
  from baidu_serp_api import BaiduPc, BaiduMobile

  pc_serp = BaiduPc()
  results = pc_serp.search('keyword', date_range='20240501,20240531', pn='2', proxies={'http': 'http://your-proxy-server:port'})
  print(results)

  m_serp = BaiduMobile()
  results = m_serp.search('keyword', date_range='day', pn='2', proxies={'http': 'http://your-proxy-server:port'})
  print(results)


  results = m_serp.search('关键词', exclude=['recommend', 'last_page', 'match_count'])
  ```



  - `keyword`: The search keyword.
  - `date_range` (optional): Search for results within the specified date range. the format should be a time range string like `'20240501,20240531'`, representing searching results between May 1, 2024, and May 31, 2024.
  - `pn` (optional): Search for results on the specified page.
  - `proxies` (optional): Use proxies for searching.



  - `{'code': 500, 'msg': '网络请求错误'}`: Network request exception.
  - `{'code': 501, 'msg': '百度安全验证'}`: Baidu security verification required.
  - `{'code': 404, 'msg': '未找到相关结果'}`: No relevant results found.
  - `{'code': 403, 'msg': '疑似违禁词'}`: Suspected prohibited word.
  - `{'code': 200, 'msg': 'ok', 'data': {'results': [], 'recommend': [], last_page': True}}`: Successful response.
      - `results` search results list.
      - `recommend` recommend keywords.
      - `last_page` indicates whether it's the last page.


  This project is intended for educational purposes only and must not be used for commercial purposes or for large-scale scraping of Baidu data. This project is licensed under the GPLv3 open-source license. If other projects utilize the content of this project, they must be open-sourced and acknowledge the source. Additionally, the author of this project shall not be held responsible for any legal risks resulting from misuse. Violators will bear the consequences at their own risk.





  一个用于从百度搜索结果页面（SERP）提取数据并将其输出为JSON对象的Python库。



  ```bash
  pip install baidu-serp-api
  ```



  ```python
  from baidu_serp_api import BaiduPc, BaiduMobile

  pc_serp = BaiduPc()
  results = pc_serp.search('关键词', date_range='20240501,20240531', pn='2', proxies={'http': 'http://你的代理服务器:端口'})
  print(results)

  m_serp = BaiduMobile()
  results = m_serp.search('关键词', date_range='20240501,20240531', pn='2', proxies={'http': 'http://你的代理服务器:端口'})
  print(results)


  results = m_serp.search('关键词', exclude=['recommend', 'last_page', 'match_count'])
  ```



  - `keyword`: 搜索关键词。
  - `date_range` (可选): 在指定日期范围内搜索结果。格式应为一个时间范围字符串，如 `'20240501,20240531'`，表示搜索2024年5月1日至2024年5月31日之间的结果。
  - `pn` (可选): 搜索指定页码的结果。
  - `proxies` (可选): 使用代理进行搜索。



  - `{'code': 500, 'msg': '网络请求错误'}`: 网络请求失败需要重试。
  - `{'code': 502, 'msg': '百度安全验证'}`: 需要进行百度安全验证。
  - `{'code': 404, 'msg': '未找到相关结果'}`: 未找到相关结果。
  - `{'code': 403, 'msg': '疑似违禁词'}`: 疑似违禁词。
  - `{'code': 200, 'msg': 'ok', 'data': {'results': [], 'last_page': True}}`: 成功响应。
      - `results` 搜索结果列表。
      - `recommend` 推荐相关搜索词。
      - `last_page` 表示是否为最后一页。



  本项目仅供学习之用，不可用于商业目的或大规模爬取百度数据。本项目采用GPLv3开源许可，若涉及到其他项目使用本项目内容，需开源并注明来源。同时，本项目作者不对滥用行为可能导致的法律风险承担责任，违者自负后果。


pkgId: ba671a1f9b4732823686c9c7023c57321e48d7c6d4df1a4188871d6f8c8afae2
name: python-baidusearch
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Baidu Search unofficial API for Python with no external dependencies
url: https://github.com/amazingcoderpro/python-baidusearch
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-baidusearch-1.0.3-1.src.rpm
checksum_type: sha256
description:
  自己手写的百度搜索接口的封装，pip安装，支持命令行执行。 Unofficial Baidu
  Search API for Python.
  It uses web scraping in the background and is compatible with both
  **Python 2 and 3**.


pkgId: 9a34f9e740b1898a61780b2fad52b5002fcffde4c503f385ecc78f0f50378971
name: python-baikalctl
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Top-level package for baikalctl.
url: https://pypi.org/project/baikalctl/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-baikalctl-1.1.0-1.src.rpm
checksum_type: sha256
description:
  ![Image](https://img.shields.io/github/license/rstms/baikalctl)
  ![Image](https://img.shields.io/pypi/v/baikalctl.svg)
  Baikal caldav/carddav server admin cli
  * Free software: MIT license
  * Documentation: https://baikalctl.readthedocs.io.


pkgId: f6b406827387ae2015dd57cf85006156ec8862d6eeb8ff8942f01e8ee7fe645e
name: python-baka-tenshi
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Baka: Skeleton framework built top of pyramid, baka_tenshi for sqlalchemy
url: https://github.com/baka-framework/baka_tenshi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-baka-tenshi-1.0.3-1.src.rpm
checksum_type: sha256
description:
  `Baka_tenshi <https://github.com/suryakencana/Baka_tenshi>`_. is add-ons baka framework built top of pyramid that provides an SQLAlchemy
  declarative ``Base`` alias model.Model and a add method on ``request.db``.


pkgId: ff8a200d9f750604c28dda84fc1152c2a09890ab66795e91d9131534bb9d8704
name: python-bakaweb-rozvrh
arch: src
version: 1.0
epoch: 0
release: 1
summary: Nástroj pro extrahování rozvrhu z Timetable modulu Bakawebu
url: https://github.com/MortikCZ/Bakaweb-Rozvrh
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bakaweb-rozvrh-1.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

    <h1>Bakaweb Rozvrh</h1>

    ![GitHub License](https://img.shields.io/github/license/MortikCZ/bakaweb-rozvrh)
    ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/MortikCZ/Bakaweb-Rozvrh)
    ![GitHub last commit](https://img.shields.io/github/last-commit/MortikCZ/Bakaweb-Rozvrh)

    <p>Jednoduchý nástroj pro extrakci rozvrhu z modulu Timetable Bakawebu. Data jsou získavána v HTML formátu a následně zpracována do JSON formátu.</p>

  </div>

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

  Tento nástroj je dostupný jako [PyPi balíček](https://pypi.org/project/bakaweb-rozvrh/). Pro instalaci je zapotřebí použít následující příkaz:
  ```bash
  pip install bakawebrozvrh
  ```

  <h2 align = "center">Použití</h2>

  Funkce `get_timetable` má dva povinné parametry:
  - `url` - URL adresa rozvrhu
  - `output_file` - název souboru, do kterého se uloží rozvrh.

  Vrací rozvrh ve formátu JSON.

  Funkce `get_substitutions` má dva povinné parametry:
  - `url` - URL adresa rozvrhu
  - `output_file` - název souboru, do kterého se uloží změny.

  Vrací změny v rozvrhu ve formátu JSON.


  ```python
  import bakawebrozvrh

  url = "https://bakalari.skola.cz/bakaweb/Timetable/Public/Permanent/Class/4U"
  output_file = "timetable.json"
  bakawebrozvrh.get_timetable(url, output_file)
  ```


pkgId: 5aebe960dee1fd052fea364c312c389c3af17e0eef89b737d21a8680d7cce7de
name: python-bakaweb-timetable
arch: src
version: 1.0
epoch: 0
release: 1
summary: Nástroj pro extrahování rozvrhu z Timetable modulu Bakawebu
url: https://github.com/MortikCZ/Bakaweb-Timetable
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bakaweb-timetable-1.0-1.src.rpm
checksum_type: sha256
description:
  Jednoduchý nástroj pro extrakci rozvrhu z modulu Timetable Bakawebu. Data jsou získavána v HTML formátu a následně zpracována do JSON formátu.


  Tento projekt je licencován pod licencí MIT. Pro více informací se podívejte do souboru `LICENSE`.


  ```python
  import bakaweb_timetable

  url = "https://bakalari.skola.cz/bakaweb/Timetable/Public/Permanent/Class/4U"
  output_file = "timetable.json"
  bakaweb_timetable.get_timetable(url, output_file)
  ```

  Je zapotřebí předat funkci `get_timetable` URL adresu rozvrhu a název souboru, do kterého se má rozvrh uložit, viz. příklad výše.


pkgId: 4bc33ff0301eff2b1252251cfd2664b5dfed86ef5738947aea5793f08bcb9fd1
name: python-bake-cli
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: The familar Make / Bash hybrid.
url: https://github.com/kennethreitz/bake
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bake-cli-0.12.0-1.src.rpm
checksum_type: sha256
description:
  I love using `Makefile` for one-off **tasks** in projects.
  The problem with doing this is that you can't use familiar bash–isms when doing so, as **GNU Make** doesn't use the familiar **Bash** syntax, nor does it allow for simple ad–hoc use of arbitrary scripting languages (e.g. **Python**).


pkgId: 2fb17d3f072d994c706d0d410598747bc962c517d07a197325d1a07c3255f271
name: python-bakeit
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: A command-line interface for Pastery, the best pastebin in the world.
url: https://github.com/skorokithakis/bakeit/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bakeit-0.2.3-1.src.rpm
checksum_type: sha256
description:
  BakeIt is a command line utility (and Python library) to
  `Pastery <https://www.pastery.net>`__, the best pastebin in the world.
  BakeIt aims to be simple to use and unobtrusive.


pkgId: 4b19ee9e73971c82629b7b1dc2663acf8949f4df48354121da94bd8a90c9ad30
name: python-bakery
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Tools to help students write code.
url: https://github.com/python-bakery/bakery-support-library
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bakery-1.0.0-1.src.rpm
checksum_type: sha256
description:
  A collection of tools to help students write code, meant for the Python Bakery CS1 curriculum.
  For now, mostly improved assertions.


pkgId: a37d48bbff97293f8b30b1a04f1d234124e98667012bab999b824ff603148226
name: python-bakplane-python-sdk
arch: src
version: 1.81.0
epoch: 0
release: 1
summary: A Python Client for Bakplane
url: https://github.com/openaristos/bakplane-python-sdk
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bakplane-python-sdk-1.81.0-1.src.rpm
checksum_type: sha256
description:
  Bakplane is the orchestration backbone for Dominus, FinFlo, and Fabrik.

  This SDK can be used to control ingestion sessions, mastering executions, plugin installation, etc.




  Installing the bakplane python client takes just a few seconds:

  ```bash
  pip install bakplane-python-sdk
  ```




  If you'd like to use Bakplane inside of Spark running in Docker:

  ```bash
  docker run -it --rm -p 8888:8888 --name pyspark jupyter/pyspark-notebook
  ```

  Inside of your notebook run:
  ```shell script
  !pip install bakplane-python-sdk
  ```

  >> Note: use `host.docker.internal` instead of `localhost` when testing.




  If you're interested in learning more then read the documentation: https://docs.openaristos.io/

  <h1 align="center">
      <img src="https://gist.githubusercontent.com/daefresh/32418b316dda99eb537fcef08b4c88af/raw/f4ed8e6fb4fd343eb61541c76871233d1105d2ec/bakplane_logo.svg" alt="Bakplane"/>
  </h1>

  Copyright (C) 2021 Aristos Data, LLC


pkgId: f7511d7086f80fa6b29916feb562b72d99bdcb1ff7d292c4be6345df081a1b6a
name: python-bakta
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: Bakta: rapid & standardized annotation of bacterial genomes, MAGs & plasmids
url: https://github.com/oschwengers/bakta
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bakta-1.10.0-1.src.rpm
checksum_type: sha256
description:
  `old id` | `new id`, `<empty>` | `chromosome`, `plasmid`, `contig`, `<empty>` | `circular`, `linear`, `<empty>` | `name`, `<empty>`
  For each input sequence recognized via the `original locus id` a `new locus id`, the replicon `type` and the `topology` as well a `name` can be explicitly set.
  Shortcuts:
  - `chromosome`: `c`
  - `plasmid`: `p`
  - `circular`: `c`
  - `linear`: `l`
  `<empty>` values (`-` / ``) will be replaced by defaults. If **new locus id** is `empty`, a new contig name will be autogenerated.
  Defaults:
  - type: `contig`
  - topology: `linear`
  Example:


pkgId: 5a7ebb8102296e4bc0961003cd4a60aa82abb1e37b0243faba13b5a8b1fb8b41
name: python-balaban
arch: src
version: 0.0.23
epoch: 0
release: 1
summary: Bayesian hierarchical models for football
url: https://github.com/anenglishgoat/balaban
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balaban-0.0.23-1.src.rpm
checksum_type: sha256
description:
  The basic goal of `balaban` is to improve the modelling of uncertainty in common player-level metrics (e.g., pass completion percentages,
  goals per 90, xG per shot, xA per 90). This is done through Bayesian hierarchical models for the 4 most common types of metric:
    1. Absolute counts per 90 (passes, shots, assists, goals, tackles etc.)
    2. Success rates (pass completion, tackle success, shots on target etc.)
    3. Model-derived 'expected' successes per action (xA per key pass, xG per shot)
    4. Model-derived 'expected' successes per 90 (xA, xG)

  If you have suggestions for other models you'd like to see, please let me know via [Twitter](https://twitter.com/AnEnglishGoat).

  Here's an [example notebook](https://colab.research.google.com/drive/1CRybRbZXe3Y6AkPh__7jaKCF9O2EaSa6#offline=true&sandboxMode=true).

  **TODO:**

     * ~~There appears to be a way of scraping with Selenium. This is great news and I'll write a function that just requires the league name to pull the latest data from fbref so users don't have to worry about downloading and formatting csv files.~~ This is done now. See the section on [Data Preparation](#data-preparation) below.
     * A few of the models are conjugate (don't require MCMC as they can be computed analytically) so I will write much faster sampling functions for those when I've got some time.
     * Something that will take more time is turning this thing into a Heroku web app. I really want it to be easy to produce the radar for any given player. I also want fans/analysts to acknowledge that quite often you can't really say much about how good a player is at a particular thing via these sort of stats. *When you can't, it's good to know that you can't.*

  **What does this get me?**

  The ultimate output is a radar-like plot of the model estimates for various metrics. The intensity of green represents our certainty
  about the players *percentile rank* for the given metric, taking into account sample size and the inherent variability of the metric.

  ![alt text](https://i.imgur.com/JlQadAq.png "Mikel Merino")

  Darker greens mean we're more confident in that value, so we're fairly sure that Merino's 'true' passing success rate is around the league
  median for midfielders. We're also fairly sure that he ranks pretty highly (somewhere around the 85th percentile) for successful passes
  into the final 3rd per 90. However, because assists are pretty rare and Merino hasn't done anything particularly spectacular, we're not
  very certain about his xA rankings, despite him having played a decent number of games. He's not particularly special and he's unlikely
  to be in the top 50% of expected assisters but, aside from that, we can't say much. It's important to remember that 'sample size'
  isn't just about the number of minutes played.

  The red numbers are the median and 90% credible intervals for the actual value we're trying to estimate (e.g., successful balls into the
  penalty area per 90). Essentially, we're 90% sure his true value lies between the two numbers in the brackets.


  **Who cares?**

  Probably not many people, but when assessing a player I think it's useful to have:
    * A reasonable estimate of the uncertainty associated with each metric (due to sample sizes, the general variability of the metric)
    * A reasonable estimate of the uncertainty associated with where players *rank* on each metric (i.e., their percentiles)
    * The use of prior information to temper crazy estimates from small sample sizes (you're average until you sufficiently prove otherwise)

  **Why hierarchical modelling?**

  It gets us all three of the things I mentioned above in a principled way. The 'hierarchical' part of the name comes from the fact that
  there are two levels to the model: the population level and the individual level. The idea is that we can use the data from *everybody* in the
  population (say all midfielders in La Liga) to give us an idea about what a reasonable estimate looks like. As an example, if a guy has played
  180 minutes and registered a pass completion percentage of 31%, we can use the information in the rest of the data to infer that he probably isn't *that* bad
  because there is practically nobody with a decent sample size who has that sort of pass completion level. However, we have learned a little
  bit about this player. We know he's probably not a *really* good passer, because a really good passer wouldn't be putting up such bad numbers
  even over a small number of passes. This is the tradeoff in hierarchical modelling. The resulting estimate, rather than just being a '31%' without
  much context, would be quite a wide distribution covering the lower portion of the population.




  You can install via `pip install balaban`.

  You can install by cloning this repo: `git clone https://github.com/anenglishgoat/balaban`

  Or you can modify this [Colab notebook](https://colab.research.google.com/drive/1CRybRbZXe3Y6AkPh__7jaKCF9O2EaSa6#offline=true&sandboxMode=true) by signing in with your Google account.

  Here is the usage pipeline:



  You have a few options:



  Generate a `.csv` file containing the data you want to include. You can download these directly from the 'Squad & Player Stats' tabs on the fbref competition pages, like the one for the [Premier League](https://fbref.com/en/comps/9/Premier-League-Stats). I had  to modify the downloaded `.xls` file a little bit in Excel before saving it as a `.csv`.

  <img src="https://i.imgur.com/cWWjryd.png" width="500"/>

  I just removed the additional row at the top (which contained extra labels about pass types) and changed the file type to `.csv`.

  Once that's done, you can just pass the filepath of the `.csv` to `balaban.bosko`.



  You can scrape from fbref -- to do so you will need to have downloaded the appropriate `chromedriver.exe` file from [here](https://sites.google.com/a/chromium.org/chromedriver/downloads) and made a note of the filepath. You can then run
  ```
  from balaban import scrape_top_five_leagues
  df = scrape_top_five_leagues('path/to/chromedriver.exe', league_names)
  ```
  `league_names` is a list that defaults to `['epl', 'laliga', 'bundesliga', 'ligue1', 'seriea']`, but you can pass any subset of those to reduce the time it takes to scrape.



  Use a pandas dataframe you've generated another way. Just make sure it has columns called 'Player' (player names; *strings*), 'Squad' (team names; *strings*), 'Pos' (playing positions; *strings*; as per fbref, these are one of `DF`, `MF`, `FW`. They can be combined like `MF,FW`), '90s' (number of 90s played, *float*).



  ```
  import balaban
  bos = balaban.bosko(df, league_season_string, query_position)
  ```

  This makes a Croatian striker/Python class containing your data that we'll add fitted models to later on.

    * `df` is either a pandas dataframe, a filepath to your csv file,
    or a url to your csv file. As long as either your csv file or dataframe have the columns 'Player', 'Squad', 'Pos' & '90s, you're all good.
    * `league_season_string` is a character string for plotting purposes. It goes where "La Liga, 2019/20" is in the Merino example above.
    * `query_position` is an (optional) character string defining a position filter. For example, if it's `'MF'`, the models will only be fitted on players
    for which the string `'MF'` appears in the Pos column.



  The following function call estimates a model:
  ```
  bos.add_model(a,b,model_type,model_name)
  ```
  *Note*: the first time you try to add a model, there might be a delay of a couple of minutes. That's PyMC3 compiling some stuff.

  `model_type` specifies which of the four possible models will be estimated. The options are
    * `'count'`
      - estimate a hierarchical Poisson model. Suitable for 'count per 90' type metrics.
      - if `model_type == 'count'`, `a` is the total number of observed actions (goals, passes, etc.)
      - if `model_type == 'count'`, `b` is the total number of minutes played
    * `'success_rate'`
      - estimate a hierarchical Binomial model. Suitable for success rate metrics.
      - if `model_type == 'success_rate'`, `a` is the total number of *successful* actions (goals, completed passes, etc.)
      - if `model_type == 'success_rate'`, `b` is the total number of *attempted* actions (shots, attempted passes, etc.)
    * `'xSpA'`
      - estimate a hierarchical Beta model. Suitable for expected success metrics per required action.
      - if `model_type == 'xSpA'`, `a` is the total expected successful actions (e.g., xA, xG)
      - if `model_type == 'xSpA'`, `b` is the total number of *attempted* corresponding actions (e.g., key passes, shots)
    * `'xSp90'`
      - combine a count model and an xSpA model to obtain expected successes per 90
      - if `model_type == 'xSp90'`, `a` is a *previously estimated* xSpA model
      - if `model_type == 'xSp90'`, `b` is a *previously estimated* count model
      - previously estimated models can be retrieved via `bos.get_model(name)`. For example, to estimate an xG90 model:

      ```
      bos.add_model('Sh', 'Minutes', 'count', 'Shots/90')
      bos.add_model('xG', 'Sh', 'xSpA', 'xG/Shot')
      bos.add_model(bos.get_model('xG/Shot'), bos.get_model('Shots/90'), 'xSp90', 'xG/90')
      ```
    * `'adj_pass'`
      - estimate a length-adjusted pass completion model. It combines two hierarchical binomial models for passes longer than 25 yards and passes shorter than 25 yards. Essentially a very simple expected passing model.
      - the estimates are the overall passing success rates if the proportion of long passes is set to the average among the cohort. i.e. it adjusts the pass success rate so that everybody has the same long:short pass ratio -- if you're playing mostly long balls, your pass success will naturally be low. This model attempts to correct for that.
      - if `model_type == 'adj_pass'`, `a` is a list of the form `[successful long passes, total successful passes]`
      - if `model_type == 'adj_pass'`, `b` is a list of the form `[attempted long passes, total attempted passes]`


  `model_name` is also the character string that will be used as a label on any subsequent plots.

  `a` and `b` can be either:
    * character strings referring to columns in your input `.csv` or pandas dataframe
    * arrays containing the values themselves (this allows you to use sums of columns or data not in the original csv/data frame)



  Once all of the models you're interested in have been estimated, you can plot the results using
  ```
  bos.make_plot(query_player,subtit_text,model_names,use_pretty_font)
  ```
    * `query_player` is a character string
    * `subtit_text` is a character string defining the first part of the plot subtitle. It goes where 'Passing metrics' appears on the Merino plot.
    * `model_names` is an (optional) list of models to plot. Defaults to all of them.
    * `use_pretty_font` is an (optional) Boolean telling me whether you want to use the nice font in the example above (`True`) or
    the matplotlib default font (`False`). Defaults to `True`.


pkgId: 8f665223cfc93597a0f9e6925488a16666b5274431cfbaf065b57b77e39501c1
name: python-balance-subscriber
arch: src
version: 0.0.1rc1
epoch: 0
release: 1
summary: MQTT listener to save data
url: https://pypi.org/p/balance-subscriber
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balance-subscriber-0.0.1rc1-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/IoT-balance-project/balance-mqtt-subscriber/actions/workflows/test.yaml/badge.svg)](https://github.com/IoT-balance-project/balance-mqtt-subscriber/actions/workflows/test.yaml)



  A service to listen for messages and save the data.





  Create a virtual environment

  ```bash
  sudo mkdir -p /opt/balance-subscriber
  sudo python3 -m venv /opt/balance-subscriber/venv
  ```

  Activate the virtual environment

  ```bash
  source /opt/balance-subscriber/venv/bin/activate
  ```

  Install this package

  ```bash
  pip install --upgrade balance-subscriber
  ```



  Create a service account called `balance-subscriber`.

  ```bash
  sudo useradd --system balance-subscriber
  ```

  This user must have permissions to write to the target data directory.

  Install the [systemd](https://systemd.io/) service.

  ```bash
  cp --verbose ./systemd/balance-subscriber.service /etc/systemd/system/balance-subscriber.service
  ```

  Configure the service

  ```bash
  systemctl edit myservice
  ```

  This will create an override configuration file in the directory `/etc/systemd/system/balance-subscriber.service.d`.
  Edit this file to set the options for the service, such as the target data directory.

  ```unit file (systemd)
  [Service]
  Environment="DATA_DIR=/tmp"
  Environment="HOST=localhost"
  ```

  The available options are listed in the configuration section.



  The following options are available.

  | Setting  | Description                                         |
  |----------|-----------------------------------------------------|
  | DATA_DIR | The target directory to serialise MQTT messages to. |
  | HOST     | MQTT broker host name                               |
  | PORT     | MQTT broker port                                    |
  | TOPICS   | MQTT topics                                         |

  These settings are specified in the configuration file for the systemd service as described in the installation section.



  The app will run as a service in the background.



  View service status

  ```bash
  sudo systemctl status balance-subscriber.service
  ```

  View logs

  ```
  sudo journalctl -u balance-subscriber.service --since "1 hour ago"
  ```


pkgId: 17be3aad0b6f985db4fd85cb84a55acdfda3cead7d4c9763989daac0430821f5
name: python-balanced
arch: src
version: 1.2
epoch: 0
release: 1
summary: Payments platform for marketplaces
url: https://balancedpayments.com/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balanced-1.2-1.src.rpm
checksum_type: sha256
description:
  Online Marketplace Payments

  [![Build Status](https://secure.travis-ci.org/balanced/balanced-python.png?branch=master)](http://travis-ci.org/balanced/balanced-python) [![Latest Version](https://pypip.in/version/balanced/badge.svg)](https://pypi.python.org/pypi/balanced/) [![Downloads](https://pypip.in/download/balanced/badge.svg)](https://pypi.python.org/pypi/balanced/) [![Supported Python versions](https://pypip.in/py_versions/balanced/badge.svg)](https://pypi.python.org/pypi/balanced/) [![License](https://pypip.in/license/balanced/badge.svg)](https://pypi.python.org/pypi/balanced/)

  **v1.x requires Balanced API 1.1. Use [v0.x](https://github.com/balanced/balanced-python/tree/rev0) for Balanced API 1.0.**



      pip install balanced



  View Balanced's online tutorial and documentation at https://www.balancedpayments.com/docs/overview?language=python



  1. Fork it
  2. Create your feature branch (`git checkout -b my-new-feature`)
  3. Write your code **and unit tests**
  4. Ensure all tests still pass (`nosetests`)
  5. [PEP8](http://pypi.python.org/pypi/pep8) your code
  6. Commit your changes (`git commit -am 'Add some feature'`)
  7. Push to the branch (`git push origin my-new-feature`)
  8. Create new pull request




  Each scenario lives in the scenarios directory and is comprised of the following:

  - definition.mako - Method definition
  - request.mako - Scenario code
  - executable.py - Processed request.mako. Can be executed directly in Python. Generated by render_scenarios.py.
  - python.mako - Documentation template to be consumed by balanced-docs. Generated by - render_scenarios.py.


pkgId: 80eb67524d2f9fdba8555f46936ee41168392d6437aeb401cf4ae28cd2cf6eae
name: python-balanced-loss
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Easy to use class-balanced cross-entropy and focal loss implementation for Pytorch.
url: https://github.com/fcakyon/balanced-loss
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balanced-loss-0.1.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
      <a href="https://badge.fury.io/py/balanced-loss"><img src="https://badge.fury.io/py/balanced-loss.svg" alt="pypi version"></a>
  </div>

  <p align="center">
  <img src="https://user-images.githubusercontent.com/34196005/180311379-1003da44-cdf9-46e8-af83-e65fbc3710cd.png" width="350">
  </p>

  <p align="center">
      Easy-to-use, class-balanced, cross-entropy and focal loss implementation for Pytorch.
  </p>



  When training dataset labels are imbalanced, one thing to do is to balance the loss across sample classes.

  - First, the effective number of samples are calculated for all classes as:

  ![alt-text](https://user-images.githubusercontent.com/34196005/180266195-aa2e8696-cdeb-48ed-a85f-7ffb353942a4.png)

  - Then the class balanced loss function is defined as:

  ![alt-text](https://user-images.githubusercontent.com/34196005/180266198-e27d8cba-f5e1-49ca-9f82-d8656333e3c4.png)




  ```bash
  pip install balanced-loss
  ```



  - Standard losses:

  ```python
  import torch
  from balanced_loss import Loss


  logits = torch.tensor([[0.78, 0.1, 0.05]]) # 1 batch, 3 class
  labels = torch.tensor([0]) # 1 batch


  focal_loss = Loss(loss_type="focal_loss")
  loss = focal_loss(logits, labels)
  ```

  ```python

  ce_loss = Loss(loss_type="cross_entropy")
  loss = ce_loss(logits, labels)
  ```

  ```python

  bce_loss = Loss(loss_type="binary_cross_entropy")
  loss = bce_loss(logits, labels)
  ```

  - Class-balanced losses:

  ```python
  import torch
  from balanced_loss import Loss


  logits = torch.tensor([[0.78, 0.1, 0.05]]) # 1 batch, 3 class
  labels = torch.tensor([0]) # 1 batch


  samples_per_class = [30, 100, 25] # 30, 100, 25 samples for labels 0, 1 and 2, respectively


  focal_loss = Loss(
      loss_type="focal_loss",
      samples_per_class=samples_per_class,
      class_balanced=True
  )
  loss = focal_loss(logits, labels)
  ```

  ```python

  ce_loss = Loss(
      loss_type="cross_entropy",
      samples_per_class=samples_per_class,
      class_balanced=True
  )
  loss = ce_loss(logits, labels)
  ```

  ```python

  bce_loss = Loss(
      loss_type="binary_cross_entropy",
      samples_per_class=samples_per_class,
      class_balanced=True
  )
  loss = bce_loss(logits, labels)
  ```

  - Customize parameters:

  ```python
  import torch
  from balanced_loss import Loss


  logits = torch.tensor([[0.78, 0.1, 0.05]]) # 1 batch, 3 class
  labels = torch.tensor([0])


  samples_per_class = [30, 100, 25] # 30, 100, 25 samples for labels 0, 1 and 2, respectively


  focal_loss = Loss(
      loss_type="focal_loss",
      beta=0.999, # class-balanced loss beta
      fl_gamma=2, # focal loss gamma
      samples_per_class=samples_per_class,
      class_balanced=True
  )
  loss = focal_loss(logits, labels)
  ```



  What is the difference between this repo and vandit15's?

  - This repo is a pypi installable package
  - This repo implements loss functions as `torch.nn.Module`
  - In addition to class balanced losses, this repo also supports the standard versions of the cross entropy/focal loss etc. over the same API
  - All typos and errors in vandit15's source are fixed



  https://arxiv.org/abs/1901.05555

  https://github.com/richardaecn/class-balanced-loss

  https://github.com/vandit15/Class-balanced-loss-pytorch


pkgId: 4bc49fe0ea9b5d6bc9040e35d1f131b047f2e0e9522d9ae4e9a35bb5bc7886b8
name: python-balcony
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Read any resource in your AWS Account. You can generate terraform code for them, too.
url: https://pypi.org/project/balcony/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balcony-0.3.3-1.src.rpm
checksum_type: sha256
description:
  - [aws-jmespath-utils](https://github.com/oguzhan-yilmaz/aws-jmespath-utils) dependency is used to enable JMESPath expressions to filter and exclude resources by tags
  - Following expressions are used to select anything: (`=`, `*=`, `=*`, `*=*`)
    - You can leave one side empty or put a `*` there to discard that sides value
  -

  - Select everything
    ```bash
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].filter_tags(`["="]`, @).Tags'
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].filter_tags(`["*="]`, @).Tags'
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].filter_tags(`["=*"]`, @).Tags'
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].filter_tags(`["*=*"]`, @).Tags'
    ```
  - Find named EC2 Instances
    ```bash
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].filter_tags(`["Name="]`, @)'
    ```
  - Find AWS MAP migration tagged EC2 Instances
    ```bash
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].filter_tags(`["map-migrated="]`, @)'
    ```

  - Exclude everything
    ```bash
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].exclude_tags(`["="]`, @).Tags'
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].exclude_tags(`["*="]`, @).Tags'
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].exclude_tags(`["=*"]`, @).Tags'
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].exclude_tags(`["*=*"]`, @).Tags'
    ```
  - Find un-named EC2 Instances
    ```bash
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].exclude_tags(`["Name="]`, @)'
    ```
  - Find AWS MAP migration un-tagged EC2 Instances
    ```bash
    balcony aws ec2 Instances -js 'DescribeInstances[].Reservations[].Instances[].exclude_tags(`["map-migrated="]`, @)'


pkgId: ae046f2be136a9680a7f778041513bc46cacb618303f9680057ea59067e554cd
name: python-baldertest
arch: src
version: 0.1.0b10
epoch: 0
release: 1
summary: balder: reusable scenario based test framework
url: https://docs.balder.dev
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-baldertest-0.1.0b10-1.src.rpm
checksum_type: sha256
description:
  SETUP SetupPrinter
    SCENARIO ScenarioMibSysDescr
      VARIATION ScenarioMibSysDescr.SnmpAgent:SetupPrinter.Printer | ScenarioMibSysDescr.SnmpManager:SetupPrinter.HostPc
        TEST ScenarioMibSysDescr.test_get_sys_descr [.]
        TEST ScenarioMibSysDescr.test_get_sys_descr_ascii_check [.]
        TEST ScenarioMibSysDescr.test_set_sys_descr [.]
    SCENARIO ScenarioMibSysObjectId
      VARIATION ScenarioMibSysObjectId.SnmpAgent:SetupPrinter.Printer | ScenarioMibSysObjectId.SnmpManager:SetupPrinter.HostPc
        TEST ScenarioMibSysObjectId.test_get_sys_object_id [.]
        TEST ScenarioMibSysObjectId.test_set_sys_object_id [.]
    SCENARIO ScenarioMibSysUpTime
      VARIATION ScenarioMibSysUpTime.SnmpAgent:SetupPrinter.Printer | ScenarioMibSysUpTime.SnmpManager:SetupPrinter.HostPc
        TEST ScenarioMibSysUpTime.test_get_sys_up_time [.]
        TEST ScenarioMibSysUpTime.test_get_sys_up_time_changed_check [.]


pkgId: fc424f311c8bd9813da36f6f907ff350ddba10b2b4b97fcc390033eaf238607c
name: python-balldontlie
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Python SDK for the BALLDONTLIE API
url: https://pypi.org/project/balldontlie/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balldontlie-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Official Python SDK for the BALLDONTLIE API. Access NBA, NFL, and MLB statistics and data. Check out the official website [here](https://app.balldontlie.io).



  ```bash

  pip install balldontlie


  pip install balldontlie==0.1.0
  ```



  ```python
  from balldontlie import BalldontlieAPI

  api = BalldontlieAPI(api_key="your-api-key")


  api.nba.teams.list()


  api.mlb.teams.list()


  api.nfl.teams.list()

  ```



  Check out the full API documentation:
  [NBA](https://nba.balldontlie.io)
  [NFL](https://nfl.balldontlie.io)
  [MLB](https://mlb.balldontlie.io)



  ```python
  from balldontlie import BalldontlieAPI
  from balldontlie.exceptions import (
      AuthenticationError,
      RateLimitError,
      ValidationError,
      NotFoundError,
      ServerError,
      BallDontLieException
  )

  client = BalldontlieAPI(api_key="your_key")

  try:
      teams = client.nba.teams.list()
  except AuthenticationError as e:
      print(f"Invalid API key. Status: {e.status_code}, Details: {e.response_data}")
  except RateLimitError as e:
      print(f"Rate limit exceeded. Status: {e.status_code}, Details: {e.response_data}")
  except ValidationError as e:
      print(f"Invalid request parameters. Status: {e.status_code}, Details: {e.response_data}")
  except NotFoundError as e:
      print(f"Resource not found. Status: {e.status_code}, Details: {e.response_data}")
  except ServerError as e:
      print(f"API server error. Status: {e.status_code}, Details: {e.response_data}")
  except BallDontLieException as e:
      print(f"General API error. Status: {e.status_code}, Details: {e.response_data}")
  except Exception as e:
      print(f"Unexpected error: {str(e)}")
  ```


pkgId: 73821552dd8c27ed2fba9658ed9c193a8a80d3117cc32d84fc834455bf8a8b1d
name: python-ballpark
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Better human-readable numbers.
url: https://github.com/debrouwere/python-ballpark/
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ballpark-1.4.0-1.src.rpm
checksum_type: sha256
description:
  When people think of human-readable numbers, they think of rounding to
  two decimal places and adding a thousands separator. 12,214.17 is
  already quite an improvement over 12214.16666667. But standard formats
  for human-readable numbers still have various flaws:
  -  even with a thousands separator, at a glance you might easily mistake
     a billion for a trillion
  -  even when rounding, an amount like 12,214.17 dollars is a lot of
     number noise for communicating 12.2K
  -  scientific notation leads to exponents like ``1.22e4`` which are hard
     to interpret because we're used to working with thousands, millions
     and billions – orders of magnitudes that are multiples of three
  -  when comparing multiple measurements of the same underlying variable,
     like the yearly sales numbers for 2010-2015, it's annoying to have
     some numbers in thousands and other numbers in millions – you want
     consistency so that digits in the same position are of the same
     magnitude
  ``python-ballpark`` introduces *business notation*, an offshoot of
  `engineering
  notation <https://en.wikipedia.org/wiki/Engineering_notation>`__, for
  producing better human-readable numbers.
  Install with ``pip install ballpark`` or ``pip3 install ballpark``.
  What it looks like
  ~~~~~~~~~~~~~~~~~~
  +---------------------+-----------------------+-----------------+-----------------+
  | numbers             | rounded               | engineering     | **business      |
  |                     |                       | notation        | notation**      |
  +=====================+=======================+=================+=================+
  | 11234.22,           | 11,234.22,            | 11.2E+3,        | 11K, 233K,      |
  | 233000.55,          | 233,000.55,           | 233E+3, 1.18E+6 | 1,180K          |
  | 1175125.2           | 1,175,125.2           |                 |                 |
  +---------------------+-----------------------+-----------------+-----------------+
  | 111, 1111.23,       | 111, 1,111.23,        | 111, 1.11E+3,   | 0.11K, 1.11K,   |
  | 1175125.234         | 1,175,125.23          | 1.18E+6         | 1,180.00K       |
  +---------------------+-----------------------+-----------------+-----------------+
  How to use it
  ~~~~~~~~~~~~~
      >>> from ballpark import human, scientific, engineering, business, ballpark
      >>> business([11234.22, 233000.55, 1175125.2])
      ['11K', '233K', '1,180K']
      >>>
      >>> # business notation is also aliased as `ballpark`
      >>> ballpark([11234.22, 233000.55, 1175125.2])
      ['11K', '233K', '1,180K']
      >>>
      >>> # or use the shortcut functions
      >>> from ballpark import H, S, E, B
      >>> B([11234.22, 233000.55, 1175125.2])
      ['11K', '233K', '1,180K']
      >>>
      >>> # all notations accept single numbers too, but then we can't guarantee
      >>> # that all numbers will have the same prefix (kilo, mega etc.)
      >>> [B(value) for value in [11234.22, 233000.55, 1175125.2]]
      ['11.2K', '233K', '1.18M']
  How it works
  ~~~~~~~~~~~~
      business(values, precision=3, prefix=True, prefixes=SI, statistic=median)
  -  **precision:** the amount of significant digits. When necessary,
     ``business`` will round beyond the decimal sign as well: in the
     example above, ``1175125.2`` was turned into ``1,180K`` rather than
     ``1,175K`` to retain only 3 significant digits.
  -  **prefix:** whether to use SI prefixes like m (milli), K (kilo) and
     so on instead of scientific exponents like E+03.
  -  **prefixes:** a mapping of orders of magnitude to prefixes, e.g.
     ``{-3: 'm', 3: 'K'}``, allowing you to customize the prefixes, for
     example using B for billion instead of T for tera.
  -  **statistic:** a function to produce the reference number. The
     reference number determines the order of magnitude and precision for
     the entire group of numbers, so that for example when the reference
     number is 23.3K, smaller numbers like 1.1K won't gain a decimal place
     and larger numbers like 1,180K won't jump an order of magnitude to
     1.18M. The median often works well, but if you want more precision
     for small outliers, try ``ballpark.statistics.Q1`` or even Python's
     builtin ``min``.


pkgId: d683cf39bbef1efa76037e17695f990dcb89f959acc91b14ac710be4619a4074
name: python-ballsort
arch: src
version: 1.0.14
epoch: 0
release: 1
summary: A framework for learning async Python
url: https://github.com/aheed/ballsort-framework
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ballsort-1.0.14-1.src.rpm
checksum_type: sha256
description:
  A framework for learning async Python. Includes challenges. Includes interop with a Ballsort display window for use in a JupyterLab environment.


pkgId: 77bfb15878b26557d03b29cd0f2235f8e17f6704d9318cfcfeb0d580a9b79c81
name: python-ballyregan
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: Find fetch & validate free proxies fast.
url: https://pypi.org/project/ballyregan/
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ballyregan-1.0.6-1.src.rpm
checksum_type: sha256
description:
  Ballyregan is a super fast proxy fetcher.
  <br>
  It provides a python package and an easy-to-use CLI to help you fetch <bFree Tested Proxies</b> fast, and keep your privacy.


pkgId: c013cb52890afb5e3ab7a6898e7a7c7bc5dc22f9d1356451d8692deb897d1431
name: python-balrogo
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Bayesian Astrometric Likelihood Recovery of Galactic Objects
url: https://gitlab.com/eduardo-vitral/balrogo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balrogo-1.8.0-1.src.rpm
checksum_type: sha256
description:
  [![pipeline status](https://gitlab.com/eduardo-vitral/balrogo/badges/master/pipeline.svg)](https://gitlab.com/eduardo-vitral/balrogo/-/commits/master)
  [![coverage report](https://gitlab.com/eduardo-vitral/balrogo/badges/master/coverage.svg)](https://gitlab.com/eduardo-vitral/balrogo/-/commits/master)
  [![pypi](https://img.shields.io/pypi/v/balrogo.svg)](https://pypi.python.org/pypi/balrogo/)
  [![python](https://img.shields.io/pypi/pyversions/balrogo.svg)](https://pypi.python.org/pypi/balrogo)
  [![license](http://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

  <!-- markdownlint-disable-next-line no-inline-html -->
  <img alt="logo" align="right" src="https://gitlab.com/eduardo-vitral/balrogo/-/raw/master/logo.png" width="20%" />

  BALRoGO: Bayesian Astrometric Likelihood Recovery of Galactic Objects.

  - Specially developed to handle data from the Gaia space mission.
  - Extracts galactic objects such as globular clusters and dwarf galaxies from data contaminated by interlopers.
  - Uses a combination of Bayesian and non-Bayesian approaches.
  - Provides:
    - Fits of proper motion space.
    - Fits of surface density.
    - Fits of object center.
    - Confidence regions for the color-magnitude diagram and parallaxes.

  If something does not work, please [file an issue](https://gitlab.com/eduardo-vitral/balrogo/-/issues).



  Please cite [us](https://academic.oup.com/mnras/article-abstract/504/1/1355/6237524?redirectedFrom=fulltext) if you find this code useful in your research. The BibTeX entry for the paper is:

  ```bibtex
  @ARTICLE{Vitral21,
     author = {{Vitral}, Eduardo},
      title = "BALRoGO: Bayesian Astrometric Likelihood Recovery of Galactic Objects - Global properties of over one hundred globular clusters with Gaia EDR3",
    journal = {\mnras},
       year = 2021,
      month = jun,
     volume = {504},
     number = {1},
      pages = {1355-1369},
        doi = {10.1093/mnras/stab947},
     eprint = {2102.04841},
     adsurl = {https://ui.adsabs.harvard.edu/abs/2021MNRAS.504.1355V},
  }
  ```



  BALRoGO has nine modules that perform different tasks:

  - ***angle.py*** : This module contains the main functions concerning angular tansformations, sky projections and spherical trigonomtry.
  - ***gaia.py*** : This module contains the main functions concerning the handling of the Gaia mission data.
  - ***hrd.py*** : This module contains the main functions concerning the color magnitude diagram (CMD). It provides a Kernel Density Estimation (KDE) of the CMD distribution.
  - ***marginals.py*** : This module is based on the Python corner package (Copyright 2013-2016 Dan Foreman-Mackey & contributors, The Journal of Open Source Software): https://joss.theoj.org/papers/10.21105/joss.00024
  I have done some modifications on it so it allows some new features and so it takes into account some choices as default. I thank Gary Mamon for his good suggestions concerning the plot visualization.
  -  ***parallax.py*** : This module contains the main functions concerning parallax information. It provides a kernel density estimation of the distance distribution, as well as a fit of the mode of this distribution.
  - ***pm.py*** : This module contains the main functions concerning proper motion data. It provides MCMC and maximum likelihood fits of proper motions data, as well as robust initial guesses for those fits.
  - ***position.py*** : This module contains the main functions concerning positional information. It provides MCMC and maximum likelihood fits of surface density, as well as robust initial guesses for the (RA,Dec) center of the source.
  - ***mock.py*** : This module handles mock data sets. It converts 3D coordinates to sky coordinates and is able to add realistic errors to proper motions. It is also able to generate Milky Way interlopers.
  - ***dynamics.py*** : This module handles conversions from celestial coordinates to plane of sky coordinates (vPOSr,vPOSt), as well as allows computation of dispersion profiles in different ways. Also computes the velocity anisotropy from cartesian data.



  BALRoGO is available through [pip](https://pypi.org/project/balrogo/). The quickiest way to install it is to type the following command in your terminal:

  ```terminal
  pip install balrogo
  ```

  If you are using [Anaconda](https://www.anaconda.com/), you might want to install it directly in your Anaconda bin path:

  ```terminal
  cd path/anaconda3/bin/
  pip install balrogo
  ```

  For updated versions of the code, you can do the same as above, but instead of using `pip install balrogo`, you should type:

  ```terminal
  pip install --upgrade balrogo
  ```



  For quick tutorial of BALRoGO applied to *Gaia* data, please click [here](https://gitlab.com/eduardo-vitral/balrogo/-/blob/master/GAIA.md).



  Copyright (c) 2020 Eduardo Vitral & Alexandre Macedo.

  BALRoGO is free software made available under the [MIT License](LICENSE). The BALRoGO logo is licensed under a [Creative Commons Attribution 4.0 International license](https://creativecommons.org/licenses/by/4.0/).


pkgId: d43972163970ca93533bfa419539ce05a49928fd5d2872c4112f8fb2f58bc614
name: python-balsam-flow
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: HPC Workflows & Edge Service
url: https://balsam.readthedocs.io
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balsam-flow-0.5.0-1.src.rpm
checksum_type: sha256
description:
  BSD 3-Clause License

  Copyright (c) 2019, UChicago Argonne LLC
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * 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.
      * Neither the name of UChicago Argonne LLC 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 <COPYRIGHT HOLDER> 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: 1b2c0c774e598ca099972e39dcd4bee1b4dd3446f324ec9c419f22351478fb63
name: python-balsamic
arch: src
version: 0.2.94
epoch: 0
release: 1
summary: Send malicious pickles via requests or sockets
url: https://pypi.org/project/balsamic/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-balsamic-0.2.94-1.src.rpm
checksum_type: sha256
description:
  balsamic is a library for sending malicious pickles to a vunlerable application, via web requests, or a malicious server or client(currently ipv4 only).
  we will add more payloads but for now we just execute shell commands. via the oscmd payload.
  ![image](https://github.com/malectricasoftware/balsamic/assets/107813117/c9e8138c-9f8f-4d68-b71c-331cf7a42343)


  web request mode
  ```
  usage: balsamic.py webreq [-h] [-m METHOD] -u URL [-p PARAMETER] [-co COOKIE] -P PAYLOAD
                            [-c COMMAND] [-H HEADERS]

  options:
    -h, --help            show this help message and exit
    -m METHOD, --method METHOD
    -u URL, --url URL
    -p PARAMETER, --parameter PARAMETER
    -co COOKIE, --cookie COOKIE
    -P PAYLOAD, --payload PAYLOAD
    -c COMMAND, --command COMMAND
    -H HEADERS, --headers HEADERS

  ```
  socksend mode
  ```
  usage: balsamic.py socksend [-h] -rh RHOST -rp RPORT -P PAYLOAD [-c COMMAND] [-s STEPS] [-e]
                              [--ipv6]

  options:
    -h, --help            show this help message and exit
    -rh RHOST, --rhost RHOST
    -rp RPORT, --rport RPORT
    -P PAYLOAD, --payload PAYLOAD
    -c COMMAND, --command COMMAND
    -s STEPS, --steps STEPS
    -e, --encode
    --ipv6                Use IPv6
  ```
  socklisten mode
  ```
  usage: balsamic.py socklisten [-h] -lp LPORT -P PAYLOAD [-c COMMAND] [-s STEPS] [-e] [--ipv6]

  options:
    -h, --help            show this help message and exit
    -lp LPORT, --lport LPORT
    -P PAYLOAD, --payload PAYLOAD
    -c COMMAND, --command COMMAND
    -s STEPS, --steps STEPS
    -e, --encode
    --ipv6                Use IPv6
  ```


  ```
  from balsamic import balsamic
  balsamic.utility.command="command"
  balsamic.webreq("method", "url", "payload", "param", "cookie", custom_headers)
  balsamic.socksend("rhost", rport, "payload", enc, steps, use_ipv6)
  balsamic.socklisten(lport, "payload", enc, steps, use_ipv6)
  ```


pkgId: 784e0887ebf05107d71ab0f05899075afe1792d83ce17a81c2dff855bf68d17a
name: python-bam2plot
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Plot of coverage from bam file
url: https://github.com/willros/bam2plot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bam2plot-0.3.7-1.src.rpm
checksum_type: sha256
description:
  Plot your bam files!


  `bam2plot` no longer depends on `perbase`. Now, `bam2plot` depends on [mosdepth](https://github.com/brentp/mosdepth)


  ```bash
  You must call bam2plot with the following subcommands:
     [1]: 'from_bam'
     [2]: 'from_reads'
     [3]: 'guci'
  ```


  ```bash
  usage: bam2plot [-h] -b BAM -o OUTPATH [-w WHITELIST] [-t THRESHOLD] [-r ROLLING_WINDOW]
                  [-i | --index | --no-index] [-s | --sort_and_index | --no-sort_and_index]
                  [-z ZOOM] [-c | --cum_plot | --no-cum_plot] [-p {png,svg,both}]
                  [-n NUMBER_OF_REFS]
                  sub_command

  Plot your bam files!

  positional arguments:
    sub_command

  options:
    -h, --help            show this help message and exit
    -b BAM, --bam BAM     bam file
    -o OUTPATH, --outpath OUTPATH
                          Where to save the plots.
    -w WHITELIST, --whitelist WHITELIST
                          Only include these references/chromosomes.
    -t THRESHOLD, --threshold THRESHOLD
                          Threshold of mean coverage depth
    -r ROLLING_WINDOW, --rolling_window ROLLING_WINDOW
                          Rolling window size
    -i, --index, --no-index
                          Index bam file
    -s, --sort_and_index, --no-sort_and_index
                          Index and sort bam file
    -z ZOOM, --zoom ZOOM  Zoom into this region. Example: -z='100 2000'
    -c, --cum_plot, --no-cum_plot
                          Generate cumulative plots of all chromosomes
    -p {png,svg,both}, --plot_type {png,svg,both}
                          How to save the plots
    -n NUMBER_OF_REFS, --number_of_refs NUMBER_OF_REFS
                          How many references (chromosomes) to plot
  ```

  bam2plot from_bam generates coverage plots:
  ![plot](example/normal.png)

  ... and if `-c` is added, cumulative coverage plots for each reference (*e.g.* chromosomes) for each sample:
  ![plot](example/cumplot.png)

  If the flag `--highlight` is given, the regions with a coverage below the `--treshold` are highlighted:
  ![plot](example/highlight.png)

  Below is an example of how bam2plot looks when runned in the terminal:
  ![plot](example/running.png)



  Here's an example of how to use the bam2plot from_bam:

  ```bash
  bam2plot from_bam --bam input.bam --outpath output_folder --rolling_window 50 --threshold 5 -s -c
  ```



  ```bash
  usage: bam2plot [-h] -r1 READ_1 [-r2 READ_2] -ref REFERENCE [-gc | --guci | --no-guci] -o OUT_FOLDER
                  [-r ROLLING_WINDOW] [-p {png,svg,both}]
                  sub_command

  Align your reads and plot the coverage!

  positional arguments:
    sub_command

  options:
    -h, --help            show this help message and exit
    -r1 READ_1, --read_1 READ_1
                          Fastq file 1
    -r2 READ_2, --read_2 READ_2
                          Fastq file 2
    -ref REFERENCE, --reference REFERENCE
                          Reference fasta
    -gc, --guci, --no-guci
                          Plot GC content? (default: False)
    -o OUT_FOLDER, --out_folder OUT_FOLDER
                          Where to save the plots.
    -r ROLLING_WINDOW, --rolling_window ROLLING_WINDOW
                          Rolling window size
    -p {png,svg,both}, --plot_type {png,svg,both}
                          How to save the plots
  ```



  ```bash
  usage: bam2plot [-h] -ref REFERENCE -w WINDOW -o OUT_FOLDER [-p {png,svg,both}] sub_command

  Plot GC content of your reference fasta!

  positional arguments:
    sub_command

  options:
    -h, --help            show this help message and exit
    -ref REFERENCE, --reference REFERENCE
                          Reference fasta
    -w WINDOW, --window WINDOW
                          Rolling window size
    -o OUT_FOLDER, --out_folder OUT_FOLDER
                          Where to save the plots.
    -p {png,svg,both}, --plot_type {png,svg,both}
                          How to save the plots
  ```



  `bam2plot` depends on [mosdepth](https://github.com/brentp/mosdepth), which you can install via:
  ```bash
  conda install -c bioconda mosdepth
  ```


  You can install `bam2plot` using the following pip command:

  ```bash
  pip install bam2plot
  ```


pkgId: 3b4f306b2c247adfabe660f8f03789b15d2f4bf3d47e4337046e80bef1163801
name: python-bambi
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: BAyesian Model Building Interface in Python
url: https://pypi.org/project/bambi/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bambi-0.14.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/bambinos/bambi/main/docs/logos/RGB/Bambi_logo.png" width=200></img>

  [![PyPi version](https://badge.fury.io/py/bambi.svg)](https://badge.fury.io/py/bambi)
  [![Build Status](https://github.com/bambinos/bambi/actions/workflows/test.yml/badge.svg)](https://github.com/bambinos/bambi/actions/workflows/test.yml)
  [![codecov](https://codecov.io/gh/bambinos/bambi/branch/master/graph/badge.svg?token=ZqH0KCLKAE)](https://codecov.io/gh/bambinos/bambi)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  BAyesian Model-Building Interface in Python



  Bambi is a high-level Bayesian model-building interface written in Python. It's built on top of the [PyMC](https://github.com/pymc-devs/pymc) probabilistic programming framework, and is designed to make it extremely easy to fit mixed-effects models common in social sciences settings using a Bayesian approach.



  Bambi requires a working Python interpreter (3.10+). We recommend installing Python and key numerical libraries using the [Anaconda Distribution](https://www.anaconda.com/products/individual#Downloads), which has one-click installers available on all major platforms.

  Assuming a standard Python environment is installed on your machine (including pip), Bambi itself can be installed in one line using pip:

      pip install bambi

  Alternatively, if you want the bleeding edge version of the package you can install from GitHub:

      pip install git+https://github.com/bambinos/bambi.git



  Bambi requires working versions of ArviZ, formulae, NumPy, pandas and PyMC. Dependencies are listed in `pyproject.toml` and should all be installed by the Bambi installer; no further action should be required.



  In the following two examples we assume the following basic setup

  ```python
  import arviz as az
  import bambi as bmb
  import numpy as np
  import pandas as pd
  ```



  A simple fixed effects model is shown in the example below.

  ```python

  data = bmb.load_data("sleepstudy")


  data.head()


  model = bmb.Model('Reaction ~ Days', data)


  print(model)


  results = model.fit(draws=1000)


  az.summary(results)


  az.plot_trace(results)
  ```
  ```
     Reaction  Days  Subject
  0  249.5600     0      308
  1  258.7047     1      308
  2  250.8006     2      308
  3  321.4398     3      308
  4  356.8519     4      308
  ```
  ```
         Formula: Reaction ~ Days
          Family: gaussian
            Link: mu = identity
    Observations: 180
          Priors:
      target = mu
          Common-level effects
              Intercept ~ Normal(mu: 298.5079, sigma: 261.0092)
              Days ~ Normal(mu: 0.0, sigma: 48.8915)

          Auxiliary parameters
              sigma ~ HalfStudentT(nu: 4.0, sigma: 56.1721)
  ```
  ```
                     mean     sd   hdi_3%  hdi_97%  mcse_mean  mcse_sd  ess_bulk  ess_tail  r_hat
  Intercept       251.552  6.658  238.513  263.417      0.083    0.059    6491.0    2933.0    1.0
  Days             10.437  1.243    8.179   12.793      0.015    0.011    6674.0    3242.0    1.0
  Reaction_sigma   47.949  2.550   43.363   52.704      0.035    0.025    5614.0    2974.0    1.0
  ```

  First, we create and build a Bambi `Model`. Then, the method `model.fit()` tells the sampler to start
  running and it returns an `InferenceData` object, which can be passed to several ArviZ functions
  such as `az.summary()` to get a summary of the parameters distribution and sample diagnostics or
  `az.plot_trace()` to visualize them.



  In this example we will use a simulated dataset created as shown below.

  ```python
  data = pd.DataFrame({
      "g": np.random.choice(["Yes", "No"], size=50),
      "x1": np.random.normal(size=50),
      "x2": np.random.normal(size=50)
  })
  ```

  Here we just add the `family` argument set to `"bernoulli"` to tell Bambi we are modelling a binary
  response. By default, it uses a logit link. We can also use some syntax sugar to specify which event
  we want to model. We just say `g['Yes']` and Bambi will understand we want to model the probability
  of a `"Yes"` response. But this notation is not mandatory. If we use `"g ~ x1 + x2"`, Bambi will
  pick one of the events to model and will inform us which one it picked.

  ```python
  model = bmb.Model("g['Yes'] ~ x1 + x2", data, family="bernoulli")
  fitted = model.fit()
  ```

  After this, we can evaluate the model as before.



  For a more in-depth introduction to Bambi see our [Quickstart](https://github.com/bambinos/bambi#quickstart) and check the notebooks in the [Examples](https://bambinos.github.io/bambi/notebooks/) webpage.



  The Bambi documentation can be found in the [official docs](https://bambinos.github.io/bambi/index.html)



  If you use Bambi and want to cite it please use

  ```bibtex
  @article{Capretto2022,
   title={Bambi: A Simple Interface for Fitting Bayesian Linear Models in Python},
   volume={103},
   url={https://www.jstatsoft.org/index.php/jss/article/view/v103i15},
   doi={10.18637/jss.v103.i15},
   number={15},
   journal={Journal of Statistical Software},
   author={Capretto, Tomás and Piho, Camen and Kumar, Ravin and Westfall, Jacob and Yarkoni, Tal and Martin, Osvaldo A},
   year={2022},
   pages={1–29}
  }
  ```



  Bambi is a community project and welcomes contributions. Additional information can be found in the [Contributing](https://github.com/bambinos/bambi/blob/main/docs/CONTRIBUTING.md) Readme.

  For a list of contributors see the [GitHub contributor](https://github.com/bambinos/bambi/graphs/contributors) page



  If you want to support Bambi financially, you can [make a donation](https://numfocus.org/donate-to-pymc) to our sister project PyMC.



  Bambi wishes to maintain a positive community. Additional details can be found in the [Code of Conduct](https://github.com/bambinos/bambi/blob/main/docs/CODE_OF_CONDUCT.md)



  [MIT License](https://github.com/bambinos/bambi/blob/main/LICENSE)

rpm_license:
  MIT License  Copyright (c) 2016 the developers of Bambi  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: 37c87c189f874f337f2f9f7bf5cef554d489f1659bcb7f708cd6c8513869ec2e
name: python-bamboo-ta
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: TA library for Pandas
url: https://github.com/DutchCryptoDad/bamboo-ta
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bamboo-ta-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **Bamboo-TA** is a personal library that consolidates various Technical Analysis (TA) indicators into one simple and modular package for analyzing financial market data. It is designed to help traders develop trading strategies based on candlestick data.
  While this library includes popular TA indicators like **MACD**, **RSI**, **SMA**, **EMA**, it also provides lesser-known indicators like **Waddah Attar Explosion** and **Bollinger Bands Trend Indicator**. Bamboo-TA is complementary to other libraries like **TA-lib**, **Pandas-ta**, and **qtpylib**, and it is not intended to replace them.


pkgId: fbb544e6141bacd7767c3180771495f32b227a6b75f49f628c61b8267ffafac4
name: python-bambooai
arch: src
version: 0.3.52
epoch: 0
release: 1
summary: A lightweight library for working with pandas dataframes using natural language queries
url: https://pypi.org/project/bambooai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bambooai-0.3.52-1.src.rpm
checksum_type: sha256
description:
  A lightweight library utilizing Large Language Models (LLMs) to provide natural language interaction capabilities, much like a research and data analysis assistant enabling conversation with your data. You can either provide your own data sets, or allow the library to locate and fetch data for you. It supports Internet searches and external API interactions.



  The BambooAI library is a experimental, lightweigh tool that utilizes Large Language Models (LLMs) to facilitate data analysis, making it more accessible to users, including those without programming expertise. It functions as an assistant for research and data analysis, allowing users to interact with their data through natural language. Users can supply their own datasets or BambooAI can assist in sourcing the necessary data. The tool also integrates internet searches and accesses external APIs to enhance its functionality.

  BambooAI processes natural language queries about datasets and can generate and execute Python code for data analysis and visualization. This enables users to derive insights from their data without extensive coding knowledge. Users simply input their dataset, ask questions in simple English, and BambooAI provides the answers, along with visualizations if needed, to help understand the data better.



  The BambooAI agent operates through several key steps to interact with users and generate responses:

  **1. Initiation**
  - The user launches the BambooAI agent with a question.
  - If no initial question is provided, the agent prompts the user for a question or an 'exit' command to terminate the program.
  - The agent then enters a loop where it responds to each question provided, and upon completion, prompts the user for the next question. This loop continues until the user chooses to exit the program.

  **2. Task Evaluation**
  - The agent stores the received question and utilizes the Large Language Model (LLM) to evaluate and categorize it.
  - The LLM determines whether the question necessitates a textual response, additional information (Google search: https://serper.dev/), or can be resolved using code.
  - Depending on the task evaluation and classification the agent calls the appropriate agent.

  **3. Dynamic Prompt Build**
  - If the question can be resolved by code, the agent determines whether the necessary data is contained within the provided dataset, requires downloading from an external source, or if the question is of a generic nature and data is not required.
  - The agent then chooses its approach accordingly. It formulates an algorithm, expressed as a task list, to serve as a blueprint for the analysis.
  - The original question is modified to align with this algorithm. The agent performs a semantic search against a vector database for similar questions.
  - Any matching questions found are appended to the prompt as examples. GPT-3.5, GPT-4 or a local OSS model is then used to generate code based on the algorithm.

  **4. Debugging, Execution, and Error Correction**
  - If the generated code needs debugging, GPT-4 is engaged.
  - The code is executed, and if errors occur, the agent logs the error message and refers it back to the LLM for correction.
  - This process continues until successful code execution.

  **5. Results, Ranking, and Knowledge Base Build**
  - Post successful execution, GPT-4 is used to rank the answer.
  - If the rank surpasses a set threshold, the question, answer, code, and rank are stored in the Pinecone vector database.
  - Regardless of the rank, the final answer or visualization is formatted and presented to the user.

  **6. Human Feedback and Loop Continuation**
  - The agent seeks feedback from the user.
  - If the user validates the auto-generated ranking, the question/answer pair is stored in the vector database.
  - If not, a new execution loop begins.

  Throughout this process, the agent continuously solicits user input, stores messages for context, and generates and executes code to ensure optimal results. Various AI models and a vector database are employed in this process to provide accurate and helpful responses to user's questions.



  The library supports use of various open source or proprietary models, either via API or localy.

  **API:**
  - OpenAI - All models
  - Google - Gemini Models
  - Anthropic - All Models
  - Groq - All Models
  - Mistral - All Models

  **Local:**
  - Ollama - All Models
  - A Selection of local models(more info below)

  You can specify what vendor/model you want to use for a specific agent by modifying the content of LLM_CONFIG file, replacing the default OpenAI model name with the model and vendor of your choicee. eg. ```{"agent": "Code Generator", "details": {"model": "open-mixtral-8x22b", "provider":"mistral","max_tokens": 4000, "temperature": 0}}```. The purpose of LLM_CONFIG is described in more detail below.



  **Installation**

  ```
  pip install bambooai
  ```

  **Usage**

  - Parameters

  ```
  df: pd.DataFrame - Dataframe (It will try to source the data from internet, if 'df' is not provided)

  max_conversations: int - Number of "user:assistant" conversation pairs to keep in memory for a context. Default=2

  debug: bool - If True, the received code is sent back to the Language Learning Model (LLM) for an evaluation of its relevance to the user's question, along with code error checking and debugging.

  search_tool: bool - If True, the Planner agent will use a "google search: https://serper.dev/" if the required information is not available or satisfactory. By default it only support HTML sites, but can be enhanced with Selenium if the ChromeDriver exists on the system (details below).

  vector_db: bool - If True, each answer will first be ranked from 1 to 10. If the rank surpasses a certain threshold (8), the corresponding question (vectorised), plan, code, and rank (metadata) are all stored in the Pinecone database. Each time a new question is asked, these records will be searched. If the similarity score is above 0.9, they will be offered as examples and included in the prompt (in a one-shot learning scenario)

  onthology: bool - If True, the onthology defined in the module `df_onthology.py` will be used to inform LLM of the dataframe structure, metrics, record frequency, keys, joins, abstract functions etc. The onthology is custom for each dataframe type, and needs to be defined by the user. Sample onthology is included. This feature signifficantly improves performance, and quality of the solutions.

  exploratory: bool - If set to True, the LLM will evaluate the user's question and select an "Expert" that is best suited to address the question (experts: Research Specialist, Data Analyst). In addition, if the task involves code generation/execution, it will generate a task list detailing the steps, which will subsequently be sent to the LLM as a part of the prompt for the next action. This method is particularly effective for vague user prompts, but it might not perform as efficiently with more specific prompts. The default setting is True.

  e.g. bamboo = BambooAI(df, debug=True, vector_db=True, search_tool=True, exploratory=True)
       bamboo = BambooAI(df,debug=False, vector_db=False, exploratory=True, search_tool=True)
  ```

  ***Deprecation Notice (October 25, 2023):***
  *Please note that the "llm", "local_code_model", "llm_switch_plan", and "llm_switch_code" parameters have been deprecated as of v 0.3.29. The assignment of models and model parameters to agents is now handled via LLM_CONFIG. This can be set either as an environment variable or via a LLM_CONFIG.json file in the working directory. Please see the details below*

  - LLM Config

  The agent specific llm configuration is stored in ```LLM_CONFIG``` environment variable, or in the "LLM_CONFIG.json file which needs to be stored in the BambooAI's working directory. The config is in a form of JSON list of dictionaries and specifies model name, provider, temperature and max_tokens for each agent. You can use the provided LLM_CONFIG_sample.json as a starting point, and modify the config to reflect your preferences. If neither "ENV VAR" nor "LLM_CONFIG.json" is present, BambooAI will use the default hardcoded configuration that uses "gpt-3.5-turbo" for all agents.

  - Prompt Templates

  The BambooAI library uses default hardcoded set of prompt templates for each agent. If you want to experiment with them, you can modify the provided "PROMPT_TEMPLATES_sample.json" file, remove the "_sample from its name and store in the working directory. Subsequently, the content of the modified "PROMPT_TEMPLATES.json" will be used instead of the hardcoded defaults. You can always revert back to default prompts by removing/renaming the modified "PROMPT_TEMPLATES.json".

  - Example usage: Run in a loop

  ```

  import pandas as pd
  from bambooai import BambooAI

  df = pd.read_csv('test_activity_data.csv')
  bamboo = BambooAI(df)
  bamboo.pd_agent_converse()
  ```
  - Example Usage: Single execution
  ```

  import pandas as pd
  from bambooai import BambooAI

  df = pd.read_csv('test_activity_data.csv')
  bamboo = BambooAI(df)
  bamboo.pd_agent_converse("Calculate 30, 50, 75 and 90 percentiles of the heart rate column")
  ```

  **Environment Variables**

  The library requires an OpenAI API account and the API key to connect to OpenAI LLMs. The OpenAI API key needs to be stored in a ```OPENAI_API_KEY``` environment variable.
  The key can be obtained from here: https://platform.openai.com/account/api-keys.

  In addition to OpenAI models a selection of models from different providers is also supported (Groq, Gemini, Mistral, Anthropic). The API keys needs to be stored in environment variables in the following format ```<VENDOR_NAME>_API_KEY```.
  You need to use ```GEMINI_API_KEY``` for Google Gemini models.

  As mentioned above, the llm config can be stored in a string format in the  ```LLM_CONFIG``` environment variable. You can use the content of the provided LLM_CONFIG_sample.json as a starting point and modify to your preference, depending on what models you have access to.

  The Pincone vector db is optional. If you don want to use it, you dont need to do anything. If you have an account with Pinecone and would like to use the knowledge base and ranking features, you will be required to setup ```PINECONE_API_KEY``` envirooment variable, and set the 'vector_db' parameter to True. The vector db index is created upon first execution.

  The Google Search is also optional. If you don want to use it, you dont need to do anything. If you have an account with Serper and would like to use the Google Search functionality, you will be required to setup and account with ": https://serper.dev/", and set ```SERPER_API_KEY``` environment variable, and set the 'search_tool' parameter to True. By default bambooai can only scrape websites with HTML content. However it is also capable of using Selenium with ChromeDriver, which is much more powerfull. To enable this functionality you will need to manualy download a version of ChromeDriver that matches your version of the Chrome browser, store it on the filesystem and create an environment variable ```SELENIUM_WEBDRIVER_PATH``` with a path to your ChromeDriver. BambooAI wil pick it up automaticaly, and use Selenium for all scraping tasks.

  **Local Open Source Models**

  The library currently directly supports the following open-source models. I have selected the models that currently score the highest on the HumanEval benchmark.
  - **WizardCoder(WizardLM):** WizardCoder-15B-V1.0, WizardCoder-Python-7B-V1.0, WizardCoder-Python-13B-V1.0, WizardCoder-Python-34B-V1.0
  - **WizardCoder GPTQ(TheBloke):** WizardCoder-15B-1.0-GPTQ, WizardCoder-Python73B-V1.0-GPTQ, WizardCoder-Python-13B-V1.0-GPTQ, WizardCoder-Python-34B-V1.0-GPTQ
  - **CodeLlama Instruct(TheBloke):** CodeLlama-7B-Instruct-fp16, CodeLlama-13B-Instruct-fp16, CodeLlama-34B-Instruct-fp16
  - **CodeLlama Instruct(Phind):** Phind-CodeLlama-34B-v2
  - **CodeLlama Completion(TheBloke):** CodeLlama-7B-Python-fp16, CodeLlama-13B-Python-fp16, CodeLlama-34B-Python-fp16

  If you want to use the local model for a specific agent, modify the LLM_CONFIG content replacing the OpenAI model name with the local model name and change the provider value to 'local'. eg. ```{"agent": "Code Generator", "details": {"model": "Phind-CodeLlama-34B-v2", "provider":"local","max_tokens": 2000, "temperature": 0}}```
  At present it is recommended to use local models only for code generation tasks, all other tasks like pseudo code generaration, summarisation, error correction and ranking should be still handled by OpenAI models of choice. The model is downloaded from Huggingface and cached localy for subsequent executions. For a reasonable performance it requires CUDA enabled GPU and the pytorch library compatible with the CUDA version. Below are the required libraries that are not included in the package and will need to be installed independently:
  ```
  pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 (Adjust to match your CUDA version. This library is already included in Colab notebooks)
  pip install auto-gptq (Only required if using WizardCoder-15B-1.0-GPTQ model)
  pip install accelerate
  pip install einops
  pip install xformers
  pip install bitsandbytes
  ```
  The settings and parameters for local models are located in local_models.py module and can be adjusted to match your particular configuration or preferences.

  **Ollama**

  The library also supports the use of Ollama https://ollama.com/ and all of it's models. If you want to use a local Ollama model for a specific agent, modify the LLM_CONFIG content replacing the OpenAI model name with the Ollama model name and change the provider value to 'ollama'. eg. ```{"agent": "Code Generator", "details": {"model": "llama3:70b", "provider":"ollama","max_tokens": 2000, "temperature": 0}}```

  **Logging**

  All LLM interactions (local or via APIs) are logged in the `bambooai_consolidated_log.json` file. When the size of the log file reaches 5 MB, a new log file is created. A total of 3 log files are kept on the file system before the oldest file gets overwritten.

  The following details are captured:

  - **Chain ID**
  - **All LLM calls (steps) within the chain**, including details of each call eg. agent name, timestamp, model, prompt (context memory), response, token use, cost, tokens per second etc.
  - **Chain summary**, including token use, cost, count of llm calls, tokens per second etc.
  - **Summary per LLM**, including token use, cost, number of calls, tokens per second etc.

  Log Structure:
  ```
  - chain_id: 1695375585
    â”œâ”€ chain_details (LLM Calls)
    â”‚   â”œâ”€ List of Dictionaries (Multiple Steps)
    â”‚       â”œâ”€ Call 1
    â”‚       â”‚   â”œâ”€ agent (String)
    â”‚       â”‚   â”œâ”€ chain_id (Integer)
    â”‚       â”‚   â”œâ”€ timestamp (String)
    â”‚       â”‚   â”œâ”€ model (String)
    â”‚       â”‚   â”œâ”€ messages (List)
    â”‚       â”‚   â”‚   â””â”€ role (String)
    â”‚       â”‚   â”‚   â””â”€ content (String)
    â”‚       â”‚   â””â”€ Other Fields (content, prompt_tokens, completion_tokens, total_tokens, elapsed_time, tokens_per_second, cost)
    â”‚       â”œâ”€ Call 2
    â”‚       â”‚   â””â”€ ... (Similar Fields)
    â”‚       â””â”€ ... (Call 3, Call 4, Call 5 ...)
    â”‚
    â”œâ”€ chain_summary
    â”‚   â”œâ”€ Dictionary
    â”‚       â”œâ”€ Total LLM Calls (Integer)
    â”‚       â”œâ”€ Prompt Tokens (Integer)
    â”‚       â”œâ”€ Completion Tokens (Integer)
    â”‚       â”œâ”€ Total Tokens (Integer)
    â”‚       â”œâ”€ Total Time (Float)
    â”‚       â”œâ”€ Tokens per Second (Float)
    â”‚       â”œâ”€ Total Cost (Float)
    â”‚
    â”œâ”€ summary_per_model
        â”œâ”€ Dictionary
            â”œâ”€ LLM 1 (Dictionary)
            â”‚   â”œâ”€ LLM Calls (Integer)
            â”‚   â”œâ”€ Prompt Tokens (Integer)
            â”‚   â”œâ”€ Completion Tokens (Integer)
            â”‚   â”œâ”€ Total Tokens (Integer)
            â”‚   â”œâ”€ Total Time (Float)
            â”‚   â”œâ”€ Tokens per Second (Float)
            â”‚   â”œâ”€ Total Cost (Float)
            â”œâ”€ LLM 2
            |   â””â”€ ... (Similar Fields)
            â””â”€ ... (LLM 3, LLM 4, LLM 5 ...)
  ```



  **Task:** _Devise a machine learning model to predict the survival of passengers on the Titanic. The output should include the accuracy of the model and visualizations of the confusion matrix, correlation matrix, and other relevant metrics._

  **Dataset:** _Titanic.csv_

  **Model:** _GPT-4-Turbo_


  - **Result:**
    - **Confusion Matrix:**
      - **True Negative (TN):** 90 passengers were correctly predicted as not surviving.
      - **True Positive (TP):** 56 passengers were correctly predicted as surviving.
      - **False Negative (FN):** 18 passengers were incorrectly predicted as not surviving.
      - **False Positive (FP):** 15 passengers were incorrectly predicted as surviving.

  | Metric         | Value        |
  | -------------- | ------------ |
  | Execution Time | 77.12 seconds|
  | Input Tokens   | 7128         |
  | Output Tokens  | 1215         |
  | Total Cost     | $0.1077      |



  - **Result:**
    - **Confusion Matrix:**
      - **True Negative (TN):** 92 passengers were correctly predicted as not surviving.
      - **True Positive (TP):** 55 passengers were correctly predicted as surviving.
      - **False Negative (FN):** 19 passengers were incorrectly predicted as not surviving.
      - **False Positive (FP):** 13 passengers were incorrectly predicted as surviving.


  | Metric         | Value        |
  | -------------- | ------------ |
  | Execution Time | 47.39 seconds|
  | Input Tokens   | 722          |
  | Output Tokens  | 931          |
  | Total Cost     | $0.0353      |




  - The library currently supports OpenAI Chat models. It has been tested with both gpt-3.5-turbo and gpt-4. The gpt-3.5-turbo seems to perform OK for simpler tasks and is the good starting/exploration option due to its 10x lower cost.
  - It can also be used with models from the following vendors via API. Anthropic, Mistral, Google Gemini, Groq. All you need is the API key.
  - Also the use of Ollama and all of it's models is supported. This could be quite handy as a buch of Llama 3 finetunes are about to start landing.
  - For coding tasks it also supports SOTA open source code models like CodeLlama and WizardCoder.
  - The library executes LLM generated Python code, this can be bad if the LLM generated Python code is harmful. Use cautiously.
  - Be sure to monitor your token usage. At the time of writing, the cost per 1K input tokens is $0.01 USD for GPT-4-turbo and $0.001 USD for GPT-3.5-turbo. It's important to keep these costs in mind when using the library, particularly when using the more expensive models.
  - Supported OpenAI models: *gpt-3.5-turbo, gpt-3.5-turbo-613, gpt-3.5-turbo-16k, gpt-4, gpt-4-turbo.*
  - Supported Open Source Models: *WizardCoder-15B-V1.0, WizardCoder-Python-7B-V1.0, WizardCoder-Python-13B-V1.0, WizardCoder-Python-34B-V1.0, WizardCoder-15B-1.0-GPTQ, WizardCoder-Python73B-V1.0-GPTQ, WizardCoder-Python-13B-V1.0-GPTQ,
    WizardCoder-Python-34B-V1.0-GPTQ, CodeLlama-7B-Instruct-fp16, CodeLlama-13B-Instruct-fp16, CodeLlama-34B-Instruct-fp16, CodeLlama-7B-Python-fp16, CodeLlama-13B-Python-fp16, CodeLlama-34B-Python-fp16, Phind-CodeLlama-34B-v2.*



  Contributions are welcome; please feel free to open a pull request. Keep in mind that our goal is to maintain a concise codebase with high readability.



  - A lot :-)


pkgId: b760cba280e9e6105e19c33cddedac0b65edc8416c88b9779b6783b472b744bb
name: python-bamboost
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: A light weight database manager using HDF5
url: https://bamboost.ch/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bamboost-0.8.2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <h3 align="center">
  	<img src="https://gitlab.com/cmbm-ethz/bamboost/-/raw/main/assets/bamboost_icon.png?ref_type=heads" width="150" alt="Logo"/><br/>
          <br/>
  	BAMBOOST <br/>

  </h3>

  <p align="center">
  Bamboost is a Python library built for datamanagement using
  the HDF5 file format.
  bamboost stands for a <span style="font-weight: bold;">lightweight</span> shelf which will <span style="font-weight: bold">boost</span> your efficiency and which
  will totally break if you load it heavily. Just kidding, bamboo can fully carry pandas. <br/>
  🐼🐼🐼🐼
  </p>

  </div>


  <div align="center">
  <a href="https://bamboost.ch">
      <img src="https://img.shields.io/badge/Docs-bamboost.ch-blue" alt="Website">
  </a>
  <!-- <a href="https://gitlab.com/cmbm-ethz/bamboost/-/commits/main"> -->
  <!--     <img src="https://gitlab.com/cmbm-ethz/bamboost/badges/main/pipeline.svg" alt="pipeline status"> -->
  <!-- </a> -->
  <!-- <a href="https://gitlab.com/cmbm-ethz/bamboost/-/commits/main"> -->
  <!--     <img src="https://gitlab.com/cmbm-ethz/bamboost/badges/main/coverage.svg" alt="coverage report"> -->
  <!-- </a> -->
  <a href="https://badge.fury.io/py/bamboost">
      <img src="https://badge.fury.io/py/bamboost.svg" alt="PyPI version">
  </a>
  <a href="https://pypistats.org/packages/bamboost">
      <img src="https://img.shields.io/pypi/dm/bamboost" alt="PyPI - Downloads">
  </a>
  <a href="https://pypi.org/project/bamboost/">
      <img src="https://img.shields.io/pypi/pyversions/bamboost" alt="PyPI - Python Version">
  </a>
  <a href="https://gitlab.com/cmbm-ethz/bamboost/-/blob/main/LICENSE">
      <img src="https://img.shields.io/pypi/l/bamboost" alt="PyPI - License">
  </a>

  <a href="https://gitlab.com/cmbm-ethz/bamboost/-/commits/test-ci"><img alt="pipeline status" src="https://gitlab.com/cmbm-ethz/bamboost/badges/test-ci/pipeline.svg" /></a>
  <a href="https://gitlab.com/cmbm-ethz/bamboost/-/commits/test-ci"><img alt="coverage report" src="https://gitlab.com/cmbm-ethz/bamboost/badges/test-ci/coverage.svg" /></a>

  Terminal user interface for bamboost: https://gitlab.com/zrlf/bamboost-tui.

  Documentation site: https://gitlab.com/zrlf/bamboost-docs.
  </div>


  Install the latest release from the package repository:
  ```
  pip install bamboost
  ```


  Install the package in editable mode for more flexibility, $e.g.$ if you plan to make changes yourself:
  ```
  git clone git@gitlab.com:cmbm-ethz/bamboost.git
  cd bamboost
  pip install -e .
  ```
  > :warning: The option `-e` installs a project in editable mode from a local path. This way,
  > you won't need to reinstall when pulling a new version or changing something in the
  > package.


  For parallel writing, you need `mpi4py`. Furthermore, the HDF5 library must have
  been built with MPI support and the python interface `h5py` must be installed
  with parallel support (https://docs.h5py.org/en/stable/mpi.html).
  ```
  export CC=mpicc
  export HDF5_MPI="ON"
  pip install --force-reinstall --no-deps --no-binary=h5py h5py
  ```

  > :warning: If you're system runs into problems installing `mpi4py`, make sure python header files are installed. Quickly google what you need (something like `python3-dev`, `libpython3.8-dev`, etc.).




  - **Python** >= 3.7
  - **HDF5** >= 1.10.0
  - **sqlite3** (comes with python) >= 3.0

  Optional:
  - **MPICC** or **OpenMPI** for parallel writing
  - **HDF5** with MPI support






  The main object of `bamboost` is the `Manager`. It manages the database located in the directory
  specified during construction. It can display the parametric space, create new simulations, remove simulations
  select a specific simulation based on it's `uid` or on conditions of it's parameters.
  Every database that is created is assigned a unique identifier (UID).
  ```python
  from bamboost import Manager

  db = Manager('path/to/db')
  ```

  `pandas.DataFrame` is used to display the database. The dataframe is convenient and fast to filter or sort your entries:
  ```python
  db.df
  ```

  An entry (from now on called *simulation*) within a database can be viewed, retrieved and modified with the `Simulation` object.
  To get the `Simulation` object, access it with it's identifier or location (index) in the dataframe:
  ```python
  sim = db['uid']
  sim = db[index]
  sim = db.sim('uid')
  ```

  All simulations can be returned as a (sorted) list. The argument `select` can be used to
  filter the simulations.
  ```python
  sims = db.sims()  # returns all
  sims = db.sims(select=(db.df.eps==1))  # returns all where eps is 1
  sims = db.sims(sort='parameter1', reverse=False)  # returns all, sorrted by parameter1
  ```
  :warning: Note that this creates objects for every simulation and the sorting is not optimized. Using pandas to select and sort is much faster. Check their documentation for how to manipulate pandas dataframes.


  Every database created will be assigned a unique identifier (UID).
  The database path is stored with the UID in an index maintained at `~.config/bamboost` in your home directory. If it is not known, `bamboost` will try to find it on your disk (you can add paths to search in `~.config/bamboost/known_paths.json`).
  You can obtain a Manager object of any database from anywhere with it's UID. In notebooks, key completion will show you all known databases:
  ```python
  db = Manager.fromUID['UID']
  ```

  The unique id makes refering to data safe. The full identifier of a simulation is considered to be `'(database id):(simulation id)'`. It is encouraged to use the identifiers (instead of the path) to link from one simulation to a different one.
  ```python

  sim.links['mesh_to_use'] = 'DATABASE-ID:simulation-id'


  uid = sim.get_full_uid()
  ```



  You can use `bamboost` to write simulation or experimental data.
  Use the `Manager` to create a new simulation (or access an existing one).
  Say you have (or want to create) a database at `data_path`.
  The code samples below shows the main functionality.

  ```python
  from bamboost import Manager

  db = Manager(data_path)

  params = {...}  # dictionary of parameters (can have nested dictionaries)
  writer = db.create_simulation(parameters=params)
  writer.copy_file('path/to/file/')  # copy a file which is needed to the database folder (e.g. executable, module list, etc.)
  writer.change_note('This run is part of a series in which i investigate the effect of worms on apples')


  with writer:

      writer.add_metadata()  # adds time and other metadata
      writer.add_mesh(coordinates, connectivity)  # Add a mesh, default mesh is named 'mesh'.
      writer.add_mesh(coordinates, connectivity, mesh_name='interface')  # add a second mesh for e.g. the interface

      
      for t in times:
          writer.add_field('field_data_1', array, time=t)
          writer.add_field('field_data_2', array, time=t, mesh='interface')
          writer.add_global_field('kinetic_energy', some_number)
          writer.finish_step()  # this increases the step counter
  ```

  If you have an existing dataset, $e.g.$ because you created the simulation before and it holds the input parameters or similar. Do the following: You will need to pass the path and the uid to the script (best use `argparse`).
  ```python
  from bamboost import SimulationWriter

  with SimulationWriter(path, uid) as writer:

      
  ```


  The above functionality should be used for ordered data, such as timeseries of spatial data related to a mesh.
  For anything else, there is the `userdata` category. You can use it to store (almost) anything in the simulation file structured how you would like it. This is also useful to store computed values during postprocessing or plotting.
  Internally, Userdata is an object handling a specific group ('/userdata') of the hdf5 file. To show the content of the group, display the object:
  ```python
  sim.userdata
  ```

   You can create a subgroup, which will return a self-similar object for the new group ($e.g.$ '/userdata/plots'):
  ```python
  plot_grp = sim.userdata.require_group('plots')
  ```

  Writing something to the file (group) is as easy as:
  ```python
  sim.userdata['avg_T'] = 34.56256
  sim.userdata['traction_profile'] = np.array([...])
  ```

  And reading:
  ```python

  sim.userdata['avg_T']

  sim.userdata['traction_profile']

  sim.userdata['traction_profile'][:]
  ```



  The key purpose is convenient access to data. I recommend an interactive session (notebooks).


  ```python
  from bamboost import Manager

  db = Manager(data_path)
  ```

  To display the database with its parametric space simply input
  ```python
  db.df
  ```
  Select a simulation of your dataset. `sim` will be a `SimulationReader` object.
  ```python
  sim = db[index]
  sim = db[uid]
  sims = db.sims((db.df.param1==2) & (db.df.param2>0), sort='param2')  # will return list of all matching, sorted by param2
  ```


  **Show data stored:**
  Display content of the data, userdata, globals groups:
  ```
  sim.data
  sim.userdata
  sim.globals
  ```

  This displays the stored fields and its sizes.
  ```python
  sim.data.info
  ```
  **Access a mesh:** Directly access a tuple where [0] is the coordinates, [1] is the connectivity.
  ```python
  coords, conn = sim.mesh  # default mesh
  coords, conn = sim.get_mesh(mesh_name=...)
  ```
  You can get a mesh object the following way.
  ```python
  mesh1 = sim.meshes['mesh1']
  mesh1.coordinates  # gives coordinates
  mesh1.connectivity  # gives connectivity
  mesh1.get_tuple()  # gives both the above
  ```

  **Access field data**:
  `sim.data` acts as an accessor for all field data.
  ```python
  field1 = sim.data['field1']
  field1[:], field1[0, :]  # slice the dataset and you get numpy arrays (time, *spatial)
  field1.at_step(-1)  # similar for access of one step
  field1.mesh  # returns the linked mesh object (see above)
  field1.msh  # returns a tuple of the mesh (coordinates, connectivity)
  field1.coordinates, field1.connectivity  # direct access to linked mesh' coords and conn arrays
  field1.times  # returns timesteps of data
  field1.shape  # shape of data
  field1.dtype  # data type of data
  ```

  **Access global data:**
  ```python
  sim.globals
  kinetic_energy = sim.globals.kinetic_energy
  ```

  **Open file:**
  All methods internally open the HDF5 file and make sure that it is closed again. Sometimes
  it's useful to keep the file open (i.e. to directly change something in the file manually).
  To do so, you are encouraged to use the following.

  > :warning: Do not open the file in write mode (`'w'`) as this truncates the file.
  ```python
  with sim.open(mode='r+') as file:
      
      
      
  ```


  You can use `bamboost` to create euler jobs, and to submit them.
  ```python
  from bamboost import Manager
  db = Manager(data_path)
  params = {...}  # dictionary of parameters (can have nested dictionaries)

  sim = db.create_simulation(parameters=params)
  sim.copy_file('path/to/postprocess.py')  # copy a file which is needed to the database folder (e.g. executable, module list, etc.)
  sim.copy_file('path/to/cpp_script')
  sim.change_note('This run is part of a series in which i investigate the effect of worms on apples')


  commands = []
  commands.append('./cpp_script')
  commands.append(f'mpirun python {os.path.join(sim.path, 'postprocess.py')}') # e.g. to write the output to the database from cpp output

  sim.create_batch_script(commands, ntasks=4, time=..., mem_per_cpu=..., euler=True)

  sim.submit()  # submits the job using slurm (works only in jupyterhub sessions on Euler)
  ```


  To be continued...


  Please open issues on gitlab: [cmbm/bamboost](https://gitlab.ethz.ch/compmechmat/research/libs/bamboost)

rpm_license:
  Copyright (c) 2023 CMBM, ETH Zurich  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: 8ee09610a7eaf97938da985984e1a35228eeebc9afdf35f8a7986b28c94c5b3f
name: python-bambulabs-api
arch: src
version: 2.4.3
epoch: 0
release: 1
summary: API for BambuLab 3D Printers over MQTT
url: https://github.com/acse-ci223/bambulabs_api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bambulabs-api-2.4.3-1.src.rpm
checksum_type: sha256
description:
  This package provides a Python API for interacting with BambuLab 3D Printers. The API enables you to control and monitor your printer programmatically, making it an essential tool for developers, makers, and automation enthusiasts. The project is open-source and available on PyPI.



  [![flake8](https://github.com/mchrisgm/bambulabs_api/actions/workflows/flake8.yml/badge.svg)](https://github.com/mchrisgm/bambulabs_api/actions/workflows/flake8.yml)
  [![pytest-unit-tests](https://github.com/mchrisgm/bambulabs_api/actions/workflows/pytest-unit-tests.yml/badge.svg)](https://github.com/mchrisgm/bambulabs_api/actions/workflows/pytest-unit-tests.yml)
  [![GitHub Pages](https://github.com/mchrisgm/bambulabs_api/actions/workflows/static.yml/badge.svg)](https://github.com/mchrisgm/bambulabs_api/actions/workflows/static.yml)



  Comprehensive documentation for this package, including API reference and usage guides, can be found [here](https://mchrisgm.github.io/bambulabs_api/).



  To install the package, use `pip`:

  ```bash
  pip install bambulabs_api
  ```

  Make sure you have Python 3.6 or higher installed.



  - **Connect and control** BambuLab 3D printers programmatically.
  - **Monitor printer status** in real-time.
  - **Execute commands** and manage print jobs directly through Python code.
  - **Easy setup** and integration with Python environments.



  Below is a basic example demonstrating how to connect to a BambuLab 3D printer and retrieve its status using the API:

  ```python
  import time
  import bambulabs_api as bl

  IP = '192.168.1.200'
  SERIAL = 'AC12309BH109'
  ACCESS_CODE = '12347890'

  if __name__ == '__main__':
      print('Starting bambulabs_api example')
      print('Connecting to BambuLab 3D printer')
      print(f'IP: {IP}')
      print(f'Serial: {SERIAL}')
      print(f'Access Code: {ACCESS_CODE}')

      
      printer = bl.Printer(IP, ACCESS_CODE, SERIAL)

      
      printer.connect()

      time.sleep(2)

      
      status = printer.get_state()
      print(f'Printer status: {status}')

      
      printer.turn_light_off()

      time.sleep(2)

      
      printer.turn_light_on()

      
      printer.disconnect()
  ```



  If you want to contribute to the development of this API or run it in a development environment, follow these steps:



  - **Conda**: Make sure you have Conda installed on your system.
  - **Git**: Ensure Git is installed for cloning the repository.



  1. Clone the repository:

     ```bash
     git clone https://github.com/mchrisgm/bambulabs_api.git
     ```

  2. Change directory:

     ```bash
     cd bambulabs_api
     ```

  3. Create the Conda environment using the provided `environment.yml` file:

     ```bash
     conda env create -f environment.yml
     ```

  4. Activate the environment:

     ```bash
     conda activate blapi
     ```

  5. Install the package in development mode:

     ```bash
     pip install -e .
     ```



  To ensure everything is working correctly, you can run the tests using `pytest`:

  ```bash
  pytest
  ```



  Contributions are welcome! If you'd like to contribute to this project, please:

  1. Fork the repository.
  2. Create a new branch (`git checkout -b feature-branch`).
  3. Commit your changes (`git commit -am 'Add new feature'`).
  4. Push to the branch (`git push origin feature-branch`).
  5. Open a pull request.

  Please make sure your code follows PEP 8 guidelines and that you run tests before submitting a PR.



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



  If you encounter any issues or have questions, feel free to open an issue on the [GitHub repository](https://github.com/mchrisgm/bambulabs_api/issues).



  This package is an open-source project developed and maintained by the community. Special thanks to all contributors who have helped improve and enhance this API.


