# packages

pkgId: a26f2ca38f3b7d684abda7f99114e328660c0c28b5150716c795ae07b79541cf
name: python-birder-help
arch: noarch
version: 0.0.5a79
epoch: 0
release: 1
summary: Development documents and examples for birder
url: https://gitlab.com/birder/birder
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-birder-0.0.5a79-1.src.rpm
location_href: Packages/python-birder-help-0.0.5a79-1.noarch.rpm
checksum_type: sha256
description:
  Birder is an open-source computer vision framework for wildlife image analysis, focusing on avian species.

  * [Introduction](#introduction)
  * [Setup](#setup)
  * [Getting Started](#getting-started)
  * [Pre-trained Models](#pre-trained-models)
  * [Detection](#detection)
  * [Licenses](#licenses)
  * [Acknowledgments](#acknowledgments)



  Birder is an open-source computer vision framework designed for wildlife imagery, specifically focused on bird species classification and detection. This project leverages deep neural networks to provide robust models that can handle real-world data challenges.

  For comprehensive documentation, tutorials, and more visit the main documentation at [docs/README.md](docs/README.md).

  The project features:

  * A diverse collection of classification and detection models
  * Support for self-supervised pre-training
  * Knowledge distillation training (teacher-student)
  * Custom utilities and data augmentation techniques
  * Comprehensive training scripts
  * Advanced error analysis tools
  * Extensive documentation and tutorials (hopefully...)

  Unlike projects that aim to reproduce ImageNet training results from common papers, Birder is tailored specifically for practical applications in ornithology, conservation, and wildlife photography.

  As Ross Wightman eloquently stated in the [timm README](https://github.com/huggingface/pytorch-image-models#introduction):

  > The work of many others is present here. I've tried to make sure all source material is acknowledged via links to github, arXiv papers, etc. in the README, documentation, and code docstrings. Please let me know if I missed anything.

  The same principle applies to Birder. We stand on the shoulders of giants in the fields of computer vision, machine learning, and ornithology. We've made every effort to acknowledge and credit the work that has influenced and contributed to this project. If you believe we've missed any attributions, please let us know by opening an issue.



  1. Ensure PyTorch 2.5 is installed on your system

  1. Install the latest Birder version:

  ```sh
  pip install birder
  ```

  For detailed installation options, including source installation, refer to our [Setup Guide](docs/getting_started.md#setup).



  ![Example](docs/img/example.jpeg)

  Check out the Birder Colab notebook for an interactive tutorial.

  [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/birder-project/birder/blob/main/notebooks/getting_started.ipynb)
  [![Hugging Face](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Project-blue)](https://huggingface.co/birder-project)

  If you prefer a local setup, follow the installation instructions below.

  Once Birder is installed, you can start exploring its capabilities.

  Birder provides pre-trained models that you can download using the `fetch-model` tool.
  To download a model, use the following command:

  ```sh
  python -m birder.tools fetch-model mvit_v2_t_il-all
  ```

  Create a data directory and download an example image:

  ```sh
  mkdir data
  wget https://f000.backblazeb2.com/file/birder/data/img_001.jpeg -O data/img_001.jpeg
  ```

  To classify bird images, use the `birder-predict` script as follows:

  ```sh
  birder-predict -n mvit_v2_t -t il-all --show data/img_001.jpeg
  ```

  For more options and detailed usage of the prediction tool, run:

  ```sh
  birder-predict --help
  ```

  For more detailed usage instructions and examples, please refer to our [documentation](docs/README.md).



  Birder provides a comprehensive suite of pre-trained models for bird species classification.

  To explore the full range of available pre-trained models, use the `list-models` tool:

  ```sh
  python -m birder.tools list-models --pretrained
  ```

  This command displays a catalog of models ready for download.



  The naming convention for Birder models encapsulates key information about their architecture and training approach.

  Architecture: The first part of the model name indicates the core neural network structure (e.g., MobileNet, ResNet).

  Training indicators:

  * intermediate: Signifies models that underwent a two-stage training process, beginning with a large-scale weakly labeled dataset before fine-tuning on the primary dataset
  * mim: Indicates models that leveraged self-supervised pre-training techniques, primarily Masked Autoencoder (MAE), prior to supervised training

  Other tags:

  * quantized: Model that has been quantized to reduce the computational and memory costs of running inference
  * reparameterized: Model that has been restructured to simplify its architecture for optimized inference performance

  Net Param: The number following the model name (e.g., 50, 1.0, 0.5), called the `net_param`, represents a specific configuration choice for the network. It represents a specific configuration choice for the network, which can affect aspects such as model size or complexity.

  Epoch Number (optional): The last part of the model name may include an underscore followed by a number (e.g., `_0`, `_200`), which represents the epoch.

  For instance, *resnext_50_intermediate_300* represents a ResNeXt model with a `net_param` of 50 that underwent intermediate training and is from epoch 300.



  Our pre-training process utilizes a diverse collection of image datasets.
  This approach allows our models to learn rich, general-purpose visual representations before fine-tuning on specific bird classification tasks.

  The pre-training dataset comprises:

  * iNaturalist 2021 (~3.3M)
  * WebVision-2.0 (~1.5M random subset)
  * imagenet-w21-webp-wds (~1M random subset)
  * SA-1B (~220K random subset of 20 chunks)
  * COCO (~120K)
  * NABirds (~48K)
  * Birdsnap v1.1 (~44K)
  * CUB-200 2011 (~18K)
  * The Birder dataset (~5M)

  Total: ~11M images

  This carefully curated mix of datasets balances general visual knowledge with domain-specific bird imagery, enhancing the model's overall performance.

  For detailed information about these datasets, including descriptions, citations, and licensing details, please refer to [docs/public_datasets.md](docs/public_datasets.md).



  Detection features are currently under development and will be available in future releases.



  Birder is currently a personal project in active development. As the sole developer, I am focused on building and refining the core functionalities of the framework. At this time, I am not actively seeking external contributors.

  However, I greatly appreciate the interest and support from the community. If you have suggestions, find bugs, or want to provide feedback, please feel free to:

  * Open an issue in the project's issue tracker
  * Use the project and share your experiences
  * Star the repository if you find it useful

  While I may not be able to incorporate external contributions at this stage, your input is valuable and helps shape the direction of Birder. I'll update this section if the contribution policy changes in the future.

  Thank you for your understanding and interest in Birder!





  The code in this project is licensed under Apache 2.0. See [LICENSE](LICENSE) for details.
  Some code is adapted from other projects.
  There are notices with links to the references at the top of the file or at the specific class/function.
  It is your responsibility to ensure compliance with licenses here and conditions of any dependent licenses.

  If you think we've missed a reference or a license, please create an issue.



  Some of the pretrained weights available here are pretrained on ImageNet. ImageNet was released for non-commercial research purposes only (<https://image-net.org/download>). It's not clear what the implications of that are for the use of pretrained weights from that dataset. It's best to seek legal advice if you intend to use the pretrained weights in a commercial product.



  If you intend to use Birder, its pretrained weights, or any associated datasets in a commercial product, we strongly recommend seeking legal advice to ensure compliance with all relevant licenses and terms of use.

  It's the user's responsibility to ensure that their use of this project, including any pretrained weights or datasets, complies with all applicable licenses and legal requirements.



  Birder owes much to the work of others in computer vision, machine learning, and ornithology.

  Special thanks to:

  * **Ross Wightman**: His work on [PyTorch Image Models (timm)](https://github.com/huggingface/pytorch-image-models) greatly inspired the design and approach of Birder.

  * **Image Contributors**:
    * Yaron Schmid - from [YS Wildlife](https://www.yswildlifephotography.com/who-we-are)

    for their generous donations of bird photographs.

  This project also benefits from numerous open-source libraries and ornithological resources.

  If any attribution is missing, please open an issue to let us know.


pkgId: eecdda6e8866b5e5bdfff80985dad080236256507799ca158b8e8c9fd5e252be
name: python-birdeye-py-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for birdeye-py
url: https://github.com/nickatnight/birdeye-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-birdeye-py-0.0.8-1.src.rpm
location_href: Packages/python-birdeye-py-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  If you would like to support development efforts, tips are greatly appreciated. SOL wallet address: HKmUpKBCcZGVX8RqLRcKyjYuY23hQHwnFSHXzdon4pCH


pkgId: bd8dc2c86881e24b224589cc8b5cc55c961c464fe7e69482f08bbc5c830d2550
name: python-bitcart-help
arch: noarch
version: 1.17.0.0
epoch: 0
release: 1
summary: Development documents and examples for bitcart
url: https://github.com/bitcart/bitcart-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bitcart-1.17.0.0-1.src.rpm
location_href: Packages/python-bitcart-help-1.17.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/bitcart/bitcart-sdk.svg?style=svg)](https://circleci.com/gh/bitcart/bitcart-sdk)
  [![Codecov](https://img.shields.io/codecov/c/github/bitcart/bitcart-sdk?style=flat-square)](https://codecov.io/gh/bitcart/bitcart-sdk)
  [![PyPI version](https://img.shields.io/pypi/v/bitcart.svg?style=flat-square)](https://pypi.python.org/pypi/bitcart/)
  [![Read the Docs](https://img.shields.io/readthedocs/bitcart-sdk?style=flat-square)](https://sdk.bitcart.ai)

  This is a client library(wrapper) around Bitcart daemon. It is used to simplify common commands.
  Coins support(⚡ means lightning is supported):

  - Bitcoin (⚡)
  - Bitcoin Cash
  - Monero
  - Ethereum
  - Binance coin (BNB)
  - SmartBCH
  - Polygon (MATIC)
  - Tron (TRX)
  - Ergon
  - Litecoin (⚡)
  - Globalboost (⚡)
  - Groestlcoin (⚡)

  Main focus is Bitcoin.

  This library supports both asynchronous and synchronous usages.

  You can call it's methods synchronously, like so:

  ```python
  print(btc.help())
  ```

  Or you can await it's methods when using from async functions:

  ```python
  async def main():
      print(await btc.help())
  ```

  Async callback functions for `@btc.on` are supported.

  For more information [Read the Docs](https://sdk.bitcart.ai)



  We follow a custom variant of semver:

  `major.minor.feature.bugfix`

  Where `major` is changed not frequently, and means significant changes to the SDK

  `minor` means breaking changes

  `feature` means adding new features without breaking existing APIs

  `bugfix` means fixing bugs without breaking existing APIs



  See [CONTRIBUTING.md](CONTRIBUTING.md).



  Copyright (C) 2019 MrNaif2018

  Licensed under the [MIT license](LICENSE)


pkgId: 440d03e362b1b4762faf9b615b4813dac2713c4118971b48d7a81d0d5d22166e
name: python-bitcoin-nostr-chat-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for bitcoin-nostr-chat
url: https://github.com/andreasgriffin/bitcoin-nostr-chat
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bitcoin-nostr-chat-0.5.1-1.src.rpm
location_href: Packages/python-bitcoin-nostr-chat-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  All users know a shared secret (like a bitcoin wallet descriptor). This allows them to find each other.
    * Even if this shared secret leaks, the attacker can only spam the discovery option, the actual chats stay secure

  The actual single and group chats are based on a newly generated secret keys for each participant.
    * Each participant has to be manually accepted to be added to the group chat
    * Chats with participants use NIP17 and group messages are simply NIP17 messages to each participant

  Export and restoring of the nsec and with it restoration of all messages of the relays


pkgId: 1619c5f7667c59c78ade7b6abfe6225c444dd6f52648f7618ce80751c67a9a9d
name: python-bitcoin-qr-tools-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for bitcoin-qr-tools
url: https://github.com/andreasgriffin/bitcoin-qrreader
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bitcoin-qr-tools-1.0.0-1.src.rpm
location_href: Packages/python-bitcoin-qr-tools-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  * `BitcoinVideoWidget` recognizes (and classifies)  **blazingly fast**
    * Addresses  (also BIP21 with amount)
    * Transactions (also base43 electrum encoding)
    * PSBT
    * Xpub
    * Descriptor
    * Multipath Descriptor (like Sparrow)
    * Partial descriptors (Specter DIY) (finger print , derivation, xpub)
    * TxId
    * SignerInfo(s) for Hardware Signer Exports (Wallet Export)
    * Animated QR Codes (BBQR), used by Coldcard
    * Animated QR Codes ([UR](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-005-ur.md)), used by Foundation Passport, Keystone
    * Animated QR Codes used by Specter DIY
  * Recognizes (and classifies)  **blazingly fast**
  * Animated QR Code generation via  `UnifiedEncoder.generate_fragments_for_qr()`
    * For BBQR, UR, and Specter DIY
  * QR Code Widgets, via the widgets `QRCodeWidget`,  `QRCodeWidgetSVG`



  Run the demo with

  ```
  python demo_reader.py
  ```



  ![screenshot](docs/bad-light.png)



  ![screenshot](docs/enhanced.png)





  ```shell
  pip install bitcoin_qr_tools
  ```



  * Setup poetry and install dependencies

    ```sh
    curl -sSL https://install.python-poetry.org | python3 -  # see https://python-poetry.org/docs/master/#installing-with-the-official-installer
    poetry config virtualenvs.in-project true
    poetry install
    ```

  * Run

    ```sh
    poetry shell
    python -m bitcoin_qr_tools
    ```



  The python files in *bitcoin_qr_tools*  are under the [GPL3](LICENSE).

  The folder *bitcoin_qr_tools/ur* is from https://github.com/Foundation-Devices/foundation-ur-py  and under   [BSD-2-Clause Plus Patent License](ur/LICENSE).

  The folder *bitcoin_qr_tools/urtypes* from https://github.com/selfcustody/urtypes  is under  [MIT](urtypes/LICENSE.md).


pkgId: 1dc093370bac32c7e3a90f2cc6529b5b0eccd84e3c43b2b80e904608eb012bf6
name: python-bitmapist-help
arch: noarch
version: 3.115
epoch: 0
release: 1
summary: Development documents and examples for bitmapist
url: https://github.com/Doist/bitmapist
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bitmapist-3.115-1.src.rpm
location_href: Packages/python-bitmapist-help-3.115-1.noarch.rpm
checksum_type: sha256
description:
  ![bitmapist](https://raw.githubusercontent.com/Doist/bitmapist/master/static/bitmapist.png "bitmapist")


  [![Build Status](https://travis-ci.org/Doist/bitmapist.svg?branch=master)](https://travis-ci.org/Doist/bitmapist)

  **NEW!** Try out our new standalone [bitmapist-server](https://github.com/Doist/bitmapist-server), which improves memory efficiency 443 times and makes your setup much cheaper to run (and more scaleable). It's fully compatiable with bitmapist that runs on Redis.



  This Python library makes it possible to implement real-time, highly scalable analytics that can answer following questions:

  * Has user 123 been online today? This week? This month?
  * Has user 123 performed action "X"?
  * How many users have been active this month? This hour?
  * How many unique users have performed action "X" this week?
  * How many % of users that were active last week are still active?
  * How many % of users that were active last month are still active this month?
  * What users performed action "X"?

  This library is very easy to use and enables you to create your own reports easily.

  Using Redis bitmaps you can store events for millions of users in a very little amount of memory (megabytes).
  You should be careful about using huge ids as this could require larger amounts of memory. Ids should be in range [0, 2^32).

  Additionally bitmapist can generate cohort graphs that can do following:
  * Cohort over user retention
  * How many % of users that were active last [days, weeks, months] are still active?
  * How many % of users that performed action X also performed action Y (and this over time)
  * And a lot of other things!

  If you want to read more about bitmaps please read following:

  * http://blog.getspool.com/2011/11/29/fast-easy-realtime-metrics-using-redis-bitmaps/
  * http://redis.io/commands/setbit
  * http://en.wikipedia.org/wiki/Bit_array
  * http://www.slideshare.net/crashlytics/crashlytics-on-redis-analytics





  Can be installed very easily via:

      $ pip install bitmapist




  * PHP port: https://github.com/jeremyFreeAgent/Bitter




  Setting things up:

  ```python
  from datetime import datetime, timedelta
  from bitmapist import setup_redis, delete_all_events, mark_event,\
                        MonthEvents, WeekEvents, DayEvents, HourEvents,\
                        BitOpAnd, BitOpOr

  now = datetime.utcnow()
  last_month = datetime.utcnow() - timedelta(days=30)
  ```

  Mark user 123 as active and has played a song:

  ```python
  mark_event('active', 123)
  mark_event('song:played', 123)
  ```

  Answer if user 123 has been active this month:

  ```python
  assert 123 in MonthEvents('active', now.year, now.month)
  assert 123 in MonthEvents('song:played', now.year, now.month)
  assert MonthEvents('active', now.year, now.month).has_events_marked() == True
  ```


  How many users have been active this week?:

  ```python
  print(len(WeekEvents('active', now.year, now.isocalendar()[1])))
  ```

  Iterate over all users active this week:

  ```python
  for uid in WeekEvents('active'):
      print(uid)
  ```


  If you're interested in "current events", you can omit extra `now.whatever`
  arguments. Events will be populated with current time automatically.

  For example, these two calls are equivalent:

  ```python

  MonthEvents('active') == MonthEvents('active', now.year, now.month)

  ```

  Additionally, for the sake of uniformity, you can create an event from
  any datetime object with a `from_date` static method.

  ```python

  MonthEvents('active').from_date(now) == MonthEvents('active', now.year, now.month)

  ```

  Get the list of these users (user ids):

  ```python
  print(list(WeekEvents('active', now.year, now.isocalendar()[1])))
  ```

  There are special methods `prev` and `next` returning "sibling" events and
  allowing you to walk through events in time without any sophisticated
  iterators. A `delta` method allows you to "jump" forward or backward for
  more than one step. Uniform API allows you to use all types of base events
  (from hour to year) with the same code.

  ```python

  current_month = MonthEvents()
  prev_month = current_month.prev()
  next_month = current_month.next()
  year_ago = current_month.delta(-12)

  ```

  Every event object has `period_start` and `period_end` methods to find a
  time span of the event. This can be useful for caching values when the caching
  of "events in future" is not desirable:

  ```python

  ev = MonthEvent('active', dt)
  if ev.period_end() < now:
      cache.set('active_users_<...>', len(ev))

  ```


  As something new tracking hourly is disabled (to save memory!) To enable it as default do::

  ```python
  import bitmapist
  bitmapist.TRACK_HOURLY = True
  ```

  Additionally you can supply an extra argument to `mark_event` to bypass the default value::

  ```python
  mark_event('active', 123, track_hourly=False)
  ```




  Sometimes the date of the event makes little or no sense, for example,
  to filter out your premium accounts, or in A/B testing. There is a
  `UniqueEvents` model for this purpose. The model creates only one
  Redis key and doesn't depend on the date.

  You can combine unique events with other types of events.

  A/B testing example:

  ```python

  active_today = DailyEvents('active')
  a = UniqueEvents('signup_form:classic')
  b = UniqueEvents('signup_form:new')

  print("Active users, signed up with classic form", len(active & a))
  print("Active users, signed up with new form", len(active & b))
  ```

  Generic filter example

  ```python

  def premium_up(uid):
      
      ...
      mark_unique('premium', uid)


  def premium_down(uid):
      
      ...
      unmark_unique('premium', uid)

  active_today = DailyEvents('active')
  premium = UniqueEvents('premium')



  for uid in premium & active_today:
      add_extra_karma(uid)
  ```

  To get the best of two worlds you can mark unique event and regular
  bitmapist events at the same time.


  ```python
  def premium_up(uid):
      
      ...
      mark_event('premium', uid, track_unique=True)

  ```




  How many users that have been active last month are still active this month?

  ```python
  active_2_months = BitOpAnd(
      MonthEvents('active', last_month.year, last_month.month),
      MonthEvents('active', now.year, now.month)
  )
  print(len(active_2_months))


  assert 123 in active_2_months
  ```

  Alternatively, you can use standard Python syntax for bitwise operations.


  ```python
  last_month_event = MonthEvents('active', last_month.year, last_month.month)
  this_month_event = MonthEvents('active', now.year, now.month)
  active_two_months = last_month_event & this_month_event
  ```
  Operators `&`, `|`, `^` and `~` supported.

  Work with nested bit operations (imagine what you can do with this ;-))!

  ```python
  active_2_months = BitOpAnd(
      BitOpAnd(
          MonthEvents('active', last_month.year, last_month.month),
          MonthEvents('active', now.year, now.month)
      ),
      MonthEvents('active', now.year, now.month)
  )
  print(len(active_2_months))
  assert 123 in active_2_months


  active_2_months.delete()
  ```




  If you want to permanently remove marked events for any time period you can use the `delete()` method:
  ```python
  last_month_event = MonthEvents('active', last_month.year, last_month.month)
  last_month_event.delete()
  ```

  If you want to remove all bitmapist events use:
  ```python
  bitmapist.delete_all_events()
  ```

  When using Bit Operations (ie `BitOpAnd`) you can (and probably should) delete the results unless you want them cached. There are different ways to go about this:
  ```python
  active_2_months = BitOpAnd(
      MonthEvents('active', last_month.year, last_month.month),
      MonthEvents('active', now.year, now.month)
  )

  active_2_months.delete()


  bitmapist.delete_runtime_bitop_keys()


  bitmapist.delete_temporary_bitop_keys()
  ```




  With bitmapist cohort you can get a form and a table rendering of the data you keep in bitmapist. If this sounds confusing [please look at Mixpanel](https://mixpanel.com/retention/).

  Here's a simple example of how to generate a form and a rendering of the data you have inside bitmapist:
  ```python
  from bitmapist import cohort

  html_form = cohort.render_html_form(
      action_url='/_Cohort',
      selections1=[ ('Are Active', 'user:active'), ],
      selections2=[ ('Task completed', 'task:complete'), ]
  )
  print(html_form)

  dates_data = cohort.get_dates_data(select1='user:active',
                                     select2='task:complete',
                                     time_group='days')

  html_data = cohort.render_html_data(dates_data,
                                      time_group='days')

  print(html_data)



  ```

  This will render something similar to this:

  ![bitmapist cohort screenshot](https://raw.githubusercontent.com/Doist/bitmapist/master/static/cohort_screenshot.png "bitmapist cohort screenshot")




  Please see our guide [here](./CONTRIBUTING.md)



  We use Poetry for dependency management & packaging.  Please see [here for setup instructions](https://python-poetry.org/docs/#installation).

  Once you have Poetry installed, you can run the following to install the dependencies in a virtual environment:

  ```bash
  poetry install
  ```



  To run our tests will need to ensure a local redis server is installed.

  We use pytest to run unittests which you can run in a poetry shell with

  ```bash
  poetry run pytest
  ```



  - Bump version in `pyproject.toml`
  - Update the CHANGELOG
  - Commit the changes with a commit message "Version X.X.X"
  - Tag the current commit with `vX.X.X`
  - Create a new release on GitHub named `vX.X.X`
  - GitHub Actions will publish the new version to PIP for you



  Copyright: 2012 by Doist Ltd.

  License: BSD


pkgId: 813a760c141d182c4726e2e821d185586fafb0db105002057a8dbcb47f503ed0
name: python-bitmovin-api-sdk-help
arch: noarch
version: 1.215.0
epoch: 0
release: 1
summary: Development documents and examples for bitmovin-api-sdk
url: https://github.com/bitmovin/bitmovin-api-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bitmovin-api-sdk-1.215.0-1.src.rpm
location_href: Packages/python-bitmovin-api-sdk-help-1.215.0-1.noarch.rpm
checksum_type: sha256
description:
  Python-Client which enables you to seamlessly integrate the Bitmovin API into your projects. Using this API client requires an active account.


pkgId: d6e703350ace3ee27c50162fdd2940535383df5dddd5b41503b309a4349af1be
name: python-bitwarden_workflow_linter-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for bitwarden_workflow_linter
url: https://github.com/bitwarden/workflow-linter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bitwarden_workflow_linter-0.3.1-1.src.rpm
location_href: Packages/python-bitwarden_workflow_linter-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  Bitwarden's Workflow Linter is an extensible linter to apply opinionated organization-specific
  GitHub Action standards. It was designed to be used alongside tools like
  [action-lint](https://github.com/rhysd/actionlint) and
  [yamllint](https://github.com/adrienverge/yamllint) to check for correct Action syntax and enforce
  specific YAML standards.

  To see an example of Workflow Linter in practice in GitHub Action, see the
  [composite Action](https://github.com/bitwarden/gh-actions/tree/main/lint-workflow).





  ```
  Not yet implemented
  ```



  ```
  git clone git@github.com:bitwarden/workflow-linter.git
  cd workflow-linter

  pip install -e .
  ```





  If a non-default configuration is desired (different than `src/bitwarden_workflow_linter/default_settings.yaml`), copy
  the below and create a `settings.yaml` in the directory that `bwwl` will be running from.

  ```yaml
  enabled_rules:
      - bitwarden_workflow_linter.rules.name_exists.RuleNameExists
      - bitwarden_workflow_linter.rules.name_capitalized.RuleNameCapitalized
      - bitwarden_workflow_linter.rules.pinned_job_runner.RuleJobRunnerVersionPinned
      - bitwarden_workflow_linter.rules.job_environment_prefix.RuleJobEnvironmentPrefix
      - bitwarden_workflow_linter.rules.step_pinned.RuleStepUsesPinned
      - bitwarden_workflow_linter.rules.underscore_outputs.RuleUnderscoreOutputs

  approved_actions_path: default_actions.json
  ```

  ```
  usage: bwwl [-h] [-v] {lint,actions} ...

  positional arguments:
    {lint,actions}
      lint          Verify that a GitHub Action Workflow follows all of the Rules.
      actions       Add or Update Actions in the pre-approved list.

  options:
    -h, --help      show this help message and exit
    -v, --verbose
  ```





  -   Python 3.11
  -   pipenv



  ```
  pipenv install --dev
  pipenv shell
  ```



  All built-in `src/bitwarden_workflow_linter/rules` should have 100% code coverage and we should shoot for an overall coverage of 80%+.
  We are lax on the
  [imperative shell](https://www.destroyallsoftware.com/screencasts/catalog/functional-core-imperative-shell)
  (code interacting with other systems; ie. disk, network, etc), but we strive to maintain a high coverage over the
  functional core (objects and models).

  ```
  pipenv shell
  pytest tests --cov=src
  ```



  We adhere to PEP8 and use `black` to maintain this adherence. `black` should be run on any change being merged
  to `main`.

  ```
  pipenv shell
  black .
  ```



  We loosely use [Google's Python style guide](https://google.github.io/styleguide/pyguide.html), but yield to
  `black` when there is a conflict

  ```
  pipenv shell
  pylint --rcfile pylintrc src/ tests/
  ```



  A new Rule is created by extending the Rule base class and overriding the `fn(obj: Union[Workflow, Job, Step])` method.
  Available attributes of `Workflows`, `Jobs` and `Steps` can be found in their definitons under `src/models`.

  For a simple example, we'll take a look at enforcing the existence of the `name` key in a Job. This is already done by
  default with the src.rules.name_exists.RuleNameExists, but provides a simple enough example to walk through.

  ```python
  from typing import Union, Tuple

  from ..rule import Rule
  from ..models.job import Job
  from ..models.workflow import Workflow
  from ..models.step import Step
  from ..utils import LintLevels, Settings


  class RuleJobNameExists(Rule):
      def __init__(self, settings: Settings = None) -> None:
          self.message = "name must exist"
          self.on_fail: LintLevels = LintLevels.ERROR
          self.compatibility: List[Union[Workflow, Job, Step]] = [Job]
          self.settings: Settings = settings

      def fn(self, obj: Job) -> Tuple[bool, str]:
          """<doc block goes here> """
          if obj.name is not None:
              return True, ""
          return False, self.message
  ```

  By default, a new Rule needs five things:

  -   `self.message`: The message to return to the user on a lint failure
  -   `self.on_fail`: The level of failure on a lint failure (NONE, WARNING, ERROR).
      NONE and WARNING will exit with a code of 0 (unless using `strict` mode for WARNING).
      ERROR will exit with a non-zero exit code
  -   `self.compatibility`: The list of objects this rule is compatible with. This is used to create separate instances of
      the Rule for each object in the Rules collection.
  -   `self.settings`: In general, this should default to what is shown here, but allows for overrides
  -   `self.fn`: The function doing the actual work to check the object and enforce the standard.

  `fn` can be as simple or as complex as it needs to be to run a check on a _single_ object. This linter currently does
  not support Rules that check against multiple objects at a time OR file level formatting (one empty between each step or
  two empty lines between each job)

  To activate a rule after implementing it, add it to `settings.yaml` in the project's base folder
  and `src/bitwarden_workflow_linter/default_settings.yaml` to make the rule default



  -   [ ] Add Rule to assert correct format for single line run


pkgId: 4f5df62cf3ff3818720d89bd49a1be5c15413d2ef9de0ca6f4f5f73d89495866
name: python-bk-crypto-python-sdk-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for bk-crypto-python-sdk
url: https://pypi.org/project/bk-crypto-python-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bk-crypto-python-sdk-2.0.1-1.src.rpm
location_href: Packages/python-bk-crypto-python-sdk-help-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Python](https://badgen.net/badge/python/%3E=3.8,%3C3.13/green?icon=github)
  ![Django](https://badgen.net/badge/django/%3E=3.1.5,%3C=4.2.1/yellow?icon=github)
  [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](LICENSE.txt)
  ![Release](https://badgen.net/github/release/TencentBlueKing/crypto-python-sdk)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/TencentBlueKing/crypto-python-sdk/pulls)
  [![Publish to Pypi](https://github.com/TencentBlueKing/crypto-python-sdk/actions/workflows/release.yml/badge.svg)](https://github.com/TencentBlueKing/crypto-python-sdk/actions/workflows/release.yml)
  [(English Documents Available)](https://github.com/TencentBlueKing/crypto-python-sdk/blob/main/readme_en.md)

  ️🔧 BlueKing crypto-python-sdk 是一个基于 pyCryptodome / tongsuopy 等加密库的轻量级密码学工具包，为 Python 应用统一的加解密实现，
  便于项目在不同的加密方式之间进行无侵入切换

  * [Basic] 提供加密统一抽象层，对接 Cryptodome / tongsuopy 等加密库，提供统一的加解密实现
  * [Basic] 支持国际主流密码学算法：AES、RSA
  * [Basic] 支持中国商用密码学算法：SM2、SM4
  * [Basic] 非对称加密支持 CBC、CTR、GCM、CFB 作为块密码模式
  * [Contrib] Django Support，集成 Django settings、ModelField


  ```bash
  $ pip install bk-crypto-python-sdk
  ```

  > 更多用法参考：[使用文档](https://github.com/TencentBlueKing/crypto-python-sdk/blob/main/docs/usage.md)

  **非对称加密**
  ````python
  from bkcrypto import constants
  from bkcrypto.asymmetric import options
  from bkcrypto.asymmetric.ciphers import BaseAsymmetricCipher
  from bkcrypto.contrib.basic.ciphers import get_asymmetric_cipher
  asymmetric_cipher: BaseAsymmetricCipher = get_asymmetric_cipher(
      cipher_type=constants.AsymmetricCipherType.SM2.value,
      
      cipher_options={
          constants.AsymmetricCipherType.SM2.value: options.SM2AsymmetricOptions(
              private_key_string=None
          ),
          constants.AsymmetricCipherType.RSA.value: options.SM2AsymmetricOptions(
              private_key_string=None
          ),
      }
  )

  assert "123" == asymmetric_cipher.decrypt(asymmetric_cipher.encrypt("123"))

  assert asymmetric_cipher.verify(plaintext="123", signature=asymmetric_cipher.sign("123"))
  ````
  **对称加密**
  ```python
  import os
  from bkcrypto import constants
  from bkcrypto.symmetric.ciphers import BaseSymmetricCipher
  from bkcrypto.contrib.basic.ciphers import get_symmetric_cipher
  symmetric_cipher: BaseSymmetricCipher = get_symmetric_cipher(
      cipher_type=constants.SymmetricCipherType.SM4.value,
      common={"key": os.urandom(16)},
  )
  assert "123" == symmetric_cipher.decrypt(symmetric_cipher.encrypt("123"))
  ```

  在 Django Settings 中配置加密算法类型
  ```python
  from bkcrypto import constants
  BKCRYPTO = {
      
      "ASYMMETRIC_CIPHER_TYPE": constants.AsymmetricCipherType.SM2.value,
      
      "SYMMETRIC_CIPHER_TYPE": constants.SymmetricCipherType.SM4.value,
  }
  ```
  **非对称加密**
  ```python
  from bkcrypto.asymmetric.ciphers import BaseAsymmetricCipher
  from bkcrypto.contrib.django.ciphers import get_asymmetric_cipher
  asymmetric_cipher: BaseAsymmetricCipher = get_asymmetric_cipher()

  assert "123" == asymmetric_cipher.decrypt(asymmetric_cipher.encrypt("123"))

  assert asymmetric_cipher.verify(plaintext="123", signature=asymmetric_cipher.sign("123"))
  ```
  **对称加密**
  ```python
  from bkcrypto.symmetric.ciphers import BaseSymmetricCipher
  from bkcrypto.contrib.django.ciphers import get_symmetric_cipher
  symmetric_cipher: BaseSymmetricCipher = get_symmetric_cipher()
  assert "123" == symmetric_cipher.decrypt(symmetric_cipher.encrypt("123"))
  ```

  在 Django Settings 中配置加密算法类型
  ```python
  from bkcrypto import constants
  from bkcrypto.symmetric.options import AESSymmetricOptions, SM4SymmetricOptions
  from bkcrypto.asymmetric.options import RSAAsymmetricOptions, SM2AsymmetricOptions
  BKCRYPTO = {
      
      "ASYMMETRIC_CIPHER_TYPE": constants.AsymmetricCipherType.SM2.value,
      
      "SYMMETRIC_CIPHER_TYPE": constants.SymmetricCipherType.SM4.value,
      "SYMMETRIC_CIPHERS": {
          
          "default": {
              
              
              
              
              
              
              
              
              
              "common": {"key": "your key"},
              "cipher_options": {
                  constants.SymmetricCipherType.AES.value: AESSymmetricOptions(key_size=16),
                  
                  constants.SymmetricCipherType.SM4.value: SM4SymmetricOptions(mode=constants.SymmetricMode.CTR)
              }
          },
      },
      "ASYMMETRIC_CIPHERS": {
          
          "default": {
              "common": {"public_key_string": "your key"},
              "cipher_options": {
                  constants.AsymmetricCipherType.RSA.value: RSAAsymmetricOptions(
                      padding=constants.RSACipherPadding.PKCS1_v1_5
                  ),
                  constants.AsymmetricCipherType.SM2.value: SM2AsymmetricOptions()
              },
          },
      }
  }
  ```
  **非对称加密**
  使用 `asymmetric_cipher_manager` 获取 `BKCRYPTO.ASYMMETRIC_CIPHERS` 配置的 `cipher`
  ```python
  from bkcrypto.asymmetric.ciphers import BaseAsymmetricCipher
  from bkcrypto.contrib.django.ciphers import asymmetric_cipher_manager
  asymmetric_cipher: BaseAsymmetricCipher = asymmetric_cipher_manager.cipher(using="default")

  assert "123" == asymmetric_cipher.decrypt(asymmetric_cipher.encrypt("123"))

  assert asymmetric_cipher.verify(plaintext="123", signature=asymmetric_cipher.sign("123"))
  ```
  **对称加密**
  使用 `symmetric_cipher_manager` 获取 `BKCRYPTO.SYMMETRIC_CIPHERS` 配置的 `cipher`
  ```python
  from bkcrypto.symmetric.ciphers import BaseSymmetricCipher
  from bkcrypto.contrib.django.ciphers import symmetric_cipher_manager

  symmetric_cipher: BaseSymmetricCipher = symmetric_cipher_manager.cipher(using="default")
  assert "123" == symmetric_cipher.decrypt(symmetric_cipher.encrypt("123"))
  ```
  **Django ModelField**
  ```python
  from django.db import models
  from bkcrypto.contrib.django.fields import SymmetricTextField
  class IdentityData(models.Model):
      password = SymmetricTextField("密码", blank=True, null=True)
  ```

  - [版本日志](https://github.com/TencentBlueKing/crypto-python-sdk/blob/main/release.md)

  - [蓝鲸论坛](https://bk.tencent.com/s-mart/community)
  - [蓝鲸 DevOps 在线视频教程](https://bk.tencent.com/s-mart/video/)
  - [蓝鲸社区版交流群](https://jq.qq.com/?_wv=1027&k=5zk8F7G)

  - [BK-CMDB](https://github.com/Tencent/bk-cmdb)：蓝鲸配置平台（蓝鲸 CMDB）是一个面向资产及应用的企业级配置管理平台。
  - [BK-CI](https://github.com/Tencent/bk-ci)：蓝鲸持续集成平台是一个开源的持续集成和持续交付系统，可以轻松将你的研发流程呈现到你面前。
  - [BK-BCS](https://github.com/Tencent/bk-bcs)：蓝鲸容器管理平台是以容器技术为基础，为微服务业务提供编排管理的基础服务平台。
  - [BK-PaaS](https://github.com/Tencent/bk-paas)：蓝鲸 PaaS 平台是一个开放式的开发平台，让开发者可以方便快捷地创建、开发、部署和管理
    SaaS 应用。
  - [BK-SOPS](https://github.com/Tencent/bk-sops)：标准运维（SOPS）是通过可视化的图形界面进行任务流程编排和执行的系统，是蓝鲸体系中一款轻量级的调度编排类
    SaaS 产品。
  - [BK-JOB](https://github.com/Tencent/bk-job) 蓝鲸作业平台(Job)是一套运维脚本管理系统，具备海量任务并发处理能力。

  如果你有好的意见或建议，欢迎给我们提 Issues 或 Pull Requests，为蓝鲸开源社区贡献力量。
  [腾讯开源激励计划](https://opensource.tencent.com/contribution) 鼓励开发者的参与和贡献，期待你的加入。

  基于 MIT 协议， 详细请参考 [LICENSE](https://github.com/TencentBlueKing/crypto-python-sdk/blob/main/LICENSE.txt)


pkgId: fd0dbe4ffa371d07326ae55f89ac2398e0981c1306c8b9034ee01fc1e7e36e1a
name: python-bkp-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for bkp
url: https://github.com/gergelyk/bkp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bkp-1.0.0-1.src.rpm
location_href: Packages/python-bkp-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Github - Tests](https://github.com/gergelyk/bkp/actions/workflows/tests.yml/badge.svg)
  ![PyPI - Version](https://img.shields.io/pypi/v/bkp)
  ![PyPI - License](https://img.shields.io/pypi/l/bkp)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/bkp)


  Simple utility that makes backups of your files/directories.

  ![](docs/demo.gif)



  * Work with separate files or entire directories.
  * Creates simple copy or TAR archive.
  * Optionally append metadata: author, creation time, commit message (applies only to TAR archives).



  ```python
  pip install bkp
  ```



  * This software is expected to work with Python 3.6, 3.7 and compatible.
  * It has never been tested under operating systems other than Linux.
  * For editing messages interactively (``-M`` switch) you need either have `vi` installed, or set ``EDITOR`` system variable to relevant value.





  Provided that we have a file or directory: `foo/bar/baz`

  ```sh

  bkp foo/bar/baz





  bkp -r foo/bar/baz.01


  ```

  Note that multiple files can be specified in the command line. Output files are always created in the same directory where corresponding input files are located, no matter what CWD at the time.



  Alternatively `-a` flag can be used to create tar archive instead of a simple copy. Also `-m` can be used to add comments.

  ```

  bkp -am "initial version" foo/bar/baz


  bkp -i foo/bar/baz.b03
  ```

  For more options and explanations invoke `bkp --help`.




  Preparing environment:

  ```sh
  python3 -m venv venv
  source venv/bin/activate
  python3 -m pip install -r requirements.txt
  python3 -m pip install -r requirements-dev.txt
  python3 -m pip install -e .
  ```

  Modifying dependencies:

  ```sh


  pip-compile
  pip-sync

  ```

  Testing:

  ```sh
  pytest
  ```

  Releasing:

  ```sh
  echo $VERSION > bkp/VERSION
  twine upload dist/bkp-$VERSION.tar.gz
  git tag $VERSION
  git push --tags
  ```



  Author doesn't take any responsibility for loss or damage caused by this utility. You are using it on your own risk.


pkgId: c444e862e06bd31031c121eb625d8347c57966732303b990abccede4f7e73c85
name: python-blackjack-gui-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for blackjack-gui
url: https://github.com/tukiains/blackjack-gui
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blackjack-gui-1.2.1-1.src.rpm
location_href: Packages/python-blackjack-gui-help-1.2.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Blackjack GUI CI](https://github.com/tukiains/blackjack-gui/actions/workflows/test.yml/badge.svg)](https://github.com/tukiains/blackjack-gui/actions/workflows/test.yml)
  [![Downloads](https://pepy.tech/badge/blackjack-gui)](https://pepy.tech/project/blackjack-gui)

  Single-player Blackjack including graphical and command line interfaces, written in Python. Can be used to simulate games with or without card counting
  and to practise basic strategy.

  <img src="https://github.com/tukiains/blackjack-gui/blob/main/blackjack_gui/images/bj-shot.png?raw=true" alt="" width="600"/>



  `blackjack-gui` requires Python 3.9 or newer and uses [tkinter](https://en.wikipedia.org/wiki/Tkinter). Make sure it's installed in your system:

  ```
  $ sudo apt install python3-tk
  ```

  or similar (otherwise, you'll see `ModuleNotFoundError: No module named 'tkinter'`).

  Then:

  ```
  $ python3 -m venv venv
  $ source venv/bin/activate
  $ pip3 install blackjack-gui
  ```



  ```
  blackjack [-h] [--no-gui] [--ai] [--count] [--bet BET] [--stack STACK]
      [--n-games N_GAMES] [--loglevel LOGLEVEL] [--cards CARDS]
      [--dealer-cards DEALER_CARDS] [--subset {hard,soft,pairs,hard/soft}]

  ```



  | Name             | Default | Description                                                                                     |
  | :--------------- | :------ | :---------------------------------------------------------------------------------------------- |
  | `--no-gui`       | `False` | Use command line version.                                                                       |
  | `--ai`           | `False` | If True, computer plays instead of you. Only with `--no-gui`.                                   |
  | `--count`        | `False` | If True, `ai` uses card counting. Only with `--no-gui` and `--ai`.                              |
  | `--bet`          | 1       | Bet size (max 10).                                                                              |
  | `--stack`        | 1000    | Initial stack.                                                                                  |
  | `--n-games`      | 10      | Number of rounds to be played. Only with `--no-gui`.                                            |
  | `--loglevel`     | `DEBUG` | Adjust amount of logging: DEBUG or INFO. Only with `--no-gui`.                                  |
  | `--cards`        |         | Determine the first player cards, e.g. `--cards=A,8,K`. Shuffles the shoe after every hand.     |
  | `--subset`       |         | Instead of `--cards`, practice with one of the subsets: `hard`, `soft`, `pairs` or `hard/soft`. |
  | `--dealer-cards` |         | Determine the first dealer cards. Useful for testing.                                           |



  Open the GUI version:

  ```
  $ blackjack
  ```

  With the default settings, play 10 rounds of Blackjack with the command line interface:

  ```
  $ blackjack --no-gui
  ```

  Let the computer play perfect basic game and use card counting technique to bring down the house:

  ```
  $ blackjack --no-gui --ai --count --n-games=100000 --loglevel=INFO
  ```

  Simulate soft 19 starting hand only:

  ```
  $ blackjack --no-gui --ai --n-games=10000 --loglevel=INFO --cards=A,8
  ```

  Practise to play "hard" starting hands:

  ```
  $ blackjack --subset hard
  ```



  Blackjack rules vary depending on the casino. In this application they follow the rules of Casino Helsinki,
  explained in Finnish [here](http://www.rahapeliopas.fi/kasinopelit/blackjack/), i.e.:

  - 6 decs
  - Blackjack pays 3 to 2
  - Dealer must stand on soft 17
  - Any two cards can be doubled
  - Max. 4 hands can be achieved by splitting
  - Aces can be split but they receive only one extra card
  - Doubling after splitting is allowed
  - Surrender is allowed but not against Ace
  - A 7-7-7 with the first three cards (not in a split game) pays 3 to 1 directly



  <img src="https://raw.githubusercontent.com/tukiains/blackjack-gui/main/blackjack_gui/images/chart.png" alt="" width="400"/>
  <img src="https://raw.githubusercontent.com/tukiains/blackjack-gui/main/blackjack_gui/images/chart-symbols.png" alt="" width="258"/>

  - Note that 16 vs 10 with 3 or more cards = Stay



  Install `blackjack-gui` with dev-dependencies from GitHub:

  ```sh
  git clone https://github.com/tukiains/blackjack-gui
  cd blackjack-gui/
  python3 -m venv venv
  source venv/bin/activate
  pip3 install --upgrade pip
  pip3 install .[dev,test]
  pre-commit install
  ```

  Run unit and integration tests:

  ```sh
  pytest tests/unit.py
  pytest tests/integration.py
  ```

  Run `pre-commit` checks:

  ```
  pre-commit run --all
  ```



  - Deviations from the basic strategy are not yet implemented.
  - Card images taken from [here](https://code.google.com/archive/p/vector-playing-cards/).



  MIT


pkgId: 708514950860efd44202f6356ad238528c6342ec2470217e9b09df8a6fa4d5b4
name: python-blastutils-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for blastutils
url: https://github.com/lawley0316/blastutils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blastutils-1.0.1-1.src.rpm
location_href: Packages/python-blastutils-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  When using BLAST, you often need to manipulate the results, such as reading, sorting, and filtering. Biopython is a good choice, but the newer version of Biopython seems to be phasing out support for tab-delimited text files, opting for XML and XML2 formats instead. This change brings several issues:

  1. XML text is not very human-readable.
  2. XML files are significantly larger than tab-delimited text files. I encountered a case where the results file was 1.5TB in XML format, while the tab-delimited version was only 40GB.
  3. Bio.Blast.parse has a bug that sometimes raises a CorruptedXMLError (this is critical).
  4. Biopython's support for sorting, filtering, and other operations is somewhat weak.



  ```shell
  pip install blastutils
  ```





  In BLAST, an HSP (High-Scoring Segment Pair) refers to a segment of alignment between two sequences that exhibits high similarity based on certain evaluation criteria such as score, e-value, or sequence coverage. HSPs are often the most important part of a BLAST result, as they represent the strongest regions of similarity between two sequences. The HSP object has 11 attributes:

  1. `qstart` – The start position of the alignment on the query sequence.
  2. `qend` – The end position of the alignment on the query sequence.
  3. `sstart` – The start position of the alignment on the subject sequence.
  4. `send` – The end position of the alignment on the subject sequence.
  5. `mismatch` – The number of mismatches in the alignment.
  6. `gapopen` – The number of gaps in the alignment.
  7. `length` – The length of the alignment.
  8. `pident` – The percentage of identical matches.
  9. `qcovhsp` – The coverage of the query sequence by this HSP.
  10. `bitscore` – The bit score of the alignment.
  11. `evalue` – The e-value of the alignment.



  In BLAST, a Hit refers to the result of an alignment between a query sequence and a subject sequence from the database. A Hit typically contains one or more HSPs. The Hit object has 3 attributes:

  1. `sseqid` – The identifier of the subject sequence.
  2. `slen` – The length of the subject sequence.
  3. `hsps` – The HSPs associated with the hit.



  A Record represents all the results of a single query sequence, typically containing one or more Hits. The Record object has 3 attributes:

  1. `qseqid` – The identifier of the query sequence.
  2. `qlen` – The length of the query sequence.
  3. `hits` – The Hits associated with the record.





  Note: To parse BLAST alignment results using the `BlastOutputFile`, the `outfmt` parameter must be set to
  `6 qseqid qlen sseqid slen qstart qend sstart send mismatch gapopen length pident qcovhsp bitscore evalue`.

  ```python
  from blastutils import BlastOutputFile, Reader, Writer

  with BlastOutputFile('example.txt') as file:
      reader = Reader(file)
      records = []
      for record in reader:
          records.append(record)

  with BlastOutputFile('new-example.txt', 'w') as file:
      writer = Writer(file)
      for record in records:
          writer.write(record)
  ```

  `BlastOutputFile` is a wrapper for BLAST result files and has two parameters:

  1. `path` – The file path.
  2. `mode` – The mode for opening the file; 'r' for reading (default), 'w' for writing.

  You can use it with a context manager as shown above, or manage the file manually:

  ```python
  from blastutils import BlastOutputFile, Reader

  file = BlastOutputFile('example.txt')
  file.open()
  row = file.read()  # ['seq1', 100, 'ref1', 100, 1, 100, 1, 100, 0, 0, 100, 100.0, 100.0, 185.0, 8.22e-50]
  file.close()
  ```

  Pass the `BlastOutputFile` object to the `Reader` to read the results. The `Reader` is an iterator, and you can iterate over it using a for loop, or use next():

  ```python
  from blastutils import BlastOutputFile, Reader

  file = BlastOutputFile('example.txt')
  file.open()
  reader = Reader(file)
  record1 = next(reader)
  record2 = next(reader)
  file.close()
  ```



  Filtering is a very common task, for example, filtering out Hits with low similarity or low coverage. However, filtering criteria can vary widely, so `blastutils` does not provide a lot of built-in filters. Instead, it provides an API for users to implement custom filtering rules.

  `blastutils` defines a `Filter` base class, and all subclasses must implement the `__call__` method, which takes a `Hit` object as input and returns `True` if the `Hit` should be kept, or `False` if it should be filtered out.

  For example, to implement a filtering rule that removes Hits with an HSP's identity (pident) lower than 90:

  ```python
  from blastutils import Filter

  class MinSimilarity(Filter):
      def __init__(self, threshold):
          self.threshold = threshold

      def __call__(self, hit):
          if hit.is_empty():  # Filter out Hits with no HSPs
              return False
          return hit.hsps[0].pident >= self.threshold

  record.filter(MinSimilarity(90))  # Filter out Hits with identity below 90
  ```



  After obtaining BLAST results, a common task is to find the best match for each query sequence. One common approach is to sort all the Hits and select the first one. Like filtering, sorting criteria can vary, and `blastutils` does not provide a universal sorting method. Instead, it defines a Compare base class, and all subclasses must implement the `__call__` method, which takes two `Hit` objects as input:

  1. Return `-1` (or any value less than `0`) if `hit1` is better than `hit2`.
  2. Return `0` if `hit1` and `hit2` are equally good.
  3. Return `1` (or any value greater that 0) if `hit2` is better than `hit1`.

  For example, to implement a sorting rule that prefers Hits with smaller e-values and larger bit scores:

  ```python
  from blastutils import Compare

  class ByEvalueBitscore(Compare):
      def __call__(self, hit1, hit2):
          if hit2.is_empty():  # If hit2 has no HSP, hit1 is better
              return -1
          if hit1.is_empty():  # If hit1 has no HSP, hit2 is better
              return 1
          hsp1 = hit1.hsps[0]
          hsp2 = hit2.hsps[0]
          if hsp1.evalue < hsp2.evalue:
              return -1
          if hsp1.evalue > hsp2.evalue:
              return 1
          return -1 if hsp1.bitscore >= hsp2.bitscore else 1

  record.best(ByEvalueBitscore())  # You can get the best Hit without sorting
  record.sort(ByEvalueBitscore())  # Sort the Hits
  ```


pkgId: 5990b6acadae0ebcf72c598f243f847fff8e71ba235c67b0d89e43848c3e88c7
name: python-blended-tiling-help
arch: noarch
version: 0.0.1.dev7
epoch: 0
release: 1
summary: Development documents and examples for blended-tiling
url: https://github.com/progamergov/blended-tiling
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blended-tiling-0.0.1.dev7-1.src.rpm
location_href: Packages/python-blended-tiling-help-0.0.1.dev7-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub - License](https://img.shields.io/github/license/progamergov/blended-tiling?logo=github&style=flat&color=green)][#github-license]
  [![PyPI](https://img.shields.io/pypi/v/blended-tiling.svg)][#pypi-package]
  [![DOI](https://zenodo.org/badge/503953108.svg)](https://zenodo.org/badge/latestdoi/503953108)

  [#github-license]: https://github.com/progamergov/blended-tiling/blob/main/LICENSE
  [#pypi-package]: https://pypi.org/project/blended-tiling/


  This module adds support for splitting NCHW tensor inputs like images & activations into overlapping tiles of equal size, and then blending those overlapping tiles together after they have been altered. This module is also fully Autograd & JIT / TorchScript compatible.

  This tiling solution is intended for situations where one wishes to render / generate outputs that are larger than what their computing device can support. Tiles can be separately rendered and periodically blended together to maintain tile feature coherence.



  **Installation Requirements**
  - Python >= 3.6
  - PyTorch >= 1.6

  **Installation via `pip`:**

  ```
  pip install blended-tiling
  ```

  **Dev / Manual install**:

  ```
  git clone https://github.com/progamergov/blended-tiling.git
  cd blended-tiling
  pip install -e .




  ```






  The base blended tiling module.

  ```
  blended_tiling.TilingModule(tile_size=(224, 224), tile_overlap=(0.25, 0.25), base_size=(512, 512))
  ```

  **Initialization Variables**

  * `tile_size` (int or tuple of int): The size of tiles to use. A single integer to use for both the height and width dimensions, or a list / tuple of dimensions with a shape of: `[height, width]`. The chosen tile sizes should be less than or equal to the sizes of the full NCHW tensor (`base_size`).
  * `tile_overlap` (int or tuple of int): The amount of overlap to use when creating tiles. A single integer to use for both the height and width dimensions, or a list / tuple of dimensions with a shape of: `[height, width]`. The chosen overlap percentages should be in the range [0.0, 0.50] (0% - 50%).
  * `base_size` (int or tuple of int): The size of the NCHW tensor being split into tiles. A single integer to use for both the height and width dimensions, or a list / tuple of dimensions with a shape of: `[height, width]`.





  **`num_tiles()`**

    * Returns
      * `num_tiles` (int): The number of tiles that the full image shape is divided into based on specified parameters.

  **`tiling_pattern()`**

    * Returns:
      * `pattern` (list of int): The number of tiles per column and number of tiles per row, in the format of: `[n_tiles_per_column, n_tiles_per_row]`.

  **`split_into_tiles(x)`**: Splits an NCHW image input into overlapping tiles, and then returns the tiles. The `base_size` parameter is automatically readjusted to match the input.
    * Returns:
      * `tiles` (torch.Tensor): A set of tiles created from the input image.

  **`get_tile_masks(channels=3, device=torch.device("cpu"), dtype=torch.float)`**: Return a stack of NCHW masks corresponding to the tiles outputted by `.split_into_tiles(x)`.

    * Variables:
      * `channels` (int, optional): The number of channels to use for the masks. Default: 3
      * `device` (torch.device, optional): The desired device to create the masks on. Default: torch.device("cpu")
      * `dtype` (torch.dtype, optional): The desired dtype to create the masks with. Default: torch.float
    * Returns:
      * `masks` (torch.Tensor): A set of tile masks stacked across the batch dimension.


  **`rebuild(tiles, border=None, colors=None)`**: Creates and returns the full image from a stack of NCHW tiles stacked across the batch dimension.
    * Variables:
      * `tiles` (torch.Tensor): A set of tiles that may or not be masked, stacked across the batch dimension.
      * `border` (int, optional): Optionally add a border of a specified size to the edges of tiles in the full image for debugging and explainability. Set to None for no border.
      * `colors` (list of float, optional): A set of floats to use for the border color, if using borders. Default is set to red unless specified.
    * Returns:
      * `full_image` (torch.Tensor): The full image made up of tiles merged together without any blending.

  **`rebuild_with_masks(tiles, border=None, colors=None)`:** Creates and returns the full image from a stack of NCHW tiles stacked across the batch dimension, using tile blend masks.
    * Variables:
      * `tiles` (torch.Tensor): A set of tiles that may or not be masked, stacked across the batch dimension.
      * `border` (int, optional): Optionally add a border of a specified size to the edges of tiles in the full image for debugging and explainability. Set to None for no border.
      * `colors` (list of float, optional): A set of floats to use for the border color, if using borders. Default is set to red unless specified.
    * Returns:
      * `full_image` (torch.Tensor): The full image made up of tiles blended together using masks.

  **`forward(x)`:** Takes a stack of tiles, combines them into the full image with blending masks, then splits the image back into tiles.
    * Variables:
      * `x` (torch.Tensor): A set of tiles to blend the overlapping regions together of.
    * Returns:
      * `x` (torch.Tensor): A set of tiles with overlapping regions blended together.




  The `TilingModule` class has been tested with and is confirmed to work with the following PyTorch [Tensor Data types / dtypes](https://pytorch.org/docs/stable/tensors.html): `torch.float32` / `torch.float`, `torch.float64` / `torch.double`, `torch.float16` / `torch.half`, & `torch.bfloat16`.




  The `TilingModule` class is pretty easy to use.

  ```
  from blended_tiling import TilingModule


  full_size = [512, 512]
  tile_size = [224, 224]
  tile_overlap = [0.25, 0.25]  # 25% overlap on both H & W

  tiling_module = TilingModule(
      tile_size=tile_size,
      tile_overlap=tile_overlap,
      base_size=full_size,
  )


  input_shape = [tiling_module.num_tiles(), 3] + tile_size


  blended_tiles = tiling_module(torch.ones(input_shape))
  ```


  Tiles can be created and then merged back into the original tensor like this:

  ```
  full_tensor = torch.ones(1, 3, 512, 512)

  tiles = tiling_module.split_into_tiles(full_tensor)

  full_tensor = tiling_module.rebuild_with_masks(tiles)
  ```

  The tile boundaries can be viewed on the full tensor like this:

  ```
  tiles = torch.ones(9, 3, 224, 224)
  full_tensor = tiling_module.rebuild_with_masks(tiles, border=2)
  ```

  And the number of tiles and tiling pattern can be obtained like this:

  ```
  num_tiles = tiling_module.num_tiles()

  tiling_pattern = tiling_module.tiling_pattern()
  print("{}x{}".format(tiling_pattern[0], tiling_pattern[1]))
  ```




  It's also easy to modify the forward function of the tiling module:

  ```
  from typing import Union, List, Tuple
  from blended_tiling import TilingModule

  class CustomTilingModule(TilingModule):
      def __init__(
          self,
          tile_size: Union[int, List[int], Tuple[int, int]] = [224, 224],
          tile_overlap: Union[float, List[float], Tuple[float, float]] = [0.25, 0.25],
          base_size: Union[int, List[int], Tuple[int, int]] = [512, 512],
      ) -> None:
          TilingModule.__init__(self, tile_size, tile_overlap, base_size)
          self.custom_module = torch.nn.Identity()

      def forward(self, x: torch.Tensor) -> torch.Tensor:
          x = self.rebuild_with_masks(x)
          x = self.custom_module(x) + 4.0
          return self._get_tiles_and_coords(x)[0]
  ```





  To demonstrate the tile blending abilities of the `TilingModule` class, an example has been created below.



  First we'll create a set of tiles & give them all unique colors for this example:

  ```

  full_size = [768, 1014]
  tile_size = [256, 448]
  tile_overlap = [0.25, 0.25]
  tiling_module = TilingModule(
      tile_size=tile_size,
      tile_overlap=tile_overlap,
      base_size=full_size,
  )


  tile_colors = [
      [0.5334, 0.0, 0.8459],
      [0.0, 1.0, 0.0],
      [0.0, 0.7071, 0.7071],
      [0.7071, 0.7071, 0.0],
      [1.0, 0.0, 0.0],
      [0.8459, 0.0, 0.5334],
      [0.7071, 0.0, 0.7071],
      [0.0, 0.8459, 0.5334],
      [0.5334, 0.8459, 0.0],
      [0.0, 0.5334, 0.8459],
      [0.0, 0.0, 1.0],
      [0.8459, 0.5334, 0.0],
  ]
  tile_colors = torch.as_tensor(tile_colors).view(12, 3, 1, 1)


  tiles = torch.ones([tiling_module.num_tiles(), 3] + tile_size)


  tiles = tiles * tile_colors
  ```

  <img src="https://github.com/ProGamerGov/blended-tiling/raw/main/examples/without_masks_separate_tiles.jpg" width="500">

  Next we apply the blend masks to the tiles:

  ```
  tiles = tiles * tiling_module.get_tile_masks()
  ```

  <img src="https://github.com/ProGamerGov/blended-tiling/raw/main/examples/with_masks_separate_tiles.jpg" width="500">


  We can now combine the masked tiles into the full image:

  ```

  output = tiling_module.rebuild(tiles)
  ```

  <img src="https://github.com/ProGamerGov/blended-tiling/raw/main/examples/with_masks.jpg" width="500">

  We can also view the tile boundaries like so:

  ```

  output = tiling_module.rebuild(tiles, border=2, colors=[0,0,0])
  ```

  <img src="https://github.com/ProGamerGov/blended-tiling/raw/main/examples/with_masks_and_borders.jpg" width="500">

  We can view an animation of the tiles being added like this:

  ```
  from torchvision.transforms import ToPILImage

  tile_steps = [
      tiling_module.rebuild(tiles[: i + 1]) for i in range(tiles.shape[0])
  ]
  tile_frames = [
      ToPILImage()(x[0])
      for x in [torch.zeros_like(tile_steps[0])] + tile_steps + [tile_steps[-1]]
  ]
  tile_frames[0].save(
      "tiles.gif",
      format="GIF",
      append_images=tile_frames[1:],
      save_all=True,
      duration=700,
      loop=0,
  )
  ```

  <img src="https://github.com/ProGamerGov/blended-tiling/raw/main/examples/with_masks.gif" width="500">


pkgId: 56646ca4db93ec974cdc414b53706b4b551a21ba2fa927adcb469d95d595ac36
name: python-blender-extension-builder-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for blender-extension-builder
url: https://github.com/ego-lay-atman-bay/blender-extension-builder
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blender-extension-builder-1.0.1-1.src.rpm
location_href: Packages/python-blender-extension-builder-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A builder for blender extensions.

  Blender allows you to add dependencies via packaging wheels with the extension, however you have to manually grab the wheels and put the filenames in the `blender_manifest.toml` file. This can be cumbersome, especially with many dependencies, and dependencies of dependencies that you don't control. This project aims to aid in that, and make it all a lot easier.



  Install via pip

  ```
  pip install blender-extension-builder
  ```

  You also need Blender available on the PATH in order to build the extension.



  You can use the command

  ```
  build-blender-extension -h
  ```

  Or

  ```
  python -m build_blender_extension -h
  ```



  Since this aims to make managing dependencies easier, there are a couple things added to the `blender_manifest.toml` file. The file will be structured like any `blender_manifest.toml` file, just with a few new options.

  ```toml
  schema_version = "1.0.0"
  id = "my_example_extension"
  version = "1.0.0"
  name = "My Example Extension"
  tagline = "This is another extension"
  maintainer = "Developer name <email@address.com>"
  type = "add-on"
  blender_version_min = "4.2.0"
  license = [
    "SPDX:GPL-3.0-or-later",
  ]


  dependencies = [
      'numpy'
  ]

  wheel-path = './wheels'



  wheels = [
    './wheels/pillow-10.3.0-cp311-cp311-win_amd64.whl',
  ]

  [build]



  source = './src'

  build = './build'

  dist = './dist'


  paths_include = [
    'LICENSE',
    'README.md',
  ]
  ```

  All you have to do is now run

  ```
  build-blender-extension -m blender_manifest.toml
  ```

  Note: if you don't specify any arguments, it will try to use `blender_manifest.toml`.

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


pkgId: b3e47c8f6a9ad49a85cc294d4c356bca1cf96dc2b4957b6dcacd3dd4b0c0d40b
name: python-blender_notebook-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for blender_notebook
url: https://pypi.org/project/blender_notebook/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blender_notebook-0.0.4-1.src.rpm
location_href: Packages/python-blender_notebook-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  A simple command line tool to wrap blender 2.8+ as a jupyter kernel.

  Blender's python API requires its embedded python interpreter. As of Blender 4.3, python 3.11 is packaged. In order to make ipykernel and other pip packages accessible to Blender, the `site-packages` directory of the python interpreter executing blender_notebook will be added to Blender's python path. Therefore, it's highly recommended to use exactly the same python version as your blender.



  The easiest way to install blender_notebook is via pip:
  ```
  $ python -m pip install blender_notebook
  ```

  It can also be installed from source:
  ```
  $ python -m pip install -e .
  ```



  If blender in installed by a package manager, the easiest way to find the executable path is:
  ```
  $ which blender
  /snap/bin/blender
  ```
  In my case, blender is installed from snap.

  On MacOS, the blender executable path is usually:
  ```
  /Applications/Blender.app/Contents/MacOS/Blender
  ```

  On Windows, the blender executable path is usually:
  ```
  C:\Program Files\Blender Foundation\Blender 4.3\blender.exe
  ```

  Then, run the blender_notebook CLI (replace `"snap/bin/blender"` with your blender executable path):
  ```
  $ blender_notebook install --blender-exec="/snap/bin/blender"
  Saving files to ~/.local/share/jupyter/kernels/blender
  ```
  If you launch jupyter notebook as usual, a new kernel named `blender` should be available.
  ```
  $ jupyter kernelspec list
  Available kernels:
  blender              ~/.local/share/jupyter/kernels/blender

  $ jupyter notebook
  ```

  You can also delete the kernel:
  ```
  $ blender_notebook remove
  Are you sure to delete ~/.local/share/jupyter/kernels/blender ? [y/N]: y
  blender jupyter kernel is removed!
  ```




  1. uv sync
  2. uv build
  3. uv publish






  * ajust README to Blender 4.3
  * Change build system from setup.py to pyproject.toml


pkgId: 04bf166fa5e513a2c41945e82147ab6f28d7cc8b4a987aa81ba557fbfdc21d03
name: python-blint-help
arch: noarch
version: 2.3.2
epoch: 0
release: 1
summary: Development documents and examples for blint
url: https://github.com/OWASP-dep-scan/blint
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blint-2.3.2-1.src.rpm
location_href: Packages/python-blint-help-2.3.2-1.noarch.rpm
checksum_type: sha256
description:
  <img src="./blint.png" width="400" />

  BLint is a Binary Linter that checks the security properties and capabilities of your executables. It is powered by [lief](https://github.com/lief-project/LIEF). Since version 2, blint can also generate Software Bill-of-Materials (SBOM) for supported binaries.

  [![BLint Demo](https://asciinema.org/a/438138.png)](https://asciinema.org/a/438138)

  Supported binary formats:

  - Android (apk, aab)
  - ELF (GNU, musl)
  - PE (exe, dll)
  - Mach-O (x64, arm64)

  You can run blint on Linux, Windows, and Mac against any of these binary formats.



  Nowadays, vendors distribute statically linked binaries produced by Golang, Rust, or Dotnet tooling. Users are used to running antivirus and anti-malware scans while using these binaries in their local devices. Blint augments these scans by listing the technical capabilities of a binary. For example, whether the binary could use network connections or can perform file system operations and so on.
  The binary is first parsed using the lief framework to identify the various properties, such as functions and the presence of symtab and dynamic symbols. Thanks to YAML-based annotation data, this information can be matched against capabilities and presented visually using a rich table.
  NOTE: The presence of capabilities doesn't imply that the binary always performs the operations. Use the output of this tool to get an idea about a binary. Also, this tool is not suitable for reviewing malware and other heavily obfuscated binaries for obvious reasons.



  - Quickly identify malicious binaries by looking at their capabilities (Ability to manipulate networks or drivers or kernels etc)
  - Add blint to CI/CD to inspect the final binaries to ensure code signing or authenticode is applied correctly
  - Identify interesting functions and symbols for fuzzing



  - Install python 3.10, 3.11, or 3.12

  ```bash
  pip install blint
  ```



  You can download single binary builds from the [blint-bin releases](https://github.com/OWASP-dep-scan/blint/releases). These executables should work without requiring python to be installed. The macOS .pkg file is signed with a valid developer account.



  ```shell
  usage: blint [-h] [-i SRC_DIR_IMAGE [SRC_DIR_IMAGE ...]] [-o REPORTS_DIR] [--no-error] [--no-banner]
               [--no-reviews] [--suggest-fuzzable]
               {sbom} ...

  Binary linter and SBOM generator.

  options:
    -h, --help            show this help message and exit
    -i SRC_DIR_IMAGE [SRC_DIR_IMAGE ...], --src SRC_DIR_IMAGE [SRC_DIR_IMAGE ...]
                          Source directories, container images or binary files. Defaults to current directory.
    -o REPORTS_DIR, --reports REPORTS_DIR
                          Reports directory. Defaults to reports.
    --no-error            Continue on error to prevent build from breaking.
    --no-banner           Do not display banner.
    --no-reviews          Do not perform method reviews.
    --suggest-fuzzable    Suggest functions and symbols for fuzzing based on a dictionary.

  sub-commands:
    Additional sub-commands

    {sbom}
      sbom                Command to generate SBOM for supported binaries.
  ```



  ```shell
  usage: blint sbom [-h] [-i SRC_DIR_IMAGE [SRC_DIR_IMAGE ...]] [-o SBOM_OUTPUT] [--deep] [--stdout] [--exports-prefix EXPORTS_PREFIX [EXPORTS_PREFIX ...]]
                    [--bom-src SRC_DIR_BOMS [SRC_DIR_BOMS ...]]

  options:
    -h, --help            show this help message and exit
    -i SRC_DIR_IMAGE [SRC_DIR_IMAGE ...], --src SRC_DIR_IMAGE [SRC_DIR_IMAGE ...]
                          Source directories, container images or binary files. Defaults to current directory.
    -o SBOM_OUTPUT, --output-file SBOM_OUTPUT
                          SBOM output file. Defaults to bom-post-build.cdx.json in current directory.
    --deep                Enable deep mode to collect more used symbols and modules aggressively. Slow operation.
    --stdout              Print the SBOM to stdout instead of a file.
    --exports-prefix EXPORTS_PREFIX [EXPORTS_PREFIX ...]
                          prefixes for the exports to be included in the SBOM.
    --bom-src SRC_DIR_BOMS [SRC_DIR_BOMS ...]
                          Directories containing pre-build and build BOMs. Use to improve the precision.
  ```

  To test any binary, including default commands

  ```bash
  blint -i /bin/netstat -o /tmp/blint
  ```

  Use -i to check any other binary. For eg: to check ngrok

  ```bash
  blint -i ~/ngrok -o /tmp/blint
  ```

  Pass `--suggest-fuzzable` to get suggestions for fuzzing. A dictionary containing "common verbs" is used to identify these functions.

  ```bash
  blint -i ~/ngrok -o /tmp/blint --suggest-fuzzable
  ```

  To generate SBOM in [CycloneDX format](https://cyclonedx.org/) for supported binaries, use the sbom sub-command.

  ```shell
  blint sbom -i /path/to/apk -o bom.json
  ```

  ```shell
  blint sbom -i /directory/with/apk/aab -o bom.json
  ```

  To parse all files, including `.dex` files, pass `--deep` argument.

  ```shell
  blint sbom -i /path/to/apk -o bom.json --deep
  ```

  The following binaries are supported:

  - Android (apk/aab)
  - Dotnet executable binaries
  - Go binaries
  - Rust binaries

  ```shell
  blint sbom -i /path/to/go-binaries -o bom.json --deep
  ```

  For all other binaries, the symbols will be collected and represented as properties with `internal` prefixes for the parent component. Child components and dependencies would be missing.

  PowerShell example

  ![PowerShell](./docs/blint-powershell.jpg)



  Blint produces the following json artifacts in the reports directory:

  - blint-output.html - HTML output from the console logs
  - exename-metadata.json - Raw metadata about the parsed binary. Includes symbols, functions, and signature information
  - findings.json - Contains information from the security properties audit. Useful for CI/CD integrations
  - reviews.json - Contains information from the capability reviews. Useful for further analysis
  - fuzzables.json - Contains a suggested list of methods for fuzzing

  sbom command generates CycloneDX json.



  - [lief examples](https://github.com/lief-project/LIEF/tree/master/examples)
  - [checksec](https://github.com/Wenzel/checksec.py)



  The developers can be reached via the [Discord](https://discord.gg/DCNxzaeUpd) channel.



  If you love blint, you should consider [donating](https://owasp.org/donate?reponame=www-project-dep-scan&title=OWASP+dep-scan) to our project. In addition, consider donating to the below projects, which make blint possible.

  - [LIEF](https://github.com/sponsors/lief-project/)


pkgId: 80bf4d52bf5dadce6c7e5551d15f2db1671aa14a825d8a3a87ed0697b8a953b9
name: python-blksprs-help
arch: noarch
version: 1.9.3
epoch: 0
release: 1
summary: Development documents and examples for blksprs
url: https://github.com/FelixSchoen/blksprs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blksprs-1.9.3-1.src.rpm
location_href: Packages/python-blksprs-help-1.9.3-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub Release](https://img.shields.io/github/v/release/FelixSchoen/blksprs?include_prereleases&label=Latest%20Release)](https://github.com/FelixSchoen/blksprs/releases)
  [![Python Version](https://img.shields.io/badge/Python%20Version-3.11-blue)](https://www.python.org/downloads/release/python-3119/)



  🚨 **Non-Final API** 🚨

  Although it already supports a wide variety of functions, this library is still under active development and the API is
  subject to change. For feature requests or bug reports, please open an [issue](https://github.com/FelixSchoen/blksprs/issues).
  We also encourage [pull requests](https://github.com/FelixSchoen/blksprs/pulls).



  A lightweight and efficient library for operations on block-sparse matrices in PyTorch using Triton.

  Currently supported operations (includes gradient calculation):

  - Matrix multiplication
  - Softmax
  - Transpose
  - Gather
  - Scatter (_supports either no reduction or summation, gradients are only available for summation_)
  - Repeat (_supports target sparsity layout_)
  - Repeat Interleave (_supports target sparsity layout_)
  - Splitting and merging of matrices along the last dimension
  - Conversion to and from sparse form
  - Conversion to different sparsity layouts and different sparsity block sizes

  As with this library sparse matrices are represented using a tuple of `(matrix, sparsity_layout, sparsity_block_size)`,
  any element-wise operations can be applied in regular torch-like fashion.
  These include, e.g.,

  - Element-wise addition and subtraction
  - Element-wise multiplication and division
  - Element-wise exponentiation
  - ...

  Note that in order to correctly apply element-wise operations between two sparse tensors their sparsity layouts have to
  match.

  Further helpful operations (included in the ``bs.ops.misc`` module) that do **not** support gradient calculation include:

  - Row-wise sum, max, addition, and subtraction
  - Broadcast addition and subtraction between slices

  Furthermore, the library provides a set of utility functions

  - for the creation of sparsity layouts based on existing
  dense tensors and for the scatter operation (module ``bs.layouting``),
  - for the application of ``nn.Linear``, ``nn.Dropout``, and ``nn.LayerNorm`` layers to block-sparse tensors,
  - as well as utility functions to apply linear layers,
  ensure correct input dimensionality, and validate input (module ``bs.utils``).



  Note that due to the dependency on [Triton](https://github.com/triton-lang/triton) this library is only compatible with
  the Linux platform.

  We recommend installing blksprs from [PyPI](https://pypi.org/project/blksprs/) using pip:

  ```pip install blksprs```



  - [PyTorch](https://pytorch.org/) (built with v2.5.1)
  - _[NumPy](https://numpy.org/) (to get rid of warnings, built with v2.2.0)_
  - _[Triton](https://github.com/triton-lang/triton) (included with PyTorch)_



  See [`CHANGELOG.md`](https://github.com/FelixSchoen/blksprs/blob/main/CHANGELOG.md) for a detailed changelog.



  We provide an example below to demonstrate the usage of the library.
  For more detailed examples, please refer to
  the [test cases](https://github.com/FelixSchoen/blksprs/blob/main/test/cases/test_blocksparse.py) which cover all
  implemented operations and functions.
  The example below can also be found in
  the [test cases](https://github.com/FelixSchoen/blksprs/blob/main/test/cases/test_readme.py).

  ```python
  import torch
  import blksprs as bs


  def test_readme():
      
      b, h, m, n, k = 2, 4, 64, 64, 16

      
      sparsity_percentage = 25

      
      sparsity_block_size = 16

      
      
      triton_block_size = None

      
      x = torch.randn(size=(b, h, m, k), device="cuda")
      y = torch.randn(size=(b, h, n, k), device="cuda").transpose(-1, -2).contiguous()

      
      x_dense, x_shape_original = bs.utils.do_shape_blocksparse(x)
      y_dense, y_shape_original = bs.utils.do_shape_blocksparse(y)

      
      sparsity_layout_x = bs.layouting.build_sparsity_layout(x_dense, sparsity_block_size,
                                                             triton_block_size=triton_block_size)
      sparsity_layout_y = bs.layouting.build_sparsity_layout(y_dense, sparsity_block_size,
                                                             triton_block_size=triton_block_size)

      
      sparsity_layout_o = _get_random_sparsity_layout(b * h, m, n, sparsity_block_size, sparsity_percentage)

      
      x_sparse = bs.to_sparse(x_dense, sparsity_layout_x, sparsity_block_size, triton_block_size=triton_block_size)
      y_sparse = bs.to_sparse(y_dense, sparsity_layout_y, sparsity_block_size, triton_block_size=triton_block_size)

      
      o_sparse = bs.matmul(x_sparse, sparsity_layout_x, y_sparse, sparsity_layout_y, sparsity_layout_o,
                           sparsity_block_size,
                           triton_block_size=triton_block_size)

      
      o_sparse = torch.add(o_sparse, 1)

      o_dense = bs.to_dense(o_sparse, sparsity_layout_o, sparsity_block_size, triton_block_size=triton_block_size)

      
      o_torch = torch.matmul(x_dense, y_dense)
      o_torch = torch.add(o_torch, 1)

      
      o_torch_round_trip = bs.to_dense(
          bs.to_sparse(o_torch, sparsity_layout_o, sparsity_block_size, triton_block_size=triton_block_size),
          sparsity_layout_o, sparsity_block_size, fill_value=0, triton_block_size=triton_block_size)

      
      assert torch.allclose(o_dense, o_torch_round_trip, atol=2e-2)  # Note that small numerical differences are expected

      
      actual_sparsity_layout_o = bs.layouting.build_sparsity_layout(o_dense, sparsity_block_size,
                                                                    triton_block_size=triton_block_size)
      assert torch.allclose(actual_sparsity_layout_o.to(torch.int), sparsity_layout_o)

      
      o = bs.utils.undo_shape_blocksparse(o_dense, x_shape_original)

      
      bs.transpose(o_sparse, sparsity_layout_o, sparsity_block_size, triton_block_size=triton_block_size)
      bs.softmax(o_sparse, sparsity_layout_o, sparsity_block_size, triton_block_size=triton_block_size)
      bs.misc.row_wise_sum(o_sparse, sparsity_layout_o, sparsity_block_size, triton_block_size=triton_block_size)
      bs.misc.row_wise_max(o_sparse, sparsity_layout_o, sparsity_block_size, triton_block_size=triton_block_size)


  def _get_random_sparsity_layout(b, m, n, sparsity_block_size, sparsity_percentage):
      """Helper function, creates a random sparsity layout for a given shape with a given percentage of blocks marked as sparse.

      """
      m_s = m // sparsity_block_size
      n_s = n // sparsity_block_size

      sparsity_layout = torch.ones(size=(b, m_s, n_s), device="cuda", dtype=torch.int)

      num_zero_elements = int(m_s * n_s * (sparsity_percentage / 100))
      for b_i in range(b):
          indices = torch.randperm(m_s * n_s)[:num_zero_elements]
          sparsity_layout[b_i, indices // n_s, indices % n_s] = 0

      return sparsity_layout
  ```


pkgId: 975fc1c0c00a28c9a8bafd6084e2202dc1631a88fa37941bdcd77f0b54390567
name: python-block-cascade-help
arch: noarch
version: 2.7.1
epoch: 0
release: 1
summary: Development documents and examples for block-cascade
url: https://pypi.org/project/block-cascade/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-block-cascade-2.7.1-1.src.rpm
location_href: Packages/python-block-cascade-help-2.7.1-1.noarch.rpm
checksum_type: sha256
description:
  Cascade is a library for submitting and managing jobs across multiple cloud environments. It is designed to integrate seamlessly into existing Prefect workflows or can be used as a standalone library.





    ```bash
    poetry add block-cascade
    ```
  or
  ```
  pip install block-cascade
  ```



  ```python
  from block_cascade import remote
  from block_cascade import GcpEnvironmentConfig, GcpMachineConfig, GcpResource

  machine_config = GcpMachineConfig("n2-standard-4", 1)
  environment_config = GcpEnvironmentConfig(
      project="example-project",
      region="us-west1",
      service_account=f"example-project@vertex.iam.gserviceaccount.com",
      image="us.gcr.io/example-project/cascade/cascade-test",
      network="projects/123456789123/global/networks/shared-vpc"
  )
  gcp_resource = GcpResource(
      chief=machine_config,
      environment=environment_config,
  )

  @remote(resource=gcp_resource)
  def addition(a: int, b: int) -> int:
      return a + b

  result = addition(1, 2)
  assert result == 3
  ```


  Cascade supports defining different resource requirements via a configuration file titled either cascade.yaml or cascade.yml. This configuration file must be located in the working directory of the code execution to be discovered at runtime.

  ```yaml
  calculate:
    type: GcpResource
    chief:
      type: n1-standard-1
  You can even define a default configuration that can be overridden by specific tasks to eliminate redundant definitions.

  default:
      GcpResource:
          environment:
              project: example-project
              service_account: example-project@vertex.iam.gserviceaccount.com
              region: us-central-1
          chief:
              type: n1-standard-4
  ```


  Cascade requires authorization both to submit jobs to either GCP or Databricks and to stage picklied code to a cloud storage bucket. In the GCP example below, an authorization token is obtained via IAM by running the following command:

  ```bash
  gcloud auth login --update-adc
  ```
  No additional configuration is required in your application's code to use this token.

  However, for authenticating to Databricks and AWS you will need to provide a token and secret key respectively. These can be passed directly to the `DatabricksResource` object or set as environment variables. The following example shows how to provide these values in the configuration file.




  When developing cascade, you can optionally use [hermit](https://cashapp.github.io/hermit/usage/get-started/) to manage the Python executable used by cascade. Together with using poetry to manage dependencies, this will ensure that your development environment is identical to other contributors. Follow the linked instructions for installing hermit and then you can create a virtualenv with Python@3.9 by running:

  `. ./bin/activate-hermit`

  Then, install the dependencies with poetry:
  `poetry install`


pkgId: 8070465949ea1dcce5a07acf00e9f7cccc71122dad13918f9d157986a5323f87
name: python-blockapi-help
arch: noarch
version: 0.51.3
epoch: 0
release: 1
summary: Development documents and examples for blockapi
url: https://pypi.org/project/blockapi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blockapi-0.51.3-1.src.rpm
location_href: Packages/python-blockapi-help-0.51.3-1.noarch.rpm
checksum_type: sha256
description:
  Library to interact with numerous cryptocurrency data APIs to get the basic info about account balance, transactions, staking informations, etc.
  List of supported coins:

  | coin  | API name | supported operations
  | :---- | :------------| :---------------------
  | XTZ   | TzscanAPI   | balance, transactions, activations, originations, delegations, endorsements, bakings
  |       | TzStatsAPI  | staking (balance, rewards)
  | ATOM  | CosmosAPI   | balance, transactions, rewards, delegates, votes
  | DCR   | DcrdataAPI  | balance, transactions
  | ADA   | CardanoExplorerAPI | balance, transactions
  | ZEC   | ChainSoAPI  | balance, transactions
  |       | MercerweissAPI | balance
  |       | ZchainAPI | balance
  | ETC   | BlockscoutAPI | balance
  | NEO   | NeoscanAPI | balance, transactions
  | ZEN   | ZensystemAPI | balance
  | DASH  | ChainSoAPI | balance, transactions
  |       | CryptoIDAPI | balance
  | DOGE  | ChainSoAPI |balance, transactions
  | BNB   | BinanceAPI |balance,transactions
  | EOS   | EosparkAPI |balance, transactions
  |       | GreymassAPI | balance
  | BCH   | BtcAPI | balance
  | XLM   | StellarAPI | balance
  | RVN   | RavencoinAPI | balance
  | TRX   | TronscanAPI | balance
  | LTC   | BlockcypherAPI | balance
  |       | ChainSoAPI | balance, transactions
  |       | CryptoIDAPI | balance
  |       | Ltc1TrezorAPI | balance, transactions
  | BTC   | BlockchainInfoAPI | balance, transactions
  |       | BlockonomicsAPI | balance, transactions
  |       | ChainSoAPI | balance, transactions
  |       | Btc1TrezorAPI | balance, transactions
  |       | Btc2TrezorAPI | balance, transactions
  |       | BitpayAPI | balance
  | GRS   | CryptoIDAPI | balance
  | ETH   | AlethioAPI | balance, transactions, events
  |       | EtherscanAPI | balance, transactions
  |       | EthplorerAPI | balance
  | ONT   | OntioAPI | balance, transactions
  | VET   | DigonchainAPI | balance
  | BOS   | BlockchainosAPI | balance, transactions
  | LUNA  | TerraMoneyAPI | balance, transactions, delegations
  | DOT   | SubscanPolkaAPI | balance, transactions, staking (locked, rewards)
  | KSM   | SubscanKusamaAPI | balance, transactions, staking (locked, rewards)



  These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.



  Python 3.x, PIP (if you'd like to install it this way).



  Library can be installed simply with pip:

  ```
  pip install blockapi
  ```

  or by running:
  ```
  make install
  ```



  Example usage to get account balance:
  ```
  import blockapi
  myobj = blockapi.api.BlockchainInfoAPI("bitcoin-address-here")
  myobj.get_balance()
  ```

  For some coins there are multiple APIs available. With get_random_api_class_for_coin it is possible
  to randomly pick any of the available APIs:
  ```
  myapi = blockapi.get_random_api_class_for_coin('BTC')('1F1tAaz5x1HUXrCNLbtMDqcw6o5GNn4xqX')
  myapi.get_balance()
  ```

  To directly pick first random working API and ask it for the account balance:
  ```
  >>> blockapi.get_balance_from_random_api('BTC','16ftSEQ4ctQFDtVZiUBusQUjRrGhM3JYwe')
  0.010034040000000001
  ```

  It is possible to ask for a list of working APIs for a coin. They are automatically checked first if they work (test is done with asking for a balance). Only APIs which pass this check are returned:
  ```
  >>> blockapi.get_working_apis_for_coin('BTC')
  (<class 'blockapi.api.blockchaininfo.BlockchainInfoAPI'>, <class 'blockapi.api.blockonomics.BlockonomicsAPI'>, <class 'blockapi.api.insight.BitpayAPI'>, <class 'blockapi.api.trezor.Btc2TrezorAPI'>, <class 'blockapi.api.trezor.Btc1TrezorAPI'>)
  ```

  During the API instance creation the supplied address is being checked for validity, if the address
  is not valid, ValueError exception is being raised:
  ```
  >>> import blockapi
  >>> blockapi.api.CosmosAPI('blahblah')
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/srv/apps/blockapi/src/blockapi/blockapi/services.py", line 195, in __init__
  self.check_validity()
  File "/srv/apps/blockapi/src/blockapi/blockapi/services.py", line 201, in check_validity
  self.symbol, self.address_info.address
  ValueError: Not a valid ATOM address: b'blahblah'
  ```

  It is possible to display the result of the address validation with included details like validity, network type, address type, or the info whether the supplied address is an extended one.
  Not for all coins all the details are available though:
  ```
  >>> import blockapi
  >>> myapi = blockapi.api.TzscanAPI('valid tezos address here')
  >>> myapi.address_info
  ValidationResult(name='tezos', ticker='xtz', address=b'valid tezos-address here', valid=True, network='both', is_extended=False, address_type='originated_account')
  ```



  To run the included tests simply issue:

  ```
  make test
  ```



  TBD



  * **Devmons s.r.o. - *Initial work* - [crypkit](https://github.com/crypkit)

  See also the list of [contributors](https://github.com/crypkit/blockapi/contributors) who participated in this project.



  * **Chris Priest - *moneywagon library we took many ideas from* - [moneywagon](https://github.com/priestc/moneywagon)
  * **Joe Black - *Address validation library* - [coinaddr](https://github.com/joeblackwaslike/coinaddr)



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


pkgId: 20aee5b7eb64ea403641386bdb68f59388a9c7c976b41b4c1bd0901fb6bd6be4
name: python-blofin-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for blofin
url: https://github.com/nomeida/blofin-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blofin-0.5.0-1.src.rpm
location_href: Packages/python-blofin-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python SDK for the BloFin API, providing easy access to BloFin's trading platform functionalities.



  You can install the BloFin API SDK using pip:

  ```bash
  pip install blofin
  ```



  Here's a quick example of how to use the BloFin API SDK:

  ```python
  from blofin import BloFinClient


  client = BloFinClient(
      api_key='your_api_key',
      api_secret='your_api_secret',
      passphrase='your_passphrase',
      use_server_time=False, #Default: False - If you want to use BloFin's server time for requests
  )



  ```



  The SDK provides access to various APIs:



  The Public API allows you to access public market data without authentication.

  ```python

  instruments = client.public.get_instruments(inst_type='SWAP')


  tickers = client.public.get_tickers(inst_id='BTC-USDT')


  order_book = client.public.get_order_book(inst_id='BTC-USDT', size=20)


  candles = client.public.get_candlesticks(inst_id='BTC-USDT', bar='1m', limit=100)
  ```



  The Account API allows you to manage your account information and perform account-related operations.

  ```python

  balance = client.account.get_balance(account_type='futures')


  transfer = client.account.funds_transfer(
      currency='USDT',
      amount=100,
      from_account='funding',
      to_account='futures'
  )


  deposits = client.account.get_deposit_history(currency='USDT', limit=10)
  ```



  The Trading API allows you to place and manage orders, as well as retrieve trading-related information.

  ```python

  order = client.trading.place_order(
      inst_id='BTC-USDT',
      margin_mode='cross',
      position_side='long',
      side='buy',
      order_type='limit',
      price=30000,
      size=0.01
  )


  positions = client.trading.get_positions(inst_id='BTC-USDT')


  cancel = client.trading.cancel_order(inst_id='BTC-USDT', order_id='123456')


  history = client.trading.get_order_history(inst_id='BTC-USDT', limit=50)
  ```



  1. **API Credentials**: To use authenticated endpoints, you need to provide your BloFin API credentials (API key, API secret, and passphrase) when initializing the client.

  2. **Rate Limiting**: Be aware of BloFin's rate limits for API requests. Exceeding these limits may result in temporary blocks or account suspension.

  3. **Error Handling**: The SDK uses custom exceptions to handle various error scenarios. Always wrap your API calls in try-except blocks to handle potential errors gracefully.

  4. **Pagination**: Some methods that return lists of items (e.g., order history) support pagination. Use the `before`, `after`, and `limit` parameters to navigate through large result sets.

  5. **Server Time**: If you experience timestamp-related issues, you can initialize the client with `use_server_time=True` to use BloFin's server time for requests.



  Contributions to the BloFin API SDK are welcome! Please refer to the project's GitHub repository for information on how to contribute, report issues, or request features.



  - Websocket support



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



  This SDK is not officially associated with BloFin.


pkgId: 12270af629a884c253819df3ab0b9a2dc5ac2b40468dbb5500b6716c28935c1e
name: python-blog-app-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for blog-app
url: https://gitlab.com/y.karzal/2024_assignment2_blogpss
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blog-app-0.1.1-1.src.rpm
location_href: Packages/python-blog-app-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A simple blog application built with Flask.



  - View all blog posts
  - Add new posts
  - Automatic timestamps for each post



  ```
  blog-app/
  ├── __init__.py
  ├── config.py
  ├── database.py
  └── posts.py
  ```



  1. Install the package
      ```bash
      pip install blog-app
      ```

  2. Run the application
      ```bash
      python blog-app
      ```

  3. Done
     - The API will be available at `http://localhost:5000`



  1. Clone the repository
      ```bash
      git https://gitlab.com/y.karzal/2024_assignment2_blogpss
      cd 2024_assignment2_blogpss
      ```

  2. Set up the application
      ```bash
      python -m venv .venv
      source .venv/bin/activate
      pip install -r requirements.txt
      ```

  3. Run the application
      ```bash
      python run.py
      ```

  4. Done
     - The API will be available at `http://localhost:5000`



  install pytest:
  ```bash
  pip install pytest
  ```

  Run backend unit tests:
  ```bash
  pytest tests/unit
  ```

  Run backend integration tests:
  ```bash
  pytest tests/integration
  ```


pkgId: 9b7c00c162fa7ca6e56a6bcaad3bf2639e6354b77e756abe3d86f0382306533b
name: python-bloodyAD-help
arch: noarch
version: 2.1.4
epoch: 0
release: 1
summary: Development documents and examples for bloodyAD
url: https://github.com/CravateRouge/bloodyAD
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bloodyAD-2.1.4-1.src.rpm
location_href: Packages/python-bloodyAD-help-2.1.4-1.noarch.rpm
checksum_type: sha256
description:
  > :warning: autobloody has been moved to its own [repo](https://github.com/CravateRouge/autobloody)



  `bloodyAD` is an Active Directory privilege escalation swiss army knife



  This tool can perform specific LDAP calls to a domain controller in order to perform AD privesc.

  `bloodyAD` supports authentication using cleartext passwords, pass-the-hash, pass-the-ticket or certificates and binds to LDAP services of a domain controller to perform AD privesc.

  Exchange of sensitive information without LDAPS is supported.

  It is also designed to be used transparently with a SOCKS proxy.


  Simple usage:

  ```ps1
  bloodyAD --host 172.16.1.15 -d bloody.local -u jane.doe -p :70016778cb0524c799ac25b439bd6a31 set password john.doe 'Password123!'
  ```

  See the [wiki](https://github.com/CravateRouge/bloodyAD/wiki) for more.


  Like this project? Donations are greatly appreciated :relaxed: [![](https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86)](https://github.com/sponsors/CravateRouge)

  Need personalized support? send us an [email](mailto:contact@cravaterouge.com) or check our website [cravaterouge.com](https://cravaterouge.com/?utm_source=bloodyad_readme) to see all our cybersecurity services.


  - Thanks to [@skelsec](https://github.com/skelsec) for his amazing libraries especially [MSLDAP](https://github.com/skelsec/msldap) which is now the engine on which bloodyAD is running.
  - Thanks to [impacket](https://github.com/fortra/impacket) contributors. [Structures](https://github.com/fortra/impacket/blob/master/impacket/structure.py) and several [LDAP attacks](https://github.com/fortra/impacket/blob/master/impacket/examples/ntlmrelayx/attacks/ldapattack.py) are based on their work.
  - Thanks to [@PowerShellMafia](https://github.com/PowerShellMafia) team ([PowerView.ps1](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1)) and their work on AD which inspired this tool.
  - Thanks to [@dirkjanm](https://github.com/dirkjanm) ([adidnsdump.py](https://github.com/dirkjanm/adidnsdump)) and ([@Kevin-Robertson](https://github.com/Kevin-Robertson))([Invoke-DNSUpdate.ps1](https://github.com/Kevin-Robertson/Powermad/blob/master/Invoke-DNSUpdate.ps1)) for their work on AD DNS which inspired DNS functionnalities.
  - Thanks to [@p0dalirius](https://github.com/p0dalirius/) and his [pydsinternals](https://github.com/p0dalirius/pydsinternals) module which helped to build the shadow credential attack


pkgId: 274109d93c3db4eacc7355729243c5b348b7998f708dc5a55ec53dbfda374a11
name: python-blue-yonder-help
arch: noarch
version: 0.0.21
epoch: 0
release: 1
summary: Development documents and examples for blue-yonder
url: https://github.com/alxfed/blue-yonder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blue-yonder-0.0.21-1.src.rpm
location_href: Packages/python-blue-yonder-help-0.0.21-1.noarch.rpm
checksum_type: sha256
description:
  This is a Bluesky Python API for humans. It can be used for the simple automations that you _know_ should be implemented, but they are just 'not there' in a pretty annoying way. But you know how to program in Python... And you have an IDE like PyCharm(R), VSCode or even Cursor or Windsurf...

  <br>Or, maybe, you are experimenting with instructing Language Models and would like to see whether _they_ will make your 'social presence' less stressful and more meaningful by assessing whether the content that you are about to see is worth looking at or it is something that you will wish you would be able to 'unsee' later...

  <br>Here comes the Blue Yonder Python package. It has been built with a perspective of a person who does not need (or want any of) the professional jargon of software engineers and 'coders'. The logged in entity that performs **actions** is called **Actor**; the **other** entity whose profile is brought into focus is called **Another**. It's that simple.


  ```Bash
    pip install blue-yonder
  ```
  Note: the pip package name has a dash `-` between the words.

  Then:
  ```Python


  from blue_yonder import Actor, Another
  ```


  The Bluesky network creators were so busy with their own perception of their enterprise as 'an implementation of a protocol' that they didn't separate in their code and documentation the different logical levels of participation of entities in the network. In this package I tried to set apart the 'active participation' which consists of the actions (posts, uploads, likes, follows, blocks, mutes, etc.) by a (_logged in_) **Actor**... sorry for the reiteration of the 'act' root bounding with tautology... from the 'passive observation' of **Another** entity, its profile, posts, likes, followers, lists, feeds, etc. that can be done by a _not logged into the Bluesky and, hence, 'anonymous'_ computer with Internet connection. Besides that, on a yet another level, there are pure functions of the network/environment too - the search functions and other utilities of the environment, which I stored in the **yonder** module, where you can import them from as a whole or individually. The package is a work in progress and will keep changing without notice.


  I didn't want to overload this repository and library, you can use the 'template repository' with multiple examples, that I considered to be useful for myself when I was studying the Bluesky API. It is located [here](https://github.com/alxfed/butterfly). Just click the 'Use this template' button at the top of that page and create your own repository in your (or your organization) account that you can edit and use the way you deem fit. I will keep working on it too, so you can be sure that it will be updated as I make changes.


pkgId: 0639dcb99aff3841ac539bd429f0ec1fec64858baa97fad224422737d7cf446a
name: python-blueapi-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for blueapi
url: https://pypi.org/project/blueapi/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blueapi-0.6.1-1.src.rpm
location_href: Packages/python-blueapi-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/DiamondLightSource/blueapi/main/docs/images/blueapi-logo.svg"
       style="background: none" width="120px" height="120px" align="right">

  [![CI](https://github.com/DiamondLightSource/blueapi/actions/workflows/ci.yml/badge.svg)](https://github.com/DiamondLightSource/blueapi/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/DiamondLightSource/blueapi/branch/main/graph/badge.svg)](https://codecov.io/gh/DiamondLightSource/blueapi)
  [![PyPI](https://img.shields.io/pypi/v/blueapi.svg)](https://pypi.org/project/blueapi)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)



  Lightweight bluesky-as-a-service wrapper application. Also usable as a library.

  Source          | <https://github.com/DiamondLightSource/blueapi>
  :---:           | :---:
  PyPI            | `pip install blueapi`
  Docker          | `docker run ghcr.io/diamondlightsource/blueapi:latest`
  Documentation   | <https://diamondlightsource.github.io/blueapi>
  Releases        | <https://github.com/DiamondLightSource/blueapi/releases>

  This module wraps [bluesky](https://blueskyproject.io/bluesky) plans and devices
  inside a server and exposes endpoints to send commands/receive data. Useful for
  installation at labs where multiple people may control equipment, possibly from
  remote locations.

  ![concept][]

  The main premise of blueapi is to minimize the boilerplate required to get plans
  and devices up and running by generating an API for your lab out of
  type-annotated plans. For example, take the following plan:

  ```python
      import bluesky.plans as bp
      from blueapi.core import MsgGenerator

      def my_plan(foo: str, bar: int) -> MsgGenerator:
          yield from bp.scan(...)
  ```

  Blueapi's job is to detect this plan and automatically add it to the lab's API
  so it can be invoked easily with a few REST calls.

  <!-- README only content. Anything below this line won't be included in index.md -->

  See https://diamondlightsource.github.io/blueapi for more detailed documentation.

  [concept]: https://raw.githubusercontent.com/DiamondLightSource/blueapi/main/docs/images/blueapi.png

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright {yyyy} {name of copyright owner}  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: 4acc35b5c5a6feef182fe92f818a377fa0766f497bdc748836b81209a6aa74a3
name: python-bluecast-help
arch: noarch
version: 1.6.4
epoch: 0
release: 1
summary: Development documents and examples for bluecast
url: https://github.com/ThomasMeissnerDS/BlueCast
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bluecast-1.6.4-1.src.rpm
location_href: Packages/python-bluecast-help-1.6.4-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/ThomasMeissnerDS/BlueCast/branch/main/graph/badge.svg?token=XRIS04O097)](https://codecov.io/gh/ThomasMeissnerDS/BlueCast)
  [![Codecov workflow](https://github.com/ThomasMeissnerDS/BlueCast/actions/workflows/workflow.yaml/badge.svg)](https://github.com/ThomasMeissnerDS/BlueCast/actions/workflows/workflow.yaml)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![pydocstyle](https://img.shields.io/badge/pydocstyle-enabled-AD4CD3)](http://www.pydocstyle.org/en/stable/)
  [![Documentation Status](https://readthedocs.org/projects/bluecast/badge/?version=latest)](https://bluecast.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/bluecast.svg)](https://pypi.python.org/pypi/bluecast/)
  [![Optuna](https://img.shields.io/badge/Optuna-integrated-blue)](https://optuna.org)
  [![python](https://img.shields.io/badge/Python-3.9-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
  [![python](https://img.shields.io/badge/Python-3.10-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)

  ![BlueCast](docs/source/bluecast_dragon_logo_5.jpeg)

  A lightweight and fast auto-ml library, that helps data scientists
  tackling real world problems from EDA to model explainability
  and even uncertainty quantification.
  BlueCast focuses on a few model architectures (on default Xgboost
  only) and a few preprocessing options (only what is
  needed for Xgboost). This allows for a much faster development
  cycle and a much more stable codebase while also having as few dependencies
  as possible for the library. Despite being lightweight in its core BlueCast
  offers high customization options for advanced users. Find
  the full documentation [here](https://bluecast.readthedocs.io/en/latest/).

  Here you can see our test coverage in more detail:

  [![Codecov sunburst](https://codecov.io/gh/ThomasMeissnerDS/BlueCast/graphs/sunburst.svg?token=XRIS04O097)](https://codecov.io/gh/ThomasMeissnerDS/BlueCast/graphs/sunburst.svg?token=XRIS04O097)

  <!-- toc -->

  * [Philosophy](#philosophy)
  * [What BlueCast has to offer](#what-bluecast-has-to-offer)
    * [Basic usage](#basic-usage)
    * [Convenience features](#convenience-features)
    * [Kaggle competition results and example notebooks](#kaggle-competition-results-and-example-notebooks)
  * [About the code](#about-the-code)
    * [Code quality](#code-quality)
    * [Documentation](#documentation)
    * [How to contribute](#how-to-contribute)
    * [Supports us](#supports-us)
    * [Meta](#meta)

  <!-- tocstop -->



  There are plenty of excellent automl solutions available.
  With BlueCast we don't follow the usual path ("Give me your data, we return the
  best model ensemble out of X algorithms"), but have the real world data
  scientist in mind. Our philosophy can be summarized as such:

  * automl should not be a black box
  * automl shall be a help rather than a replacement
  * automl shall not be a closed system
  * automl should be easy to install
  * explainability over another after comma digit in precision
  * real world value over pure performance

  We support our users with an end-to-end toolkit, allowing fast and rich EDA,
  modelling at highest convenience, explainability, evaluation and even
  uncertainty quantification.





  ```sh
  from bluecast.blueprints.cast import BlueCast

  automl = BlueCast(
          class_problem="binary",
      )

  automl.fit(df_train, target_col="target")
  y_probs, y_classes = automl.predict(df_val)


  y_probs = automl.predict_proba(df_val)
  ```



  Despite being a lightweight library, BlueCast also includes some convenience
  with the following features:

  * rich library of EDA functions to visualize and understand the data
  * plenty of customization options via an open API
  * inbuilt uncertainty quantification framework (conformal prediction)
  * hyperparameter tuning (with lots of customization available)
  * automatic feature type detection and casting
  * automatic DataFrame schema detection: checks if unseen data has new or
    missing columns
  * categorical feature encoding (target encoding or directly in Xgboost)
  * datetime feature encoding
  * automated GPU availability check and usage for Xgboost
    a fit_eval method to fit a model and evaluate it on a validation set
    to mimic production environment reality
  * functions to save and load a trained pipeline
  * shapley values
  * ROC AUC curve & lift chart
  * warnings for potential misconfigurations

  The fit_eval method can be used like this:

  ```sh
  from bluecast.blueprints.cast import BlueCast

  automl = BlueCast(
          class_problem="binary",
      )

  automl.fit_eval(df_train, df_eval, y_eval, target_col="target")
  y_probs, y_classes = automl.predict(df_val)
  ```

  It is important to note that df_train contains the target column while
  df_eval does not. The target column is passed separately as y_eval.



  Even though BlueCast has been designed to be a lightweight
  automl framework, it still offers the possibilities to
  reach very good performance. We tested BlueCast in Kaggle
  competitions to showcase the libraries capabilities
  feature- and performance-wise.

  * ICR top 20% finish with over 6000 participants ([notebook](https://www.kaggle.com/code/thomasmeiner/icr-bluecast-automl-almost-bronze-ranks))
  * An advanced example covering lots of functionalities ([notebook](https://www.kaggle.com/code/thomasmeiner/ps3e23-automl-eda-outlier-detection/notebook))
  * PS3E23: Predict software defects top 12% finish ([notebook](https://www.kaggle.com/code/thomasmeiner/ps3e23-automl-eda-outlier-detection?scriptVersionId=145650820))
  * PS3E25: Predict hardness of steel via regression ([notebook](https://www.kaggle.com/code/thomasmeiner/ps3e25-bluecast-automl?scriptVersionId=153347618))
  * PS4E1: Bank churn top 13% finish ([notebook](https://www.kaggle.com/code/thomasmeiner/ps4e1-eda-feature-engineering-modelling?scriptVersionId=158121062))
  * A comprehensive guide about BlueCast showing many capabilities ([notebook](https://www.kaggle.com/code/thomasmeiner/ps4e3-bluecast-a-comprehensive-overview))
  * BlueCast using a custom Catboost model for quantile regression
  and adding conformal prediction ([notebook](https://www.kaggle.com/code/thomasmeiner/bluecast-has-conformal-prediction))
  * 26th place in the Kaggle 24h "AutoMl" GrandPrix July 2024 blitz competition ([notebook](https://www.kaggle.com/code/thomasmeiner/automl-grand-prix-bluecast-26th-place-solution))

  Please note that some notebooks ran older versions of BlueCast and
  might not be compatible with the most recent version anymore.





  To ensure code quality, we use the following tools:

  * various pre-commit libraries
  * strong type hinting in the code base
  * unit tests using Pytest

  For contributors, it is expected that all pre-commit and unit tests pass.
  For new features it is expected that unit tests are added.



  Documentation is provided via [Read the Docs](https://bluecast.readthedocs.io/en/latest/)
  On GitHub we offer multiple ReadMes to cover all aspects of working
  with BlueCast, covering:

  * [Installation](docs/source/Installation.md)
  * [EDA](docs/source/EDA.md)
  * [Basic usage](docs/source/Basic%20usage.md)
  * [Customize training settings](docs/source/Customize%20training%20settings.md)
  * [Feature engineering](docs/source/Feature%20engineering.md)
  * [Customizing configurations and objects](docs/source/Customizing%20configurations%20and%20objects.md)
  * [Model evaluation](docs/source/Model%20evaluation.md)
  * [Error analysis](docs/source/Error%20analysis.md)
  * [Model explainability (XAI)](docs/source/Model%20explainability%20(XAI).md)
  * [Uncertainty quantification](docs/source/Uncertainty%20quantification.md)
  * [Monitoring](docs/source/Monitoring.md)



  Contributions are welcome. Please follow the following steps:

  * Get in touch with me (i.e. via LinkedIn) if longer contribution is of interest
  * Create a new branch from develop branch
  * Add your feature or fix
  * Add unit tests for new features
  * Run pre-commit checks and unit tests (using Pytest)
  * Adjust the `docs/source/index.md` file
  * Copy paste the content of the `docs/source/index.md` file into the
    `README.md` file
  * Push your changes and create a pull request

  If library or dev dependencies have to be changed, adjust the pyproject.toml.
  For readthedocs it is also requited to update the
  `docs/srtd_requirements.txt` file. Simply run:

  ```sh
  poetry export --with dev -f requirements.txt --output docs/rtd_requirements.txt
  ```

  If readthedocs will be able to create the documentation can be tested via:

  ```sh
  poetry run sphinx-autobuild docs/source docs/build/html
  ```

  This will show a localhost link containing the documentation.



  Being a small open source project we rely on the community. Please
  consider giving us a GitHb star and spread the word. Also your feedback
  will help the project evolving.



  Creator: Thomas Meißner – [LinkedIn](https://www.linkedin.com/in/thomas-mei%C3%9Fner-m-a-3808b346)


pkgId: 19eeaf2036106bef757c63e8c930fa29eb3d73b28518b1b4e9cdf6fd40214ece
name: python-bluemath-tk-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for bluemath-tk
url: https://github.com/GeoOcean/BlueMath_tk
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bluemath-tk-1.0.0-1.src.rpm
location_href: Packages/python-bluemath-tk-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Module collection for custom climate data analysis. The main objective of this Python package is to provide a set of statistical tools tailored for climate data analysis, with a focus on statistical classification and prediction.

  The package also includes a set of utility functions for processing climate data. To facilitate understanding of how to use these modules, simple demonstration scripts and the necessary data have been added to this repository.



  ![Sketch](./docs/sketch_tk.png)

  Link to the different sections:
  - [datamining](./bluemath_tk/datamining/)
  - [waves](./bluemath_tk/waves/)
  - [predictor](./bluemath_tk/predictor/)
  - [TC](./bluemath_tk/tc/)
  - [distributions](./bluemath_tk/distributions/)
  - [wrappers](./bluemath_tk/wrappers/)
  - [risk](./bluemath_tk/risk/)
  - [tide](./bluemath_tk/tide/)



  In this repository, simple demo files showcasing the utilization of the different tools can be found in this [link](./demos). Furthermore, full examples with figures can be found in the [Bluemath - notebooks](./) repository.



  Codes have been developed through a collaborative effort by members of the GeoOcean group at the University of Cantabria. For inquiries, please contact Fernando Méndez at mendezf@unican.es



  This project is licensed under the MIT License. See the [license](LICENSE.txt) file for details



  - UNDER DEVELOPMENT



  - Check whole code in NNs
  - Check climate scale data in SamoaTonga
  - Add logs to datamining classes.
  - Descomentar crontab, que ya funcionan los sh
  - Add ERA5 spectra download.
  - Add docker, sbatch, et options in wrappers!

rpm_license:
  Copyright (c) 2024 GeoOcean group, Universidad de Cantabria  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: 2de31f90c7b3fee0f06f12d0b82dfd55b8e728791a33f34f00a33d80e1feeb9f
name: python-bluepy3-help
arch: noarch
version: 2.16.1
epoch: 0
release: 1
summary: Development documents and examples for bluepy3
url: https://github.com/Mausy5043/bluepy3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bluepy3-2.16.1-1.src.rpm
location_href: Packages/python-bluepy3-help-2.16.1-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/mausy5043/bluepy3)](LICENSE)
  [![PyPI version](https://img.shields.io/pypi/v/bluepy3.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/bluepy3)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/bluepy3?logo=python&logoColor=FFE873)](https://pypi.org/project/bluepy3)
  [![PyPI downloads](https://img.shields.io/pypi/dm/bluepy3.svg)](https://pypistats.org/packages/bluepy3)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/Mausy5043/bluepy3/devel.svg)](https://results.pre-commit.ci/latest/github/Mausy5043/bluepy3/devel)



  This is a Python3 library to allow communication with Bluetooth Low Energy devices on Linux.



  Please be aware that this is not a beginners tool. Some experience with Linux CLI, Python3 and BT/BLE is expected.

  Development of this package is done in Python 3.12. The package is considered forwards compatible at least upto Python 3.12 and probably also beyond. Backwards compatibility is not guaranteed; if it works on Python 3.9 or before consider yourself lucky. [Python versions that are end-of-life](https://devguide.python.org/versions/) are not supported.

  The package has been extensively tested on a Raspberry Pi 3 Model B+ (aarch64) with Debian GNU Linux 11 w/ Python 3.9.* AND with Debian GNU Linux 12 /w Python 3.11.* and 3.12.*.

  The code needs an executable `bluepy3-helper` which is compiled from C source automatically
  when first used (see below).

  The `bluepy3` package comes installed with lists of compatible UUIDs in `uuids.json`.
  If, for whatever reason, you want to rebuild those lists, then the Python3 modules
  `bs4`, `requests` and `lxml` need to be installed.
  ```(python3)
  python3 -m pip install bs4 lxml requests
  ```
  Then find where the bluepy3 package is installed and rebuild `uuids.json` thus:
  ```(bash)
  cd some_path_name/site-packages/bluepy3/
  make uuids.json
  ```



  To install the currently released version, on most Debian-based systems:
  ```(bash)
  sudo apt-get install libglib2.0-dev libbluetooth-dev
  python3 -m pip install --upgrade bluepy3
  ```
  Then test the installation using:
  ```(bash)
  sudo setcap cap_net_raw,cap_net_admin+ep $(find . -name bluepy3-helper)
  blescan -n
  sudo hcitool lescan
  ```
  This should list the (compatible) Bluetooth devices in range.

  Upon the first `import` of `bluepy3.btle` the required binary is compiled. This requires the download of the BlueZ source (20MB) to `/tmp` (don't worry this is done automatically). The default behaviour is to compile against the version of the BlueZ source that matches the version of the installed `bluetoothctl`. The user may override this by forcing compilation against any of the supported source trees by running `helpermaker --build <version>`. You are advised NOT to use `make` directly, but rather use the python script `helpermaker`.

  It may be considered to have command-line tools from BlueZ available for debugging.



  Make sure the user is part of the `bluetooth` group.
  Use `hciconfig` to confirm that the device actually exists. This should output something like:
  ```
  hci0:    Type: Primary  Bus: UART
  BD Address: B8:27:EB:90:4F:F5  ACL MTU: 1021:8  SCO MTU: 64:1
  UP RUNNING
  RX bytes:15332515 acl:452626 sco:0 events:333729 errors:0
  TX bytes:7376962 acl:438075 sco:0 commands:72113 errors:0
  ```
  Use `hciconfig [hci0] up` to activate the BT device if the above returns an error.



  For documentation you are referred to [the documentation that comes with `bluepy`](http://ianharvey.github.io/bluepy-doc/). Be warned though that as development of `bluepy3` advances some of the documentation may be off a bit.



  Your assistance to improve this package is greatly appreciated.
  See [CONTRIBUTING](CONTRIBUTING.md) for details.


  As of September 2024 `bluepy3` is distributed under [AGPL-3.0-or-later](LICENSE).



  This work builds on previous work by [Ian Harvey](https://github.com/IanHarvey/bluepy) and uses code
  by the [BlueZ project](http://www.bluez.org/) and the GitHub repository [BlueZ on GitHub](https://github.com/bluez/bluez)


pkgId: 68023736b9e659f237d8f40937d2f03c623d3d17553b67f9edf6185cf5bb95ab
name: python-bluesky-2-album-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for bluesky-2-album
url: https://github.com/gaoyunzhi/bluesky_2_album
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bluesky-2-album-0.0.1-1.src.rpm
location_href: Packages/python-bluesky-2-album-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Return photo list and caption (markdown format) from bluesky.



  ```
  import bluesky_2_album
  result = bluesky_2_album.get(url)
  result.imgs
  result.cap
  ```



  `pip3 install bluesky_2_album`


pkgId: ae412f42ee7a41dbb506a2632d81202e3b824c985f10270aaf5701a88b453cd4
name: python-bluesky-nats-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for bluesky-nats
url: https://pypi.org/project/bluesky-nats/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bluesky-nats-0.1.3-1.src.rpm
location_href: Packages/python-bluesky-nats-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  This module allows to:

  * publish Bluesky documents to a NATS JetStream
  * consume a NATS JetStream



  Install from pypi
  ```bash
  uv add bluesky-nats
  ```

  Install with dependecies to run the `examples`
  ```bash
  uv add bluesky-nats --extra examples
  ```



  The module requires a NATS JetStream-enabled server.
  If not explicitly specified, the Publisher will automatically publish to the NATS JetStream "bluesky".
  Make sure that the respective JetStream is available on the server and that your "subject" pattern matches the configuration.

  A simple Docker setup for local development and testing is provided in the [docker](https://github.com/Canadian-Light-Source/bluesky-nats/tree/main/docker) directory, with a [Readme](https://github.com/Canadian-Light-Source/bluesky-nats/tree/main/docker/Readme.adoc) for guidance.



  This is the most basic example to create a NATS publisher subscribed to RE documents.
  ```python
  from bluesky.run_engine import RunEngine

  from bluesky_nats.nats_client import NATSClientConfig
  from bluesky_nats.nats_publisher import CoroutineExecutor, NATSPublisher

  if __name__ == "__main__":
      RE = RunEngine({})
      config = NATSClientConfig()

      nats_publisher = NATSPublisher(
          client_config=config,
          executor=CoroutineExecutor(RE.loop),
          subject_factory="events.nats-bluesky",
      )

      RE.subscribe(nats_publisher)
  ```

  Follow the [instructions](https://github.com/Canadian-Light-Source/bluesky-nats/tree/main/examples) for more information about the examples.

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


pkgId: bcde50320cacdcbb24ebd314f2c7607f54fb8df2d6b3b9b1bd7f8d2e47d3ee1a
name: python-bluesky-notify-help
arch: noarch
version: 0.4.4
epoch: 0
release: 1
summary: Development documents and examples for bluesky-notify
url: https://github.com/jerdog/bluesky-notify
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bluesky-notify-0.4.4-1.src.rpm
location_href: Packages/python-bluesky-notify-help-0.4.4-1.noarch.rpm
checksum_type: sha256
description:
  A cross-platform desktop notification system for Bluesky. Monitor and receive notifications from your favorite Bluesky accounts.

  [![Version](https://img.shields.io/badge/version-0.4.2-blue.svg)](https://github.com/jerdog/bluesky-notify)
  [![Python](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
  [![Flask](https://img.shields.io/badge/Flask-3.1.0-blue)](https://pypi.org/project/Flask/)
  [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

  https://pypi.org/project/bluesky-notify/



  - Monitor multiple Bluesky accounts for new posts
  - Real-time browser notifications in Docker environment
  - Desktop notifications support across platforms (macOS, Linux, Windows)
  - Daemon mode for continuous monitoring
  - Web interface for easy account management
  - Email notifications support (requires Mailgun configuration)
  - XDG-compliant configuration storage
  - SQLite database for reliable post tracking
  - Cross-platform compatibility
  - Consistent CLI interface with clear version and configuration information
  - Comprehensive logging system with rotation and separate error logs
  - WebSocket support for real-time updates in Docker environment



  - From local / repo download
  ```bash
  pip install bluesky-notify
  ```

  - From PyPi
  ```bash

  To verify the installation:
  ```bash
  bluesky-notify --version
  ```

  Example output:
  ```
  Bluesky Notify v0.4.1
  Config: /Users/username/.local/share/bluesky-notify

  A cross-platform desktop notification system for Bluesky. Monitor and receive notifications from your favorite Bluesky accounts.

  Usage: bluesky-notify [OPTIONS] COMMAND [ARGS]...

  Run 'bluesky-notify start --daemon' to install and run as a system service.

  Options:
    --version     Show version and exit
    --help        Show this message and exit

  Commands:
    add          Add a Bluesky account to monitor.
    list         List all monitored Bluesky accounts and their notification...
    remove       Remove a Bluesky account from monitoring.
    settings     View or update application settings.
    start        Start the notification service.
    status       View the current status of the service.
    stop         Stop the notification service.
    toggle       Toggle monitoring status for a Bluesky account.
    update       Update notification preferences for a monitored account.
  ```



  The application uses the XDG Base Directory Specification for storing its data:

  - Configuration: `~/.config/bluesky-notify/`
  - Data: `~/.local/share/bluesky-notify/`
  - Cache: `~/.cache/bluesky-notify/`
  - Logs:
    - macOS: `~/Library/Logs/bluesky-notify/`
    - Linux: `~/.local/share/bluesky-notify/logs/`



  The web interface runs on port 3000 by default. On macOS, port 5000 is avoided as it's reserved for AirPlay. You can change the port using:

  ```bash
  bluesky-notify settings --port NUMBER
  ```



  To enable email notifications, set the following environment variables:

  ```bash
  export MAILGUN_API_KEY='your-api-key'
  export MAILGUN_DOMAIN='your-domain'
  export MAILGUN_FROM_EMAIL='notifications@yourdomain.com'
  export MAILGUN_TO_EMAIL='your-email@example.com'
  ```





  Start the service with debug logging:
  ```bash
  bluesky-notify start --log-level DEBUG
  ```

  Start as a system service:
  ```bash
  bluesky-notify start --daemon
  ```



  To see all available commands and options:
  ```bash
  bluesky-notify --help
  ```



  ```bash
  bluesky-notify add username.bsky.social
  ```

  Note: The handle should be provided without the '@' symbol.

  Options:
  - `--desktop/--no-desktop`: Enable/disable desktop notifications (default: enabled)
  - `--email/--no-email`: Enable/disable email notifications (default: disabled)



  ```bash
  bluesky-notify list
  ```



  Toggle monitoring for an account:
  ```bash
  bluesky-notify toggle username.bsky.social
  ```

  Remove an account:
  ```bash
  bluesky-notify remove username.bsky.social
  ```

  Update notification preferences:
  ```bash
  bluesky-notify update username.bsky.social --desktop/--no-desktop --email/--no-email
  ```



  When running in Docker, the application supports browser notifications through WebSocket connections. The web interface will automatically detect the Docker environment and enable real-time notifications.



  - `DOCKER_CONTAINER`: Set to 'true' to enable Docker-specific features
  - `PORT`: Override the default port (default: 5001 in Docker)



  The application uses a comprehensive logging system:

  - Log files are stored in platform-specific locations:
    - macOS: `~/Library/Logs/bluesky-notify/`
    - Linux: `~/.local/share/bluesky-notify/logs/`

  - Two log files are maintained:
    - `bluesky-notify.log`: General application logs (INFO level and above)
    - `bluesky-notify.error.log`: Error logs only (ERROR level)

  - Log rotation is enabled:
    - Maximum file size: 1MB
    - Keeps up to 5 backup files
    - Rotated files are named with numerical suffixes (e.g., bluesky-notify.log.1)

  - Debug logging can be enabled with:
    ```bash
    bluesky-notify start --log-level DEBUG
    ```





  - Python 3.9 or higher
  - Dependencies listed in pyproject.toml



  1. Clone the repository:
  ```bash
  git clone https://github.com/jerdog/bluesky-notify.git
  cd bluesky-notify
  ```

  2. Install development dependencies:
  ```bash
  pip install -e ".[dev]"
  ```

  3. Run tests:
  ```bash
  pytest
  ```



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



  Contributions are welcome! Please feel free to submit a Pull Request.



  If you encounter any issues or have questions, please file an issue on the GitHub repository.



  - 0.4.2: Enhance monitoring + logging
  - 0.4.1: Validate Docker container image builds correctly, make CLI co-exist
  - 0.4.0: Add web interface to daemon + terminal mode
  - 0.3.0: Add daemon mode, web interface, and improved CLI help text
  - 0.2.7: Fixed CLI output formatting and help text organization
  - 0.2.6: Enhanced CLI interface with consistent version and config display
  - 0.2.5: Improved help text formatting and command output
  - 0.2.4: Added version and config information to all commands
  - 0.2.3: Refined CLI presentation and version display
  - 0.2.0: Initial public release



  1. **Version Check**
     - Run `bluesky-notify --version` to verify the installed version
     - Make sure you have the latest version installed

  2. **No Notifications**
     - Check if desktop notifications are enabled in your system
     - Verify the notification service is running
     - Check logs in `~/.local/share/bluesky-notify/logs/`

  3. **API Errors**
     - Verify Bluesky handles are entered correctly (without '@' symbol)
     - Check your internet connection
     - Ensure the Bluesky API is accessible


pkgId: 92c2f80594e8830c98a31202967150b070c4443c578b305f3c827a4599688425
name: python-blueutils-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for blueutils
url: https://github.com/ox-blueblue/blueutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blueutils-0.0.5-1.src.rpm
location_href: Packages/python-blueutils-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  这是一个python 的 工具集


  ```
  $ pip install blueutils
  ```


  比特浏览器官方虽然提供了api文档，但是没法直接拿来用，所以我对官方api文档进行封装了下，使用起来更简单了，使用方法如下：


  ```python
  from blueutils.bitbrowser_api import BitBrowser

  b = BitBrowser(id="你的浏览器id")
  b.open()
  context = b.get_browser_context()
  print(context)
  b.close()
  ```


  针对程序配置，提供一个ini配置文件，方便动态配置程序，使用方法如下：

  from blueutils.config_manager import ConfigManager

  config_manager = ConfigManager('config.ini')
  config_manager.set('log', 'level', 'DEBUG')  # 设置默认值
  config_manager.save()
  DOCKER_HOST = config_manager.get('log', 'level')  # 获取配置信息


  可发送消息到飞书，方便监控程序运行状态，使用方法如下：
  需要提前在飞书申请好通知密钥（完全免费），步骤为：
  创建群组>>设置>>群机器人>>添加机器人>>自定义机器人>>添加>>保存Webhook 地址>>勾选签名校验>>保存签名>>完成
  REPORT_URL 设置为Webhook 地址
  REPORT_KEY 设置为签名

  from blueutils.feishu_robot import FeishuRobot

  feishu = FeishuRobot(webhook=REPORT_URL, secret=REPORT_KEY)
  feishu.send_text(text="飞书通知")


pkgId: afad77665e6bb31fd5e55cdef3649f3223622b0b72a159d69a50c6a7d0f4a484
name: python-bluish-help
arch: noarch
version: 0.9.6
epoch: 0
release: 1
summary: Development documents and examples for bluish
url: https://github.com/luismedel/bluish
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bluish-0.9.6-1.src.rpm
location_href: Packages/python-bluish-help-0.9.6-1.noarch.rpm
checksum_type: sha256
description:
  [![justforfunnoreally.dev badge](https://img.shields.io/badge/justforfunnoreally-dev-9ff)](https://justforfunnoreally.dev)


  Bluish automates software development and deployment tasks, similar to GitHub Actions, but for local execution or within Docker. It allows you to define, organize, and execute workflows in your own environment without relying on external services.



  - **Command-Line Interface**: Bluish offers a `make`-like experience via the `blu` command for easy task execution (e.g., `blu build`).
  - **Local and Remote Automation**: Execute tasks locally, without needing cloud services, or remotely via SSH.
  - **Docker Integration**: Run workflows in Docker containers for a controlled environment.
  - **Simple Configuration**: Define workflows in YAML files, following a familiar structure for defining steps.
  - **CI/CD Integration**: Integrate with GitHub Actions, GitLab CI/CD, and other CI/CD tools for unified local and remote workflows.



  Use `pipx` (or `pip`!):

  ```bash
  pipx install bluish
  ```



  Refer to the project [wiki](https://github.com/luismedel/bluish/wiki) for more detailed documentation. Please note that the documentation is still in progress and may be incomplete or not fully reliable.

  Define workflows in a YAML file (`bluish.yml`). Each workflow contains steps executed in sequence. Example:

  ```yaml
  name: My Local Workflow

  steps:
    - name: Clone repository
      uses: git/checkout
      with:
        repository: https://github.com/myuser/myproject.git

    - name: Build Docker image
      run: docker build -t myproject .

    - name: Run tests
      run: docker run --rm myproject pytest

    - name: Cleanup
      run: docker rmi myproject
  ```

  To run a workflow:

  ```bash
  blu <workflow>
  ```

  The command looks for `bluish.yml` in the current or `.bluish/` directory.



  - **Local CI**: Build and test your project without a cloud CI platform.
  - **Reproducible Environments**: Run code in Docker containers for consistency.
  - **Task Automation**: Automate repetitive development tasks.



  | Feature               | GitHub Actions                | Bluish                                         |
  | --------------------- | ----------------------------- | ---------------------------------------------- |
  | Execution Environment | Cloud                         | Local / Remote / Docker Containers             |
  | Privacy               | Data hosted on GitHub servers | No data exposure, or exposure that is tightly controlled                               |
  | Flexibility           | Tied to GitHub's CI/CD model  | Agnostic, adaptable to different CI/CD systems |
  | Internet Requirement  | Yes                           | No                                             |

  Bluish is ideal for:

  - **Privacy**: No data exposed to third-party platforms.
  - **Control**: Define and modify environments without external limitations.
  - **Offline Development**: Use workflows without internet.
  - **Unified Workflows**: Consistent local and CI/CD workflows.



  [nektos/act](https://github.com/nektos/act) runs GitHub Actions locally but is tied to GitHub's syntax. Bluish offers more flexibility and is not restricted by GitHub-specific rules, making it more versatile across different CI/CD systems.



  Contributions are welcome! Open an issue or send a pull request. See the [contribution guidelines](https://github.com/luismedel/bluish/blob/main/CONTRIBUTING.md) for more details.



  Licensed under the MIT License. See the `LICENSE` file for details.



  For questions or suggestions, open an issue in the repository or contact me on GitHub: [luismedel](https://github.com/luismedel).


pkgId: 8b8525c9816d95b3a94a7cb18e3e9f64862c0d1cb7482668567d8940078d02ee
name: python-blurry-cli-help
arch: noarch
version: 0.13.0
epoch: 0
release: 1
summary: Development documents and examples for blurry-cli
url: https://github.com/blurry-dev/blurry
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-blurry-cli-0.13.0-1.src.rpm
location_href: Packages/python-blurry-cli-help-0.13.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Nox build status](https://github.com/blurry-dev/blurry/actions/workflows/github-actions-nox.yml/badge.svg?branch=main)](https://github.com/blurry-dev/blurry/actions/workflows/github-actions-nox.yml)
  [![PyPI package version](https://img.shields.io/pypi/v/blurry-cli.svg)](https://pypi.org/project/blurry-cli/)
  [![PyPI Python versions](https://img.shields.io/pypi/pyversions/blurry-cli.svg)](https://pypi.org/project/blurry-cli/)
  ![Package license](https://img.shields.io/github/license/blurry-dev/blurry.svg)

  ![Blurry logo](docs/content/favicon.png)



  Blurry is a schema-first, plugin-enabled static site generator.
  Markdown front matter directly to [Schema.org types](https://schema.org/docs/full.html), so your content is SEO-friendly and [rich results-ready](https://developers.google.com/search/docs/appearance/structured-data/search-gallery) out of the box.

  Blurry also makes your images responsive, supports embedding Python source code in Markdown files, and more.

  Check out the docs and try it out!



  View the documentation site at <https://blurry-docs.netlify.app/>.



  Contributions are welcome!
  Check out [the contribution docs](https://github.com/blurry-dev/blurry/blob/main/CONTRIBUTING.md) to get started.



  Blurry blends together high-quality libraries:

  - [Mistune](https://mistune.readthedocs.io/) to convert Markdown to HTML
  - [Jinja](https://jinja.palletsprojects.com/) for HTML templating
  - [JinjaX](https://jinjax.scaletti.dev/) for Jinja components
  - [LiveReload](https://livereload.readthedocs.io/) for an HTTP server with automatic browser reloading
  - [Typer](https://typer.tiangolo.com/) for its CLI interface
  - [ImageMagick](https://imagemagick.org/index.php) to resize and convert images

  &copy; 2020-present, John Franey


pkgId: 00deb995b6177ed969687b43be713e06a0e23f0c4d713422ec76822fed3a7fee
name: python-bma-cli-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for bma-cli
url: https://pypi.org/project/bma-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bma-cli-0.8.0-1.src.rpm
location_href: Packages/python-bma-cli-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  [![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)
  [![PyPI version](https://badge.fury.io/py/bma-cli.svg)](https://pypi.org/project/bma-cli/)



  BMA CLI client written in Python

  Based on https://github.com/bornhack/bma-client-lib-python


pkgId: a26c36b0c9be4555cb140e5794e865dee505c69f4b4da186078405974945f3ae
name: python-bma-client-lib-help
arch: noarch
version: 0.10.0
epoch: 0
release: 1
summary: Development documents and examples for bma-client-lib
url: https://pypi.org/project/bma-client-lib/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bma-client-lib-0.10.0-1.src.rpm
location_href: Packages/python-bma-client-lib-help-0.10.0-1.noarch.rpm
checksum_type: sha256
description:
  [![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)
  [![PyPI version](https://badge.fury.io/py/bma-client-lib.svg)](https://pypi.org/project/bma-client-lib/)



  BMA client Python library

  Used by https://github.com/bornhack/bma-cli-python


pkgId: 5bf4fb92819d0ed89d442d2c8b2de8731675120738cba2d6cb168281ff01ad45
name: python-bmtool-help
arch: noarch
version: 0.6.2
epoch: 0
release: 1
summary: Development documents and examples for bmtool
url: https://github.com/cyneuro/bmtool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bmtool-0.6.2-1.src.rpm
location_href: Packages/python-bmtool-help-0.6.2-1.noarch.rpm
checksum_type: sha256
description:
  A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/neuron/) and [BMTK](https://alleninstitute.github.io/bmtk/) models easier.

  [![license](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](https://github.com/cyneuro/bmtool/blob/master/LICENSE)


  - [Getting Started](#getting-started)
  - [CLI](#cli)
  - [Single Cell](#single-cell-module)
  - [Synapses](#synapses-module)
  - [Connectors](#connectors-module)
  - [Bmplot](#bmplot-module)
  - [Graphs](#graphs-module)



  **Installation**
  ```bash
  pip install bmtool
  ```
  For developers who will be pulling down additional updates to this repository regularly use the following instead.
  ```bash
  git clone https://github.com/cyneuro/bmtool.git
  cd bmtool
  python setup.py develop
  ```
  Then download updates (from this directory) with
  ```bash
  git pull
  ```



  ```bash
  > cd your_bmtk_model_directory
  > bmtool
  Usage: bmtool [OPTIONS] COMMAND [ARGS]...

  Options:
    --verbose  Verbose printing
    --help     Show this message and exit.

  Commands:
    debug
    plot
    util

  >
  > bmtool plot
  Usage: bmtool plot [OPTIONS] COMMAND [ARGS]...

  Options:
    --config PATH  Configuration file to use, default: "simulation_config.json"
    --no-display   When set there will be no plot displayed, useful for saving
                   plots
    --help         Show this message and exit.

  Commands:
    connection  Display information related to neuron connections
    positions   Plot cell positions for a given set of populations
    raster      Plot the spike raster for a given population
    report      Plot the specified report using BMTK's default report plotter
  >
  ```


  - [Passive properties](#passive-properties)
  - [Current injection](#current-clamp)
  - [FI curve](#fi-curve)
  - [ZAP](#zap)
  - [Tuner](#single-cell-tuning)
  - [VHalf Segregation](#vhalf-segregation-module)





  ```python
  from bmtool.singlecell import Profiler
  profiler = Profiler(template_dir='templates', mechanism_dir = 'mechanisms', dt=0.1)
  ```




  ```python
  from bmtool.singlecell import load_allen_database_cells
  cell = load_allen_database_cells(path_to_SWC_file,path_to_json_file)
  ```





  ```python
  from bmtool.singlecell import Passive,run_and_plot
  import matplotlib.pyplot as plt
  sim = Passive('Cell_Cf', inj_amp=-100., inj_delay=1500., inj_dur=1000., tstop=2500., method='exp2')
  title = 'Passive Cell Current Injection'
  xlabel = 'Time (ms)'
  ylabel = 'Membrane Potential (mV)'
  X, Y = run_and_plot(sim, title, xlabel, ylabel, plot_injection_only=True)
  plt.gca().plot(*sim.double_exponential_fit(), 'r:', label='double exponential fit')
  plt.legend()
  plt.show()
  ```

      Injection location: Cell_Cf[0].soma[0](0.5)
      Recording: Cell_Cf[0].soma[0](0.5)._ref_v
      Running simulation for passive properties...

      V Rest: -70.21 (mV)
      Resistance: 128.67 (MOhms)
      Membrane time constant: 55.29 (ms)

      V_rest Calculation: Voltage taken at time 1500.0 (ms) is
      -70.21 (mV)

      R_in Calculation: dV/dI = (v_final-v_rest)/(i_final-i_start)
      (-83.08 - (-70.21)) / (-0.1 - 0)
      12.87 (mV) / 0.1 (nA) = 128.67 (MOhms)

      Tau Calculation: Fit a double exponential curve to the membrane potential response
      f(t) = a0 + a1*exp(-t/tau1) + a2*exp(-t/tau2)
      Constained by initial value: f(0) = a0 + a1 + a2 = v_rest
      Fit parameters: (a0, a1, a2, tau1, tau2) = (-83.06, -3306.48, 3319.33, 55.29, 55.15)
      Membrane time constant is determined from the slowest exponential term: 55.29 (ms)

      Sag potential: v_sag = v_peak - v_final = -0.66 (mV)
      Normalized sag potential: v_sag / (v_peak - v_rest) = 0.049





  ![png](readme_figures/output_8_1.png)







  ```python
  from bmtool.singlecell import CurrentClamp
  sim = CurrentClamp('Cell_Cf', inj_amp=350., inj_delay=1500., inj_dur=1000., tstop=3000., threshold=-15.)
  X, Y = run_and_plot(sim, title='Current Injection', xlabel='Time (ms)',
                      ylabel='Membrane Potential (mV)', plot_injection_only=True)
  plt.show()
  ```

      Injection location: Cell_Cf[1].soma[0](0.5)
      Recording: Cell_Cf[1].soma[0](0.5)._ref_v
      Current clamp simulation running...

      Number of spikes: 19





  ![png](readme_figures/output_10_1.png)







  ```python
  from bmtool.singlecell import FI
  sim = FI('Cell_Cf', i_start=0., i_stop=1000., i_increment=50., tstart=1500.,threshold=-15.)
  X, Y = run_and_plot(sim, title='FI Curve', xlabel='Injection (nA)', ylabel='# Spikes')
  plt.show()
  ```

      Injection location: Cell_Cf[21].soma[0](0.5)
      Recording: Cell_Cf[21].soma[0](0.5)._ref_v
      Running simulations for FI curve...

      Results
      Injection (nA): 0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95
      Number of spikes: 0, 1, 10, 12, 15, 16, 17, 19, 20, 20, 21, 21, 22, 23, 23, 24, 25, 25, 26, 27





  ![png](readme_figures/output_12_1.png)







  ```python
  from bmtool.singlecell import ZAP
  sim = ZAP('Cell_Cf')
  X, Y = run_and_plot(sim)
  plt.show()
  ```

      Injection location: Cell_Cf[22].soma[0](0.5)
      Recording: Cell_Cf[22].soma[0](0.5)._ref_v
      ZAP current simulation running...

      Chirp current injection with frequency changing from 0 to 15 Hz over 15 seconds
      Impedance is calculated as the ratio of FFT amplitude of membrane voltage to FFT amplitude of chirp current





  ![png](readme_figures/output_14_1.png)






  ```bash
  bmtool util cell tune --builder
  ```


  ```bash
  bmtool util cell --template TemplateFile.hoc --mod-folder ./ tune --builder
  ```
  ![bmtool](./figures/figure2.png "Tuning Figure")








  ```bash
  > bmtool util cell vhseg --help

  Usage: bmtool util cell vhseg [OPTIONS]

    Alturki et al. (2016) V1/2 Automated Segregation Interface, simplify
    tuning by separating channel activation

  Options:
    --title TEXT
    --tstop INTEGER
    --outhoc TEXT         Specify the file you want the modified cell template
                          written to
    --outfolder TEXT      Specify the directory you want the modified cell
                          template and mod files written to (default: _seg)
    --outappend           Append out instead of overwriting (default: False)
    --debug               Print all debug statements
    --fminpa INTEGER      Starting FI Curve amps (default: 0)
    --fmaxpa INTEGER      Ending FI Curve amps (default: 1000)
    --fincrement INTEGER  Increment the FI Curve amps by supplied pA (default:
                          100)
    --infvars TEXT        Specify the inf variables to plot, skips the wizard.
                          (Comma separated, eg: inf_mech,minf_mech2,ninf_mech2)
    --segvars TEXT        Specify the segregation variables to globally set,
                          skips the wizard. (Comma separated, eg:
                          mseg_mech,nseg_mech2)
    --eleak TEXT          Specify the eleak var manually
    --gleak TEXT          Specify the gleak var manually
    --othersec TEXT       Specify other sections that a window should be
                          generated for (Comma separated, eg: dend[0],dend[1])
    --help                Show this message and exit.

  ```





  ```bash
  > bmtool util cell vhseg

  ? Select a cell:  CA3PyramidalCell
  Using section dend[0]
  ? Show other sections? (default: No)  Yes
  ? Select other sections (space bar to select):  done (2 selections)
  ? Select inf variables to plot (space bar to select):   done (5 selections)
  ? Select segregation variables [OR VARIABLES YOU WANT TO CHANGE ON ALL SEGMENTS at the same time] (space bar to select):  done (2 selections)
  ```



  ```bash
  bmtool util cell --template CA3PyramidalCell vhseg --othersec dend[0],dend[1] --infvars inf_im --segvars gbar_im --gleak gl_ichan2CA3 --eleak el_ichan2CA3
  ```

  Example:

  ![bmtool](./figures/figure4.png "Seg Figure")


  ``` bash
  bmtool util cell --hoc cell_template.hoc vhsegbuild --build
  bmtool util cell --hoc segmented_template.hoc vhsegbuild
  ```
  ex: [https://github.com/tjbanks/two-cell-hco](https://github.com/tjbanks/two-cell-hco)


  -[SynapticTuner](#synaptictuner)





  - [UnidirectionConnector](#unidirectional-connector---unidirectional-connections-in-bmtk-network-model-with-given-probability-within-a-single-population-or-between-two-populations)
  - [ReciprocalConnector](#recipical-connector---buiilding-connections-in-bmtk-network-model-with-reciprocal-probability-within-a-single-population-or-between-two-populations)
  - [CorrelatedGapJunction](#correlatedgapjunction)
  - [OneToOneSequentialConnector](#onetoonesequentialconnector)




  ```python
  from bmtk.builder import NetworkBuilder
  net = NetworkBuilder('example_net')
  net.add_nodes(N=100, pop_name='PopA',model_type = 'biophysical')
  net.add_nodes(N=100, pop_name='PopB',model_type = 'biophysical')

  background = NetworkBuilder('background')
  background.add_nodes(N=300,pop_name='tON',potential='exc',model_type='virtual')
  ```


  ```python
  from bmtool.connectors  import UnidirectionConnector
  connector = UnidirectionConnector(p=0.15, n_syn=1)
  connector.setup_nodes(source=net.nodes(pop_name = 'PopA'), target=net.nodes(pop_name = 'PopB'))
  net.add_edges(**connector.edge_params())
  ```

  ```python
  from bmtool.connectors  import ReciprocalConnector
  connector = ReciprocalConnector(p0=0.15, pr=0.06767705087, n_syn0=1, n_syn1=1,estimate_rho=False)
  connector.setup_nodes(source=net.nodes(pop_name = 'PopA'), target=net.nodes(pop_name = 'PopA'))
  net.add_edges(**connector.edge_params())
  ```

  ```python
  from bmtool.connectors import ReciprocalConnector, CorrelatedGapJunction
  connector = ReciprocalConnector(p0=0.15, pr=0.06, n_syn0=1, n_syn1=1, estimate_rho=False)
  connector.setup_nodes(source=net.nodes(pop_name='PopA'), target=net.nodes(pop_name='PopA'))
  net.add_edges(**connector.edge_params())
  gap_junc = CorrelatedGapJunction(p_non=0.1228,p_uni=0.56,p_rec=1,connector=connector)
  gap_junc.setup_nodes(source=net.nodes(pop_name='PopA'), target=net.nodes(pop_name='PopA'))
  conn = net.add_edges(is_gap_junction=True, syn_weight=0.0000495, target_sections=None,afferent_section_id=0, afferent_section_pos=0.5,
  **gap_junc.edge_params())
  ```


  ```python
  from bmtool.connectors  import OneToOneSequentialConnector
  connector = OneToOneSequentialConnector()
  connector.setup_nodes(source=background.nodes(), target=net.nodes(pop_name = 'PopA'))
  net.add_edges(**connector.edge_params())
  connector.setup_nodes(target=net.nodes(pop_name = 'PopB'))
  net.add_edges(**connector.edge_params())
  ```



  - [total_connection_matrix](#total_connection_matrix)
  - [percent_connection_matrix](#percent_connection_matrix)
  - [connector_percent_matrix](#connector_percent_matrix)
  - [convergence_connection_matrix](#convergence_connection_matrix)
  - [divergence_connection_matrix](#divergence_connection_matrix)
  - [gap_junction_matrix](#gap_junction_matrix)
  - [connection_distance](#connection_distance)
  - [connection_histogram](#connection_histogram)
  - [plot_3d_positions](#plot_3d_positions)
  - [plot_3d_cell_rotation](#plot_3d_cell_rotation)










































  ```python
  bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='pop_name',sids='pop_name',no_prepend_pop=True)
  ```



  ![png](readme_figures/output_35_0.png)





  - [Generate graph](#generate-graph)
  - [Plot Graph](#plot-graph)
  - [Connectioon table](#generate-graph-connection-table)



  ```python
  from bmtool import graphs
  import networkx as nx

  Graph = graphs.generate_graph(config='config.json',source='LA',target='LA')
  print("Number of nodes:", Graph.number_of_nodes())
  print("Number of edges:", Graph.number_of_edges())
  print("Node labels:", set(nx.get_node_attributes(Graph, 'label').values()))
  ```

      Number of nodes: 2000
      Number of edges: 84235
      Node labels: {'SOM', 'PNc', 'PNa', 'PV'}






  ```python
  graphs.plot_graph(Graph)
  ```







  ```python
  import pandas as pd
  graphs.export_node_connections_to_csv(Graph, 'node_connections.csv')
  df = pd.read_csv('node_connections.csv')
  df.head()
  ```




  <div>
  <style scoped>
      .dataframe tbody tr th:only-of-type {
          vertical-align: middle;
      }

      .dataframe tbody tr th {
          vertical-align: top;
      }

      .dataframe thead th {
          text-align: right;
      }
  </style>
  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>Unnamed: 0</th>
        <th>Node Label</th>
        <th>PNc Connections</th>
        <th>PV Connections</th>
        <th>SOM Connections</th>
        <th>PNa Connections</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>0</th>
        <td>0</td>
        <td>PNa</td>
        <td>15</td>
        <td>11</td>
        <td>9</td>
        <td>6</td>
      </tr>
      <tr>
        <th>1</th>
        <td>1</td>
        <td>PNa</td>
        <td>24</td>
        <td>25</td>
        <td>6</td>
        <td>21</td>
      </tr>
      <tr>
        <th>2</th>
        <td>2</td>
        <td>PNa</td>
        <td>27</td>
        <td>28</td>
        <td>12</td>
        <td>25</td>
      </tr>
      <tr>
        <th>3</th>
        <td>3</td>
        <td>PNa</td>
        <td>19</td>
        <td>27</td>
        <td>15</td>
        <td>35</td>
      </tr>
      <tr>
        <th>4</th>
        <td>4</td>
        <td>PNa</td>
        <td>25</td>
        <td>11</td>
        <td>8</td>
        <td>16</td>
      </tr>
    </tbody>
  </table>
  </div>


pkgId: 79cdcc493ed207589c60c3ee17ba4d7e34e024bfa268cf89e315d97ade9121dd
name: python-bmw-lobster-core
arch: noarch
version: 0.9.21
epoch: 0
release: 1
summary: Lightweight Open BMW Software Traceability Evidence Report
url: https://github.com/bmw-software-engineering/lobster
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bmw-lobster-core-0.9.21-1.src.rpm
location_href: Packages/python-bmw-lobster-core-0.9.21-1.noarch.rpm
checksum_type: sha256
description:
  The **L**ightweight **O**pen **B**MW **S**oftware **T**raceability
  **E**vidence **R**eport allows you to demonstrate software traceability
  and requirements coverage, which is essential for meeting standards
  such as ISO 26262.

  This package contains the core LOBSTER tools: the basic API and tools
  for generating reports.



  You can generate a report linking everything together with `lobster-report`.
  The report is in JSON, but you can generate more readable versions of it
  with additional tools:

  * `lobster-online-report`: Preprocess a JSON report to contain github
    references instead of local file references
  * `lobster-html-report`: Generate a HTML report
  * `lobster-ci-report`: Generate a compiler-message like output, useful for CI


  * `lobster-online-report`: This tool needs `git 1.7.8` or higher to support
    git submodules



  The copyright holder of LOBSTER is the Bayerische Motoren Werke
  Aktiengesellschaft (BMW AG), and LOBSTER is published under the [GNU
  Affero General Public License, Version
  3](https://github.com/bmw-software-engineering/lobster/blob/main/LICENSE.md).

  Several LOBSTER tools rely on other tools to process data and extract
  tracing tags. These tools are run-time (but not link or program)
  dependencies. Their copyright and license is as follows:

  The LOBSTER HTML report generator `lobster-html-report` includes some
  of the [Feather Icons](https://feathericons.com) in the report it
  generates. The Feather Icons are licensed under the [MIT
  License](https://github.com/feathericons/feather/blob/master/LICENSE).

  The LOBSTER HTML report generator `lobster-html-report` uses `dot`
  from the [graphviz project](https://graphviz.org/) to produce some of
  the pictures it includes in the report it generates. Graphviz is
  licensed under the [Common Public License, Version
  1.0](https://graphviz.org/license).


pkgId: 1482021b97a9d3e41528e5a3e86a7b653e72f5c6b64408f8632a695dc16b0dc7
name: python-bmw-lobster-tool-codebeamer
arch: noarch
version: 0.9.21
epoch: 0
release: 1
summary: LOBSTER Tool for Codebeamer
url: https://github.com/bmw-software-engineering/lobster
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bmw-lobster-tool-codebeamer-0.9.21-1.src.rpm
location_href: Packages/python-bmw-lobster-tool-codebeamer-0.9.21-1.noarch.rpm
checksum_type: sha256
description:
  The **L**ightweight **O**pen **B**MW **S**oftware **T**raceability
  **E**vidence **R**eport allows you to demonstrate software traceability
  and requirements coverage, which is essential for meeting standards
  such as ISO 26262.

  This package contains a tool to interface with the proprietary
  requirements management tool
  [Codebeamer](https://intland.com/codebeamer).



  * `lobster-codebeamer`: Extract requirements from codebeamer.


  This tool works with an optional config file.
  It allows to configure the following features:


  Codebeamer items can reference other items through
  [Reference Fields](https://support.ptc.com/help/codebeamer/r2.1/en/index.html#page/codebeamer/user_guide/ug_reference_fields.html).
  This piece of information can be extracted by the tool, and serialized into the
  LOBSTER output file.
  It only needs to know which fields to take into account.
  Following the LOBSTER JSON schema, the item references will be added to the
  `refs` property of the LOBSTER item.
  Accordingly, the configuration parameter to specify the codebeamer field names
  is called `refs`, too.
  It can contain a single field name, or a list of field names.
  Field IDs cannot be used, only the field names.

  Examples:
  ```json
  {
    "refs" : "cb-fieldname"
  }
  ```
  or
  ```json
  {
    "refs" : ["cb-fieldname"]
  }
  ```
  or
  ```json
  {
    "refs" : ["cb-fieldname1", "cb-fieldname2"]
  }
  ```


  It is also possible to define the Bearer authentication token in the
  configuration file:
  ```json
  {
    "token" : "your-codebeamer-Bearer-token"
  }
  ```
  Note:
  - The Bearer authentication token can also be provided as a command line
    argument (use `--cb-token=your-codebeamer-Bearer-token`).
  - If the token is provided in the configuration file and as command line
    argument, then the configuration file takes precedence.
  - If `--cb-user` or `--cb-pass` is given together with a Bearer token (either
    as a command line argument or through the configuration file), then the
    Bearer authentication method is used, and the username and/or password are
    ignored.
  - If neither a token nor a username or password are given, then the tool tries
    to read the username and password from the `.netrc` file in the user's home
    directory.


  Here is an example configuration file:
  ```json
  {
    "refs" : ["derived from", "satisfied by"],
    "token" : "SomeTokenStringABC123"
  }
  ```

  Is it also possible to define the codebeamer token in this file:
  ```
  {
  "refs" : "cb-fieldname",
  "token" : "your cb-token"
  }
  ```


  You can also specify the type of schema for the resulting output file. The supported values for the schema field are:
  - Activity: Sets the schema to lobster-act-trace.
  - Implementation: Sets the schema to lobster-imp-trace.
  - Requirement: Sets the schema to lobster-req-trace.

  If the schema is not specified, the tool will default to Requirement, and the schema lobster-req-trace will be used.

  Here is an example configuration file:
  ```json
  {
    "schema": "Activity",  // Specifies schema
    "refs": ["cb-fieldname1", "cb-fieldname2"]  // Specifies references
  }
  ```

  If an invalid schema is provided, the tool will raise an exception. Supported schema values are Activity, Implementation, and Requirement.



  When running the tool, you can specify the `--schema` flag via the command line or set the `schema` value in
  the configuration file. **The configuration file will always take precedence over the command-line argument**.

  - **`--schema`**: The schema to be used (optional, overrides the config file if provided).
  - **Configuration file**: If `schema` is defined in the configuration file, it will be used, and the command-line `--schema` argument will be ignored.



  There are two ways you can use this tool:

  1. Download all requirements mentioned by another lobster trace (this
    way you do not get a completeness check) (using `--import-tagged`)

  2. Download all requirements generated by a saved codebeamer query ID OR a codebeamer query string (cbQL query)
    (using `--import-query` - accepts the query ID as well as query string)

  * Configure the 'refs' upstream reference (this argument is optional)
  (using `--config`)

  * Additionally, you can specify the schema and references:

    1. Specify the schema of trace to be generated (optional, defaults to Requirement)
       using the --schema argument, or configure it in the config file.
    2. Configure the 'refs' upstream reference (optional) using --config or
       specify directly via command line.

      * For example:
      ``` codepython lobster_codebeamer.py --config lobster-codebeamer-config.json --schema "Activity" --references "custom_ref_1```

         This command will extract activity traces (lobster-act-trace) with specified references.



  The key limitation is item text, which is currently not
  imported. However, we do plan to also import item text eventually.



  The copyright holder of LOBSTER is the Bayerische Motoren Werke
  Aktiengesellschaft (BMW AG), and LOBSTER is published under the [GNU
  Affero General Public License, Version
  3](https://github.com/bmw-software-engineering/lobster/blob/main/LICENSE.md).

  This tool has no actual dependency on, or with, Codebeamer. It just
  talks the API as described here: https://codebeamer.com/cb/wiki/117612


pkgId: 624a20d73d7c191f2d9c126a2fd393486046b601d084a3443848cd231b73c076
name: python-bmw-lobster-tool-cpp
arch: noarch
version: 0.9.21
epoch: 0
release: 1
summary: LOBSTER Tool for ISO C/C++
url: https://github.com/bmw-software-engineering/lobster
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bmw-lobster-tool-cpp-0.9.21-1.src.rpm
location_href: Packages/python-bmw-lobster-tool-cpp-0.9.21-1.noarch.rpm
checksum_type: sha256
description:
  The **L**ightweight **O**pen **B**MW **S**oftware **T**raceability
  **E**vidence **R**eport allows you to demonstrate software traceability
  and requirements coverage, which is essential for meeting standards
  such as ISO 26262.

  This package contains a tool extract tracing tags from ISO C or C++
  source code. This tool is making use of a clang-tidy hack, and for
  this to work you need to build [our clang-tidy
  fork](https://github.com/bmw-software-engineering/llvm-project) and
  place the `clang-tidy` binary somewhere on your PATH.

  Instructions for clang-tidy [here](https://github.com/bmw-software-engineering/lobster/blob/main/documentation/user-manual.md#clang-tidy-file-generation).

  This tool works using a custom clang-tidy checker `lobster-trace`
  which emits tracing information as clang checks.

  We plan to rework this tool to be a stand-alone clang tool in the
  future.



  * `lobster-cpp`: Extract requirements from C/C++ code using a
    clang-tidy hack



  This tool supports C/C++ code.

  For this you can embedd tracing tags like this:

  ```cpp

  class Potato {
  public:
      std::string potato() {
          // lobster-trace: something.example
          return "potato";
      }
  };
  ```

  You can add justifications as well:

  ```cpp

  class Potato {
  public:
      std::string potato() {
          // lobster-exclude: Reason to justify the exlude
          return "potato";
      }
  };
  ```



  The copyright holder of LOBSTER is the Bayerische Motoren Werke
  Aktiengesellschaft (BMW AG), and LOBSTER is published under the [GNU
  Affero General Public License, Version
  3](https://github.com/bmw-software-engineering/lobster/blob/main/LICENSE.md).


pkgId: b720097ee88790afc7fbfda729a35ce0545e1701201a95544fa0ef5c88fc99e3
name: python-bmw-lobster-tool-cpptest
arch: noarch
version: 0.9.21
epoch: 0
release: 1
summary: LOBSTER Tool for ISO C/C++
url: https://github.com/bmw-software-engineering/lobster
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bmw-lobster-tool-cpptest-0.9.21-1.src.rpm
location_href: Packages/python-bmw-lobster-tool-cpptest-0.9.21-1.noarch.rpm
checksum_type: sha256
description:
  The **L**ightweight **O**pen **B**MW **S**oftware **T**raceability
  **E**vidence **R**eport allows you to demonstrate software traceability
  and requirements coverage, which is essential for meeting standards
  such as ISO 26262.

  This package contains a tool extract tracing tags from ISO C or C++
  source code. The tracing tags are identified by searching for configurable
  markers in the comments of the source code.



  * `lobster-cpptest`: Extract requirements with specific references
    from tests.



  This tool supports C/C++ code.

  For this you have to provide a C/C++ test documentation with `markers`:

  `Markers` can be either `@requirement`, `@requiredby` or `@defect`.

  ```cpp
  /**
   * @requirement CB-#1111, CB-#2222,
   *              CB-#3333
   * @requirement CB-#4444 CB-#5555
   *              CB-#6666
   */
  TEST(RequirementTagTest1, RequirementsAsMultipleComments) {}
  ```
  You have to provide a config-file which determines which `markers` should be extracted in which output-files.
  The expected `kind` for each output-file should also be specified.

  * Note: If you want to extract the other tests with other `markers`,
   you can use an empty list as `markers` value. Be aware in this case the tests do not have any references.


  ```config
  {
      "markers": [],
      "kind": "req"
  }
  ```

  In addition, you have to provide the codebeamer-url:

  `Kind` can be either `req`, `imp` or `act`.

  ```config
  {
  	"output": {
  		"unit_tests.lobster" :
              {
                  "markers": ["@requirement"],
                  "kind": "req"
              },
          "components_tests.lobster" :
              {
                  "markers": ["@requiredby", "@requirement"],
                  "kind": "imp"
              }
  	},
  	"codebeamer_url": "https://codebeamer.example.com/test"
  }
   ```

  For more information about how to setup cpp and config files take a look at [manual-lobster_cpptest](https://github.com/bmw-software-engineering/lobster/blob/main/../../documentation/manual-lobster_cpptest.md)




  The copyright holder of LOBSTER is the Bayerische Motoren Werke
  Aktiengesellschaft (BMW AG), and LOBSTER is published under the [GNU
  Affero General Public License, Version
  3](https://github.com/bmw-software-engineering/lobster/blob/main/LICENSE.md).


pkgId: 4ad70e32e2ee766ea71f0a623fb429f5b5a5a080a865bd4d0cd9942860c94e5f
name: python-bmw-lobster-tool-gtest
arch: noarch
version: 0.9.21
epoch: 0
release: 1
summary: LOBSTER Tool for GoogleTest
url: https://github.com/bmw-software-engineering/lobster
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bmw-lobster-tool-gtest-0.9.21-1.src.rpm
location_href: Packages/python-bmw-lobster-tool-gtest-0.9.21-1.noarch.rpm
checksum_type: sha256
description:
  The **L**ightweight **O**pen **B**MW **S**oftware **T**raceability
  **E**vidence **R**eport allows you to demonstrate software traceability
  and requirements coverage, which is essential for meeting standards
  such as ISO 26262.

  This package contains a tool and helper header for GoogleTest.



  * `lobster-gtest`: Extract tracing data from GoogleTest XML files

  * [lobster_gtest.h](https://github.com/bmw-software-engineering/lobster/blob/main/../../support/gtest/include/lobster_gtest.h): A
    public domain header with a C/C++ macro to embed tracing tags or
    justifications



  The copyright holder of LOBSTER is the Bayerische Motoren Werke
  Aktiengesellschaft (BMW AG), and LOBSTER is published under the [GNU
  Affero General Public License, Version
  3](https://github.com/bmw-software-engineering/lobster/blob/main/LICENSE.md).

  The `lobster.h` file included here is released to the public domain.


pkgId: 3033049bfecd3466291a9883e9501dcae0d03a6d6fdb09a5acda5f5393fbe53f
name: python-bmw-lobster-tool-json
arch: noarch
version: 0.9.21
epoch: 0
release: 1
summary: LOBSTER Tool for JSON
url: https://github.com/bmw-software-engineering/lobster
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bmw-lobster-tool-json-0.9.21-1.src.rpm
location_href: Packages/python-bmw-lobster-tool-json-0.9.21-1.noarch.rpm
checksum_type: sha256
description:
  The **L**ightweight **O**pen **B**MW **S**oftware **T**raceability
  **E**vidence **R**eport allows you to demonstrate software traceability
  and requirements coverage, which is essential for meeting standards
  such as ISO 26262.

  This package contains a tool extract tracing tags from JSON files. The
  tool expects a json file with a list of objects, for which you can
  specify members to extract by name. It is extremely simplistic but it
  may be good enough to support some use-cases.

  If you have a more complex file format you will likely need to provide
  your own tool for your own files.



  * `lobster-json`: Extract activities from JSON files



  Some projects store their test vectors in JSON files. This tool can be
  used to expose these to LOBSTER. Consider this example:

  ```json
  [
      {"name"        : "XOR Test 1",
       "values"      : [false, false],
       "expectation" : false,
       "tags"        : "example.req_xor"},

      {"name"        : "XOR Test 2",
       "values"      : [false, true],
       "expectation" : true,
       "tags"        : "example.req_xor"},

      {"name"          : "Potato Test 1",
       "values"        : [false, false],
       "expectation"   : true,
       "tags"          : null,
       "justification" : "Unlinked on purpose"}
  ]
  ```

  Here we have a list of three tests. You can configure the
  `lobster-json` tool to extract the relevant information:

  ```bash
  $ lobster-json --name-attribute "name" \
                 --tag-attribute "tags" \
                 --justification-attribute "justification" \
                 FILENAME
  ```

  The name attribute is optional. If your test files do not contain
  names for the tests then a name is synthesised using the filename and
  the index of the test (e.g. foo_1, foo_2, foo_3, etc.).

  The justification attribute is also optional.

  The tag attribute is not, and it needs to be present in each test
  object.

  The specification of these attributes can be nested, for example if
  your test objects instead look like this:

  ```json
  [
      {"meta" : {"name" : "XOR Test 1",
                 "asil" : "B",
                 "req"  : "example.req_xor"},
       "test" : {"inputs" : [false, false],
                 "expect" : false}
      },

      ...
  ```

  Then you can get to the data like so:

  ```bash
  $ lobster-json --name-attribute "meta.name" \
                 --tag-attribute "meta.req" \
                 --justification-attribute "meta.just" \
                 FILENAME
  ```

  Finally, if your list of tests is nested more deeply in an object, you
  can use the `--test-list` flag to identify where it is. For example:

  ```json
  { "kind"    : "tests",
    "vectors" : [
      {"meta" : {"name" : "XOR Test 1",
                 "asil" : "B",
                 "req"  : "example.req_xor"},
       "test" : {"inputs" : [false, false],
                 "expect" : false}
      },

      ...
  ```

  Then you can use `--test-list=vectors` to identify the correct list.

  Note: This tool is pretty limited. For the obvious cases it works
  pretty well, but if you have a more complex test definition in JSON
  then you will need to write your own adaptor [using the documented
  schema](https://github.com/bmw-software-engineering/lobster/blob/main/documentation/schemas.md).



  The copyright holder of LOBSTER is the Bayerische Motoren Werke
  Aktiengesellschaft (BMW AG), and LOBSTER is published under the [GNU
  Affero General Public License, Version
  3](https://github.com/bmw-software-engineering/lobster/blob/main/LICENSE.md).


pkgId: 5e01875836edb3463bfd4e7754691b0c7131e3ea791ffee1e5036b107c6ead7e
name: python-bmw-lobster-tool-python
arch: noarch
version: 0.9.21
epoch: 0
release: 1
summary: LOBSTER Tool for Python3
url: https://github.com/bmw-software-engineering/lobster
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bmw-lobster-tool-python-0.9.21-1.src.rpm
location_href: Packages/python-bmw-lobster-tool-python-0.9.21-1.noarch.rpm
checksum_type: sha256
description:
  The **L**ightweight **O**pen **B**MW **S**oftware **T**raceability
  **E**vidence **R**eport allows you to demonstrate software traceability
  and requirements coverage, which is essential for meeting standards
  such as ISO 26262.

  This package contains a tool to extract tracing tags from Python3 source
  code.



  * `lobster-python`: Extract requirements from Python3 code



  This tool supports both Python code and PyUnit/unittest unit tests.

  For either code or tests you can embedd tracing tags like this:

  ```python
     def potato(self):
        
        return "potato"
  ```

  You can add justifications as well:

  ```python
     def potato(self):
        
        return "potato"
  ```

  For classes, you have a choice on how you trace them: you either
  annotate the class itself, or each individual method. If you choose to
  annotate the class itself, then you will get warnings for each method
  with an annotation.

  For normal code the usage is:

  ```bash
  lobster-python FILES_OR_DIRS
  ```

  Note that `FILES_OR_DIRS` should not contain any tests.
  They will be treated as regular code otherwise.

  For tests (`pyunit` or `unittest`) the usage is:

  ```bash
  lobster-python --activity FILES_OR_DIRS
  ```

  Here `FILES_OR_DIRS` may contain additional code (like the implementation of mock classes), but it will be ignored.

  For `pyunit` and `unittest` the tool automatically ignores any class function that is
  not explicitly a test (i.e. you don't need to manually exclude your
  setup or tear down code, only individual tests will be included).

  Please note that the generated output json files always use `PyTest` as framework indicator, even if `unittest` is used:
  ```json
  {
    "framework": "PyUnit",
    "kind": "Test"
  }
  ```



  The resulting lobster file does not use the method names, but instead uses the class name together with an integer counter for consecutive methods.
  This only affects methods in a class.
  It does not affect functions.
  For details see [issue 89](https://github.com/bmw-software-engineering/lobster/issues/89).
  It will be fixed with the next release.



  The copyright holder of LOBSTER is the Bayerische Motoren Werke
  Aktiengesellschaft (BMW AG), and LOBSTER is published under the [GNU
  Affero General Public License, Version
  3](https://github.com/bmw-software-engineering/lobster/blob/main/LICENSE.md).


pkgId: 8d5182a72ac01310feb22d11aacbb2f27c0a77e1477273f12b53390b94aa4fed
name: python-boaviztapi-help
arch: noarch
version: 1.3.7
epoch: 0
release: 1
summary: Development documents and examples for boaviztapi
url: https://pypi.org/project/boaviztapi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-boaviztapi-1.3.7-1.src.rpm
location_href: Packages/python-boaviztapi-help-1.3.7-1.noarch.rpm
checksum_type: sha256
description:
  See the [documentation](https://doc.api.boavizta.org/) for API usage and methodology.
  [![Python tests](https://github.com/Boavizta/boaviztapi/actions/workflows/test.yml/badge.svg)](https://github.com/Boavizta/boaviztapi/actions/workflows/test.yml)
  💬 [Join us on our public chat](https://chat.boavizta.org/signup_user_complete/?id=97a1cpe35by49jdc66ej7ktrjc)

  Boavizta aims to enhance the assessment of environmental impacts induced by ICTs in organizations by providing widespread access to our work in an automated and efficient manner.
  Boavizta integrates various data and methodologies, which are combined and made accessible through this API.
  Transparency and the popularization of scientific knowledge are of utmost importance in this project, and key aspects include open-sourcing the code, versioning the impact factors, and thoroughly documenting the project.
  In the interest of transparency and scientific popularization, the opening of the code, the versioning of the impact factors and the documentation of the project are critical points.
  The system follows a bottom-up approach in its development, organized into layers. The initial layer focuses on equipment. The second layer focues on the impacts of digital services (e.g. cloud instances) or systems. However, assessing the overall global impact of ICT is currently beyond the project's scope.

  * See our pedagogical front-end app (using the API): <https://datavizta.boavizta.org/serversimpact>
  * See the OpenAPI specification: <https://api.boavizta.org/docs>
  * [Documentation](https://doc.api.boavizta.org/)
  * Access the demo API: <https://api.boavizta.org>


  ```bash
  $ docker run -p 5000:5000 ghcr.io/boavizta/boaviztapi:latest
  ```
  Access the API at http://localhost:5000.

  ```bash
  $ pip3 install boaviztapi
  ```
  Run the server locally with:
  ```bash
  $ uvicorn boaviztapi.main:app --host=localhost --port 5000
  ```


  Python 3 mandatory, Python >=3.10 and [Poetry](https://python-poetry.org/) strongly recommended.

  Install poetry (see the [install instructions](https://python-poetry.org/docs/) for more details):
  ```bash
  $ pip3 install poetry
  ```
  Install dependencies and create a Python virtual environment:
  ```bash
  $ make install
  $ poetry shell
  ```

  **Once in the poetry environment**
  The development server uses [uvicorn](https://www.uvicorn.org/) and [FastAPI](https://fastapi.tiangolo.com/). You can launch the development server with the `uvicorn` CLI.
  ```bash
  $ uvicorn boaviztapi.main:app --host=localhost --port 5000
  ```
  You can run the tests with `pytest` via `make test`.

  Build application package:
  ```sh
  make install
  ```
  Build Docker image:
  ```sh

  make docker-build

  docker build --build-arg VERSION=`poetry version -s` .
  ```
  Run Docker image:
  ```sh
  docker run -p 5000:5000/tcp boavizta/boaviztapi:`poetry version -s`
  ```

  ```sh
  make docker-build-development
  make docker-run-development
  ```

  ⚠ This is currently not working , see  [Deployment as serverless application does not work · Issue #153 · Boavizta/boaviztapi](https://github.com/Boavizta/boaviztapi/issues/153)
  Api can be self hosted to your own AWS account using the serverless framework.
  ```sh

  npm install -g serverless
  npm i

  export AWS_PROFILE=your-own-profile

  serverless deploy
  ```
  _Fisrt packaging/deployment may takes a several minutes_

  Once API server is launched API swagger is available at [httsp://localhost:5000/docs](https://localhost:5000/docs).

  See [contributing.md](./CONTRIBUTING.md).
  You can build a source distribution (installable with pip) with `make build`.

  We use [Semantic Versioning 2.0.0](https://semver.org/)
  |    Type     | Description                                                          |    Command        |
  | :---        |    :----:                                                            |              ---: |
  | MAJOR       | version when you make incompatible API changes                       | ```make major```  |
  | MINOR       | version when you add functionality in a backwards compatible manner  | ```make minor```  |
  | PATCH       | version when you make backwards compatible bug fixes                 | ```make patch```  |

  You can run:
  ```shell
  API_TOKEN=<your_token> make distribute
  ```

  GNU Affero General Public License v3.0


pkgId: 7d1497c649aac9dd065dad75e426a59fa89fb0d0a71d84faa7698beaba076c5c
name: python-bocl-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for bocl
url: https://pypi.org/project/bocl/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bocl-0.3.0-1.src.rpm
location_href: Packages/python-bocl-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  **B-OCL** is a tool designed to parse and evaluate the OCL constraints designed on **BESSER** models.
  It is a python based implementation, that utilises parser and listener generated with the ANTLR4 grammer.

  **BESSER** is a low-modeling low-code open-source platform built on top
  of our Python-based personal interpretation of a "Universal Modeling Language"


  We have tested B-OCL with python 3.9+. We recommend creating a virtual environment using `venv <https://docs.python.org/3/tutorial/venv.html>`_, or
  `conda <https://docs.conda.io/en/latest/>`_).

  Dependencies
  ************
  B-OCL depends on BESSER for parsing the OCL constraints and providing a concrete syntax tree (CST) to evaluate. The latest stable version of BESSER is available in the Python Package Index (PyPi) and can be installed using


      $ pip install besser





  Stable version of B-OCL interpreter can be installed via

      $ pip install bocl



  To obtain the full code, including examples and tests, you can clone the git repository.

      $ git clone https://github.com/BESSER-PEARL/b-ocl-Interpreter
      $ cd b-ocl-Interpreter

  To install the reqs please run the following commands in virtual environment (recommended)

      $ pip install -r requirements.txt



  We encourage contributions from the community and any comment is welcome!

  If you are interested in contributing to this project, please read the [CONTRIBUTING.md](CONTRIBUTING.md) file.



  At BESSER, our commitment is centered on establishing and maintaining development environments that are welcoming, inclusive, safe and free from all forms of harassment. All participants are expected to voluntarily respect and support our [Code of Conduct](CODE_OF_CONDUCT.md).



  The development of this project follows the governance rules described in the [GOVERNANCE.md](GOVERNANCE.md) document.


  You can reach us at: [info@besser-pearl.org](mailto:info@besser-pearl-org)

  Website: https://besser-pearl.github.io/website/


  More details about B-OCL can be found here https://b-ocl-interpreter.readthedocs.io/en/latest/



  This project is licensed under the [MIT](https://mit-license.org/) license.


pkgId: d4b3d1cf75d9786254c97b8fee5b1854c88468a25a9c10ec7edc7fc129407766
name: python-bofhound-help
arch: noarch
version: 0.4.5
epoch: 0
release: 1
summary: Development documents and examples for bofhound
url: https://github.com/coffeegist/bofhound
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bofhound-0.4.5-1.src.rpm
location_href: Packages/python-bofhound-help-0.4.5-1.noarch.rpm
checksum_type: sha256
description:
  ```
                _____________________________ __    __    ______    __    __   __   __   _______
               |   _   /  /  __   / |   ____/|  |  |  |  /  __  \  |  |  |  | |  \ |  | |       \
               |  |_)  | |  |  |  | |  |__   |  |__|  | |  |  |  | |  |  |  | |   \|  | |  .--.  |
               |   _  <  |  |  |  | |   __|  |   __   | |  |  |  | |  |  |  | |  . `  | |  |  |  |
               |  |_)  | |  `--'  | |  |     |  |  |  | |  `--'  | |  `--'  | |  |\   | |  '--'  |
               |______/   \______/  |__|     |__|  |___\_\________\_\________\|__| \___\|_________\

                                           << @coffeegist | @Tw1sm >>
  ```

  <h1 align="center">

  ![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54)
  ![PyPi](https://img.shields.io/pypi/v/bofhound?style=for-the-badge)
  </h1>

  BOFHound is an offline BloodHound ingestor and LDAP result parser compatible with TrustedSec's [ldapsearch BOF](https://github.com/trustedsec/CS-Situational-Awareness-BOF), the Python adaptation, [pyldapsearch](https://github.com/fortalice/pyldapsearch) and Brute Ratel's [LDAP Sentinel](https://bruteratel.com/tabs/commander/badgers/#ldapsentinel). ldapsearch BOF logs can also be parsed from [Havoc](https://github.com/HavocFramework/Havoc) or OutflankC2 logs.

  By parsing log files generated by the aforementioned tools, BOFHound allows operators to utilize BloodHound's beloved interface while maintaining full control over the LDAP queries being run and the spped at which they are executed. This leaves room for operator discretion to account for potential honeypot accounts, expensive LDAP query thresholds and other detection mechanisms designed with the traditional, automated BloodHound collectors in mind.

  Check this [PR](https://github.com/trustedsec/CS-Situational-Awareness-BOF/pull/114) to the SA BOF repo for BOFs that collect session and local group membership data and can be parsed by BOFHound.



  Blog Posts:

  | Title| Date|
  |------|-----|
  | [*BOFHound: AD CS Integration*](https://medium.com/specter-ops-posts/bofhound-ad-cs-integration-91b706bc7958) | Oct 30, 2024 |
  | [*BOFHound: Session Integration*](https://posts.specterops.io/bofhound-session-integration-7b88b6f18423) | Jan 30, 2024 |
  | [*Granularize Your AD Recon Game Part 2*](https://www.fortalicesolutions.com/posts/granularize-your-active-directory-reconnaissance-game-part-2) | Jun 15, 2022 |
  | [*Granularize Your AD Recon Game*](https://www.fortalicesolutions.com/posts/bofhound-granularize-your-active-directory-reconnaissance-game) | May 10, 2022  |

  Presentations:

  | Conference| Materials| Date|
  |-----------|----------|-----|
  | *SO-CON 2024*| [Slides](https://github.com/SpecterOps/presentations/blob/main/SO-CON%202024/Matt%20Creel%20%26%20Adam%20Brown%20-%20Manually%20Enumerating%20AD%20Attack%20Paths%20with%20BOFHound/Matt%20Creel%20and%20Adam%20Brown%20-%20Manually%20Enumerating%20AD%20Attack%20Paths%20With%20BOFHound%20-%20SO-CON%202024.pdf) & [Recording](https://www.youtube.com/watch?v=Xxm4YktSKVY)| Mar 11, 2024|


  BOFHound can be installed with `pip3 install bofhound` or by cloning this repository and running `pip3 install .`


  ```
   Usage: bofhound [OPTIONS]

   Generate BloodHound compatible JSON from logs written by ldapsearch BOF, pyldapsearch and Brute Ratel's
   LDAP Sentinel

   Generate BloodHound compatible JSON from logs written by ldapsearch BOF, pyldapsearch and Brute
   Ratel's LDAP Sentinel

  ╭─ Options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ --input             -i      TEXT                              Directory or file containing     │
  │                                                               logs of ldapsearch results       │
  │                                                               [default:                        │
  │                                                               /opt/cobaltstrike/logs]          │
  │ --output            -o      TEXT                              Location to export bloodhound    │
  │                                                               files                            │
  │                                                               [default: .]                     │
  │ --properties-level  -p      [Standard|Member|All]             Change the verbosity of          │
  │                                                               properties exported to JSON:     │
  │                                                               Standard - Common BH properties  │
  │                                                               | Member - Includes MemberOf and │
  │                                                               Member | All - Includes all      │
  │                                                               properties                       │
  │                                                               [default: Member]                │
  │ --parser                    [ldapsearch|BRC4|Havoc|           Parser to use for log files.     │
  │                             OutflankC2]                       ldapsearch parser (default)      │
  │                                                               supports ldapsearch BOF logs     │
  │                                                               from Cobalt Strike and           │
  │                                                               pyldapsearch logs                │
  │                                                               [default: ldapsearch]            │
  │ --debug                                                       Enable debug output              │
  │ --zip               -z                                        Compress the JSON output files   │
  │                                                               into a zip archive               │
  │ --help              -h                                        Show this message and exit.      │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯


  ```


  Parse ldapseach BOF results from Cobalt Strike logs (`/opt/cobaltstrike/logs` by default) to /data/
  ```
  bofhound -o /data/
  ```

  Parse pyldapsearch logs and only include all properties (vs other property levels)
  ```
  bofhound -i ~/.pyldapsearch/logs/ --properties-level all
  ```

  Parse LDAP Sentinel data from BRc4 logs (will change default input path to `/opt/bruteratel/logs`)
  ```
  bofhound --parser brc4
  ```

  Parse Havoc loot logs (will change default input path to `/opt/havoc/data/loot`) and zip the resulting JSON files
  ```
  bofhound --parser havoc --zip
  ```


  Specify `*,ntsecuritydescriptor` as the attributes to return to be able to parse ACL edges. You are missing a ton of data if you don't include this in your `ldapsearch` queries!


  The following attributes are required for proper functionality:
  ```
  samaccounttype
  distinguishedname
  objectsid
  ```

  Some object classes rely on domain objects being populated within BOFHound. Domains can be queried with either of the following commands
  ```
  ldapsearch (objectclass=domain) *,ntsecuritydescriptor
  ldapsearch (distinguishedname=DC=windomain,DC=local) *,ntsecuritydescriptor
  ```


  ```

  ldapsearch (objectclass=*) *,ntsecuritydescriptor


  ldapsearch (schemaIDGUID=*) name,schemaidguid 0 3 "" CN=Schema,CN=Configuration,DC=windomain,DC=local


  ldapsearch (name=ms-mcs-admpwd) name,schemaidguid 1 3 "" CN=Schema,CN=Configuration,DC=windomain,DC=local


  ldapsearch (netbiosname=*) * 0 3 "" "CN=Partitions,CN=Configuration,DC=windomain,DC=local"


  ldapsearch (memberOf:1.2.840.113556.1.4.1941:=CN=TargetGroup,CN=Users,DC=windomain,DC=local) *,ntsecuritydescriptor


  ldapsearch (objectclass=trusteddomain) *,ntsecuritydescriptor


  ldapsearch (objectclass=domain) *,ntsecuritydescriptor 0 3 dc1.trusted.windomain.local "DC=TRUSTED,DC=WINDOMAIN,DC=LOCAL"





  ldapsearch (objectclass=domain) *,ntsecuritydescriptor


  ldapsearch (objectclass=pKIEnrollmentService) *,ntsecuritydescriptor 0 3 “” “CN=Configuration,DC=domain,DC=local”


  ldapsearch (objectclass=certificationAuthority) *,ntsecuritydescriptor 0 3 “” “CN=Configuration,DC=domain,DC=local”


  ldapsearch (objectclass=pKICertificateTemplate) *,ntsecuritydescriptor 0 3 “” “CN=Configuration,DC=domain,DC=local”


  ldapsearch (objectclass=msPKI-Enterprise-Oid) *,ntsecuritydescriptor 0 3 “” “CN=Configuration,DC=domain,DC=local”
  ```


  Check the tagged releases to download a specific version
  - v0.4.0 and onward support parsing AD CS objects and edges
  - v0.3.0 and onward support session/local group data
  - v0.2.1 and onward are compatible with BloodHound CE
  - v0.2.0 is the last release supporting BloodHound Legacy


  bofhound uses Poetry to manage dependencies. Install from source and setup for development with:

  ```shell
  git clone https://github.com/fortalice/bofhound
  cd bofhound
  poetry install
  poetry run bofhound --help
  ```


  - [@_dirkjan](https://twitter.com/_dirkjan) (and other contributors) for [BloodHound.py](https://github.com/fox-it/BloodHound.py)
  - TrustedSec for [CS-Situational-Awareness-BOF](https://github.com/trustedsec/CS-Situational-Awareness-BOF)
  - [P-aLu](https://github.com/P-aLu) for collaboration on bofhoud's [AD CS support](https://github.com/coffeegist/bofhound/pull/8)


pkgId: abc9a2d92583b7edf36f61a173bad01e743f5b280c2949f545485dfc9fb3c899
name: python-bogs-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for bogs
url: https://github.com/Swaran66/TCRA_SRN
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bogs-0.1.2-1.src.rpm
location_href: Packages/python-bogs-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  **Tropical Cyclone Risk Analysis (TCRA)** is a Python package that allows for the development of scenario-based tropical cyclone risk analysis of buildings and Electrical Power Network (EPN). This tool performs scenario-hazard analysis based on historical or simulated cyclone tracks, fragility-based damage analysis, damage ratio analysis, loss estimation, recovery simulation of damaged structures, and social impact assessments on the community. It also enables decision-makers to make rehabilitation decisions and perform rehabilitation scenario analysis.

rpm_license:
  MIT License  Copyright (c) 2024 rxm562  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: c88f819b6c5fe64658e626b7e045d1d14c386d7c6f6030722462a0b678d7baaa
name: python-boilermaker-servicebus-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for boilermaker-servicebus
url: https://pypi.org/project/boilermaker-servicebus/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-boilermaker-servicebus-0.6.0-1.src.rpm
location_href: Packages/python-boilermaker-servicebus-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  This project is an extremely-lightweight task-runner exclusively for __async Python__ and Azure Service Bus Queues. If you need a fully fledged task-runner, you should consider one of these other projects instead:

  - [Celery](https://github.com/celery/celery/tree/main)
  -



  ```sh
  pip install "boilermaker-servicebus"
  ```



  The `Boilermaker` application object requires some state (which will get sent to all handlers as the first argument upon invocation) and an authenticated ServiceBus client.

  A task handler for `Boilermaker` is any async function which takes as its first argument application state and which has been registered:

  ```python

  async def background_task1(state, somearg, somekwarg=True):
      """`state` must be first argument."""
      await state.data.get("key")
      print(state)
      print(somearg)
      print(somekwarg)


  boilermaker_app.register_async(background_task1, policy=...A retry policy goes here...)
  ```
  __Note__: `Boilermaker` does not currently have a way to store or use the results of tasks, and all arguments must be JSON-serializable.



  For a fuller example, in our application, we may have some code like the following:

  ```python
  from azure.identity.aio import DefaultAzureCredential
  from boilermaker.app import Boilermaker
  from boilermaker.config import Config

  from boilermaker.service_bus import AzureServiceBus
  from boilermaker import retries



  class App:
      def __init__(self, data):
          self.data = data



  async def background_task1(state, somearg, somekwarg=True):
      """`state` must be first argument."""
      await state.data.get("key")
      print(state)
      print(somearg)
      print(somekwarg)



  service_bus_namespace_url = os.environ["SERVICE_BUS_NAMESPACE_URL"]
  service_bus_queue_name = os.environ["SERVICE_BUS_QUEUE_NAME"]
  conf = Config(
      service_bus_namespace_url=service_bus_namespace_url,
      service_bus_queue_name=service_bus_queue_name,
  )

  service_bus_client = AzureServiceBus.from_config(conf)


  worker = Boilermaker(App({"key": "value"}), service_bus_client=service_bus_client)
  worker.register_async(background_task1, policy=retries.RetryPolicy.default())



  async def publish_task():
      await worker.apply_async(
          background_task1, "first-arg", somekwarg=False
      )

  if __name__ == "__main__":
      asyncio.run(publish_task())
  ```

  In another process, we'll need to _run_ a background task worker. That looks like this:

  ```python
  async def run_worker():
      await worker.run()
  ```

  If we look in the logs for our other process, we should be able to see this task registered and run:

  ```sh
  {"event": "Registered background function fn=background_task1", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:46:54"}
  {"event": "[background_task1] Begin Task sequence_number=19657", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:23"}
  ...prints-go-here...
  {"event": "[background_task1] Completed Task sequence_number=19657 in 0.00021130498498678207s", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:23"}
  ```




  It is possible to register callbacks for tasks, which can run on success or failure. To schedule a task with callbacks, we have to create a task object and then set a success and/or failure callback. Finally, instead of `apply_async` we have to call `publish_task`:

  ```python
  ...see worker-instantation example above...

  from boilermaker.failure import TaskFailureResult

  async def a_background_task(state, param: str):
      if param == "success":
          print("Things seem to be going really well")
          return None
      elif param == "fail":
          return TaskFailureResult
      raise ValueError("Exceptions are a bummer!")


  async def happy_path(state):
      print("Everything is great!")


  async def sad_path(state):
      print("Everything is sad")



  worker.register_async(a_background_task, policy=retries.NoRetry())
  worker.register_async(happy_path, policy=retries.NoRetry())
  worker.register_async(sad_path, policy=retries.NoRetry())


  happy_task = worker.create_task(a_background_task, "success")

  happy_task.on_success = worker.create_task(happy_path)

  happy_task.on_failure = worker.create_task(sad_path)


  sad_task = worker.create_task(a_background_task, "uh oh!")

  sad_task.on_success = worker.create_task(happy_path)

  sad_task.on_failure = worker.create_task(sad_path)


  async def publish_task():
      await worker.publish_task(happy_task)
      
      await asyncio.sleep(4)
      await worker.publish_task(sad_task)
  ```

  Here are examples of log out from running the above:

  ```json
  // Logs from registering the functions
  {"event": "Registered background function fn=callback_task_test", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:46:54"}
  {"event": "Registered background function fn=happy_path", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:46:54"}
  {"event": "Registered background function fn=sad_path", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:46:54"}
  // Happy path test ->
  {"event": "[callback_task_test] Begin Task sequence_number=19657", "version": "pr72-0.25.1", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:23"}
  {"event": "[callback_task_test] Completed Task sequence_number=19657 in 0.00021130498498678207s", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:23"}
  {"event": "[happy_path] Begin Task sequence_number=19659", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:24"}
  {"event": "[happy_path] Completed Task sequence_number=19659 in 0.0001390039687976241s", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:24"}
  // Sad path test ->
  {"event": "[callback_task_test] Begin Task sequence_number=19661", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:27"}
  {"event": "Failed processing task sequence_number=19661  Traceback (most recent call last):\n  File \"/app/.venv/lib/python3.12/site-packages/boilermaker/app.py\", line 238, in message_handler\n    result = await self.task_handler(task, sequence_number)\n             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n  File \"/app/.venv/lib/python3.12/site-packages/boilermaker/app.py\", line 306, in task_handler\n    result = await function(\n             ^^^^^^^^^^^^^^^\n  File \"/app/boilermaker_example.py\", line 210, in callback_task_test\n    raise ValueError(\"Negative numbers are a bummer\")\nValueError: Negative numbers are a bummer\n", "level": "error", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:27"}
  {"event": "[sad_path] Begin Task sequence_number=19663", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:28"}
  {"event": "[sad_path] Completed Task sequence_number=19663 in 0.00020030408632010221s", "level": "info", "logger": "boilermaker.app", "timestamp": "2024/12/10 15:52:28"}
  ```



  Retries are configured in `Boilermaker` using a `RetryPolicy`:

  ```python
  class RetryPolicy(BaseModel):
      
      max_tries: int = MAX_REASONABLE_RETRIES
      
      delay: int = 0
      
      delay_max: int = MAX_BACKOFF_SECONDS
      
      retry_mode: RetryMode = RetryMode.Fixed
  ```

  Retries are __scheduled__ only by raising a `RetryException`:

  ```python
  def sometask(state):
      raise RetryException("Please try again!")
  ```

  __Note__: _all_ tasks __must__ be registered with a `RetryPolicy`, but `Boilermaker` will only retry tasks that have raised a `RetryException`.

  If you do not want your tasks to be retried:

  - Do not throw a `RetryException` from inside of your task.
  - Register them with a `NoRetry` policy: `worker.register_async(..., policy=retries.NoRetry())`

  `NoRetry()` is simply a special policy where `max_tries=1`.

  __Note__: `on_failure` callbacks will only be run __after all retries have been exhausted__.



  There are three places where retries for a task can be configured:

  - When initially registering a task (the task default).
  - When scheduling a task (overrides the default for that invocation).
  - When raising a `RetryException` with a custom policy (overrides default _if_ different).

  Examples of each are included below.



  When a task has been registered, we can set a retry policy for any invocation of it:

  ```python
  from boilermaker import retries

  async def a_background_task(state, param: str):
      if param == "throwing":
          
          raise retries.RetryException("We are thrown")
      return "OK"

  worker.register_async(a_background_task, policy=retries.RetryPolicy.default())
  ```

  This example works like a template for running the task. If `a_background_task` gets retried, `Boilermaker` will use the default policy to calculate its next delay and max attempts allowed.



  Sometimes we'd like to publish our task so that its retries follow a different plan than the task was originally registered with.

  We can __publish__ (schedule) a particular task with a different retry policy like this:

  ```python
  from boilermaker import retries

  async def a_background_task(state, param: str):
      if param == "throwing":
          
          
          raise retries.RetryException("We are thrown")
      return "OK"


  worker.register_async(a_background_task, policy=retries.RetryPolicy.default())

  async def schedule_task_with_different_policy():
      new_policy=retries.RetryPolicy(
          max_tries=100, delay=2, delay_max=1000, retry_mode=retries.RetryMode.Exponential,
      )
      await worker.apply_async(a_background_task, "throwing", policy=new_policy)
  ```

  In the above example, _this_ invocation of the task has a new retry policy, but all other invocations of this task elsewhere in our codebase will continue to use the default.




  Lastly, it's also possible to request a different `RetryPolicy` from _inside_ a task:


  ```python
  from boilermaker import retries

  async def a_background_task(state, param: str):
      if param == "throwing":
          
          raise retries.RetryExceptionDefaultExponential("We are thrown", max_tries=42)
      return "OK"


  worker.register_async(a_background_task, policy=retries.RetryPolicy.default())

  async def schedule_task_with_different_policy():
      new_policy=retries.RetryPolicy(
          max_tries=10, delay=20, delay_max=100, retry_mode=retries.RetryMode.Linear,
      )
      
      await worker.apply_async(a_background_task, "throwing", policy=new_policy)
  ```




  **Where does the name come from?**

  From [here](https://www.discogs.com/artist/632957-Boilermaker)

  **Are You Going to Add Other Queue Services?**

  No, not planning to. Consider one of the other background-task libraries.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024 Mulligan Funding  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: 14e82e04fd981fffec4792d669a6688893a9b4431d2f81a4be1fe95b027d6052
name: python-bolna-help
arch: noarch
version: 0.9.2
epoch: 0
release: 1
summary: Development documents and examples for bolna
url: https://pypi.org/project/bolna/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bolna-0.9.2-1.src.rpm
location_href: Packages/python-bolna-help-0.9.2-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
  </h1>
  <p align="center">
    <p align="center"><b>End-to-end open-source voice agents platform</b>: Quickly build voice firsts conversational assistants through a json. </p>
  </p>

  <h4 align="center">
    <a href="https://discord.gg/59kQWGgnm8">Discord</a> |
    <a href="https://docs.bolna.dev">Docs</a> |
    <a href="https://bolna.dev">Website</a>
  </h4>

  <h4 align="center">
    <a href="https://discord.gg/59kQWGgnm8">
        <img src="https://img.shields.io/static/v1?label=Chat%20on&message=Discord&color=blue&logo=Discord&style=flat-square" alt="Discord">
    </a>
    <a href="https://github.com/bolna-ai/bolna/blob/main/LICENSE">
      <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="Bolna is released under the MIT license." />
    </a>
    <a href="https://github.com/bolna-ai/bolna/blob/main/CONTRIBUTING.md">
      <img src="https://img.shields.io/badge/PRs-Welcome-brightgreen" alt="PRs welcome!" />
    </a>
  </h4>

  > [!NOTE]
  > We are actively looking for maintainers.



  **[Bolna](https://bolna.dev)** is the end-to-end open source production ready framework for quickly building LLM based voice driven conversational applications.


  https://github.com/bolna-ai/bolna/assets/1313096/2237f64f-1c5b-4723-b7e7-d11466e9b226



  This repository contains the entire orchestration platform to build voice AI applications. It technically orchestrates voice conversations using combination of different ASR+LLM+TTS providers and models over websockets.



  Bolna helps you create AI Voice Agents which can be instructed to do tasks beginning with:

  1. Orchestration platform (this open source repository)
  2. Hosted APIs (https://docs.bolna.dev/api-reference/introduction) built on top of this orchestration platform [currently closed source]
  3. No-code UI playground at https://playground.bolna.dev/ using the hosted APIs + tailwind CSS [currently closed source]



  1. Any integration, enhancement or feature initially lands on this open source package since it form the backbone of our APIs and dashboard
  2. Post that we expose APIs or make changes to existing APIs as required for the same
  3. Thirdly, we push it to the UI dashboard

  ```mermaid
  graph LR;
      A[Bolna open source] -->B[Hosted APIs];
      B[Hosted APIs] --> C[Playground]
  ```


  1. Initiating a phone call using telephony providers like `Twilio`, `Plivo`, `Exotel` (coming soon), `Vonage` (coming soon) etc.
  2. Transcribing the conversations using `Deepgram`, etc.
  3. Using LLMs like `OpenAI`, `Llama`, `Cohere`, `Mistral`,  etc to handle conversations
  4. Synthesizing LLM responses back to telephony using `AWS Polly`, `ElevenLabs`, `Deepgram`, `OpenAI`, `Azure`, `Cartesia`, `Smallest` etc.


  Refer to the [docs](https://docs.bolna.dev/providers) for a deepdive into all supported providers.



  A basic local setup includes usage of [Twilio](local_setup/telephony_server/twilio_api_server.py) or [Plivo](local_setup/telephony_server/plivo_api_server.py) for telephony. We have dockerized the setup in `local_setup/`. One will need to populate an environment `.env` file from `.env.sample`.

  The setup consists of four containers:

  1. Telephony web server:
     * Choosing Twilio: for initiating the calls one will need to set up a [Twilio account](https://www.twilio.com/docs/usage/tutorials/how-to-use-your-free-trial-account)
     * Choosing Plivo: for initiating the calls one will need to set up a [Plivo account](https://www.plivo.com/)
  2. Bolna server: for creating and handling agents
  3. `ngrok`: for tunneling. One will need to add the `authtoken` to `ngrok-config.yml`
  4. `redis`: for persisting agents & prompt data

  Use docker to build the images using `.env` file as the environment file and run them locally
  1. `docker-compose build --no-cache bolna-app <twilio-app | plivo-app>`: rebuild images
  2. `docker-compose up bolna-app <twilio-app | plivo-app>`: run the build images

  Once the docker containers are up, you can now start to create your agents and instruct them to initiate calls.



  Go to the [Bolna wiki](https://github.com/bolna-ai/bolna/wiki) to try out sample agents.



  You can populate the `.env` file to use your own keys for providers.

  <details>

  <summary>ASR Providers</summary><br>
  These are the current supported ASRs Providers:

  | Provider     | Environment variable to be added in `.env` file |
  |--------------|-------------------------------------------------|
  | Deepgram     | `DEEPGRAM_AUTH_TOKEN`                           |

  </details>
  &nbsp;<br>

  <details>
  <summary>LLM Providers</summary><br>
  Bolna uses LiteLLM package to support multiple LLM integrations.

  These are the current supported LLM Provider Family:
  https://github.com/bolna-ai/bolna/blob/477e08d6800dbf02931abeeea883d78451b7d7e2/bolna/providers.py#L29-L44

  For LiteLLM based LLMs, add either of the following to the `.env` file depending on your use-case:<br><br>
  `LITELLM_MODEL_API_KEY`: API Key of the LLM<br>
  `LITELLM_MODEL_API_BASE`: URL of the hosted LLM<br>
  `LITELLM_MODEL_API_VERSION`: API VERSION for LLMs like Azure

  For LLMs hosted via VLLM, add the following to the `.env` file:<br>
  `VLLM_SERVER_BASE_URL`: URL of the hosted LLM using VLLM

  </details>
  &nbsp;<br>

  <details>

  <summary>TTS Providers</summary><br>
  These are the current supported TTS Providers:
  https://github.com/bolna-ai/bolna/blob/c8a0d1428793d4df29133119e354bc2f85a7ca76/bolna/providers.py#L7-L14

  | Provider   | Environment variable to be added in `.env` file  |
  |------------|--------------------------------------------------|
  | AWS Polly  | Accessed from system wide credentials via ~/.aws |
  | Elevenlabs | `ELEVENLABS_API_KEY`                             |
  | OpenAI     | `OPENAI_API_KEY`                                 |
  | Deepgram   | `DEEPGRAM_AUTH_TOKEN`                            |
  | Cartesia   | `CARTESIA_API_KEY`                            |
  | Smallest   | `SMALLEST_API_KEY`                            |

  </details>
  &nbsp;<br>

  <details>

  <summary>Telephony Providers</summary><br>
  These are the current supported Telephony Providers:

  | Provider | Environment variable to be added in `.env` file                                                                                                                    |
  |----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | Twilio   | `TWILIO_ACCOUNT_SID`, `TWILIO_AUTH_TOKEN`, `TWILIO_PHONE_NUMBER`|
  | Plivo    | `PLIVO_AUTH_ID`, `PLIVO_AUTH_TOKEN`, `PLIVO_PHONE_NUMBER`|

  </details>


  **We have in the past tried to maintain both the open source and the hosted solution (via APIs and a UI dashboard)**.

  We have fluctuated b/w maintaining this repository purely from a point of time crunch and not interest.

  Currently, we are continuing to maintain it for the community and improving the adoption of Voice AI.

  Though the repository is completely open source, you can connect with us if interested in managed hosted offerings or more customized solutions.
  <a href="https://calendly.com/bolna/30min"><img alt="Schedule a meeting" src="https://cdn.cookielaw.org/logos/122ecfc3-4694-42f1-863f-2db42d1b1e68/0bcbbcf4-9b83-4684-ba59-bc913c0d5905/c21bea90-f4f1-43d1-8118-8938bbb27a9d/logo.png" /></a>


  In case you wish to extend and add some other Telephony like Vonage, Telnyx, etc. following the guidelines below:
  1. Make sure bi-directional streaming is supported by the Telephony provider
  2. Add the telephony-specific input handler file in [input_handlers/telephony_providers](https://github.com/bolna-ai/bolna/tree/master/bolna/input_handlers/telephony_providers) writing custom functions extending from the [telephony.py](https://github.com/bolna-ai/bolna/blob/master/bolna/input_handlers/telephony.py) class
     1. This file will mainly contain how different types of event packets are being ingested from the telephony provider
  3. Add telephony-specific output handler file in [output_handlers/telephony_providers](https://github.com/bolna-ai/bolna/tree/master/bolna/output_handlers/telephony_providers) writing custom functions extending from the [telephony.py](https://github.com/bolna-ai/bolna/blob/master/bolna/output_handlers/telephony.py) class
     1. This mainly concerns converting audio from the synthesizer class to a supported audio format and streaming it over the websocket provided by the telephony provider
  4. Lastly, you'll have to write a dedicated server like the example [twilio_api_server.py](https://github.com/bolna-ai/bolna/blob/master/local_setup/telephony_server/twilio_api_server.py) provided in [local_setup](https://github.com/bolna-ai/bolna/blob/master/local_setup/telephony_server) to initiate calls over websockets.



  We love all types of contributions: whether big or small helping in improving this community resource.

  1. There are a number of [open issues present](https://github.com/bolna-ai/bolna/issues) which can be good ones to start with
  2. If you have suggestions for enhancements, wish to contribute a simple fix such as correcting a typo, or want to address an apparent bug, please feel free to initiate a new issue or submit a pull request
  2. If you're contemplating a larger change or addition to this repository, be it in terms of its structure or the features, kindly begin by creating a new issue [open a new issue :octocat:](https://github.com/bolna-ai/bolna/issues/new) and outline your proposed changes. This will allow us to engage in a discussion before you dedicate a significant amount of time or effort. Your cooperation and understanding are appreciated

rpm_license:
  Copyright (c) 2023 Bolna  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: f16f0ca43d1a6b23634354e7df897ce7d7051231b0d533b38e3e71fe885231f6
name: python-booktest-help
arch: noarch
version: 0.3.44
epoch: 0
release: 1
summary: Development documents and examples for booktest
url: https://github.com/lumoa-oss/booktest
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-booktest-0.3.44-1.src.rpm
location_href: Packages/python-booktest-help-0.3.44-1.noarch.rpm
checksum_type: sha256
description:
  booktest is review-driven testing tool that combines Jupyterbook style data science
  development with traditional regression testing. Booktest is developed by
  [Lumoa.me](https://lumoa.me), the actionable feedback analytics platform.

  booktest is designed to tackle a common problem with the data science
  RnD work flows and regression testing:

   * Data science produces results such as probability estimates, which can be
     good or bad, but not really right or wrong as in the traditional software engineering.
       * Because the DS results are not strictly right or wrong, it's very difficult to use assertions
         for quality assurance and preventing regression.
       * For example, you cannot really say that accuracy 0.84 is correct, while the
         accuracy 0.83 is incorrect, especially if you have other measurements (log likelihood)
         giving conflicting results. Neither evaluating a topic model as correct or incorrect
         is non-sensical. In practice, most data science applications require an expert
         review.
       * This less ambigious quality also creates need for a better visibility of how
         the system behaves. One typically wants to print out edge cases and their diagnostics
         to see the behavior, see intermediate steps and see the results for different data sets .
   * There is also the problem of the data science data being big and the intermediate
     results being computationally expensive.
       * Jupyter notebook deals with this problem by keeping the state in memory between runs, while
         traditional unittests tend to lose the program state between runs. This leads to very slow
         test runs, slow iteration speed and low productivity.
   * While the Jupyter Notebook provides good visibility to results required by the expert review and
     powerful caching functionality: it fails short on a) often requiring copy-pasting production code to
     make results visible, b) it doesn't support automated regression testing and c) expert review requires
     expensive full review even if nothing changed.

  booktest solves this problem setting by delivering on 3 main points:

   * Focus on the results and analytic as in Jupyter notebook by allowing user to print
     the results as MD files.
   * Keep the intermediate results cached either in memory or in filesystem by
     having two level cache.
   * Instead of doing strict assertions, do testing by comparing old results with
     new results.

  As such, booktest does snapshot testing, and it stores the snapshots in filesystem and in Git.
  Additional benefit of this approach is that you can trace the result development in Git.



  You can find getting started guide [here](getting-started.md)



  You can find guide on common workflows, coverage measurements and
  continuous integration [here](workflows.md)



  Examples are found in the [test example directory](test/examples).

  Example results are visible in the [book index](books/index.md).

  There is also [separate example project](https://github.com/lumoa-oss/booktest-example)




  API reference is generated under [docs](docs) directory. Main classes are:

   * [TestCaseRun](docs/testcaserun.py.md), which provides API for tests
   * [TestBook](docs/testbook.py.md), which provide a base class for test suite object
   * [TestSuite](docs/testsuite.py.md), which provide a base class for test suite object
   * [Tests](docs/tests.py.md), which manages CLI interface



  Development guide is available [here](development.md)


pkgId: d3601c71f2fcb310dc1a56c44642bdca68a746ccbfad8aa95b1d4a70a80e7854
name: python-bookworm_genai-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for bookworm_genai
url: https://pypi.org/project/bookworm_genai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bookworm_genai-0.7.0-1.src.rpm
location_href: Packages/python-bookworm_genai-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  *`bookworm ask`*
  ```python
  python -m bookworm ask
  ```
  ```mermaid
  graph LR
  query
  Bookworm(bookworm ask)
  subgraph _
      LLM(LLM e.g OpenAI)
      VectorStore(Vector Store e.g DuckDB)
  end
  query -->|user queries for information|Bookworm
  Bookworm -->|simularity search|VectorStore -->|send similar docs + user query|LLM
  LLM -->|send back response|Bookworm


pkgId: d7700ffbebc681e9e35cfdb14b16db65fe30172fedf9117e741245dbfad13aba
name: python-bootstrap-rag-help
arch: noarch
version: 0.0.17
epoch: 0
release: 1
summary: Development documents and examples for bootstrap-rag
url: https://pypi.org/project/bootstrap-rag/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bootstrap-rag-0.0.17-1.src.rpm
location_href: Packages/python-bootstrap-rag-help-0.0.17-1.noarch.rpm
checksum_type: sha256
description:
  ![Banner](https://raw.githubusercontent.com/pavanjava/bootstrap-rag/refs/heads/main/assets/bootstrap-rag.png)

  This project will bootstrap and scaffold the projects for specific semantic search and RAG applications along with regular boilerplate code.


  ![Arch](assets/architecture.png)




  - install ollama following this [guide](https://ollama.com/download)
  - install qdrant follwing this [guide](https://qdrant.tech/documentation/guides/installation/)


  - In the root folder run `docker compose -f docker-compose-dev.yml up`
  - One the containers are up and running run `docker exec -it ollama_service sh`
  - In the container shell run `ollama run llama3.1`



  - run `pip install inquirerpy bootstrap-rag`
  - run `bootstraprag create <PROJECT_NAME>`
  - Navigate to newly created project `<PROJECT_NAME>` the run `pip install -r requirements.txt`
  - modify the `.env` file accordingly
  - run `python main.py` for cli experience
    <b>[or]</b> run `python api_server.py`


  - `git clone git@github.com:pavanjava/bootstrap-rag.git`
  - `pip install -e .`
  - run `bootstraprag create <PROJECT_NAME>`
  - Navigate to newly created project `<PROJECT_NAME>` the run `pip install -r requirements.txt`
  - modify the `.env` file accordingly
  - run `python main.py` for cli experience
    <b>[or]</b> run `python api_server.py`


  Note: `llamaindex`, `langchain`, `Qdrant Search` and `RAG evaluations` are functional for now, others frameworks [`langgraph`, `haystack`] in progress.



  ![Demo GIF](https://raw.githubusercontent.com/pavanjava/bootstrap-rag/refs/heads/main/assets/demo.gif)

  ![Qdrant](https://raw.githubusercontent.com/pavanjava/bootstrap-rag/refs/heads/main/assets/qdrant.png)

  ![Arize Phoenix](https://raw.githubusercontent.com/pavanjava/bootstrap-rag/refs/heads/main/assets/observability.png)


pkgId: 110e23b1e7c640ea362d8be0c1f8e0c169cf8564eee9ecc847d42c53c3332e5b
name: python-bootwrap-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for bootwrap
url: https://github.com/mmgalushka/bootwrap
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bootwrap-1.2.1-1.src.rpm
location_href: Packages/python-bootwrap-help-1.2.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Python + Bootstrap = Bootwrap](https://github.com/mmgalushka/bootwrap/raw/main/docs/bootwrap-equation.png)

  [![Continuous Integration Status](https://github.com/mmgalushka/bootwrap/workflows/CI/badge.svg)](https://github.com/mmgalushka/bootwrap/actions)
  [![Code Coverage Percentage](https://codecov.io/gh/mmgalushka/bootwrap/branch/main/graphs/badge.svg)](https://codecov.io/gh/mmgalushka/bootwrap)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/763657a471ff424c85a5b894ddb750d0)](https://www.codacy.com/gh/mmgalushka/bootwrap/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=mmgalushka/bootwrap&amp;utm_campaign=Badge_Grade)
  [![Project License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/mmgalushka/bootwrap/blob/main/LICENSE)
  [![Project Documentation](https://img.shields.io/badge/docs-up--to--date-success)](https://mmgalushka.github.io/bootwrap/)

  **Bootwrap** is a Python library for rapid developing of web-based user interfaces (WebUI). It helps creating WebUI using Python code only and can be used in conjunction with different web-development frameworks such as [Flask](https://palletsprojects.com/p/flask/). Under the hood, this library wraps one of the most popular front-end toolkit [Bootstrap](https://getbootstrap.com/).

  As a showcase of what this library is capable of please check the documentation. The entire [documentation](https://mmgalushka.github.io/bootwrap/) web interface is created using the **Bootwrap**.



  Install and update using [pip](https://pip.pypa.io/en/stable/quickstart/):

  ```bash
  ~$ pip install bootwrap
  ```

  Bootwrap package has no external dependencies!



  The vast majority of web applications consist of frontend and backend. If you are a small team or even a solo developer you need to divide resources and time to focus on both parts. This often results in switching between different platforms such as Python and [React](https://reactjs.org/), [AngularJs](https://angular.io/), Flask templates (HTML, CSS, JS), etc. But what if your main focus is the backend and you also don't want to compromise on the quality of your WebUI. In this case, the Bootwrap library is for you! It will help you develop WebUI without leaving the Python ecosystem and not waste your time on HTML, CSS, and Javascript. To understand its capability just clone the project and run the [demo application](demo/demo.md) ":pig: PiggyBank".

  ![Screenshots Collage](demo/collage.png)

  For more information also read the Bootwrap [documentation](https://mmgalushka.github.io/bootwrap/).



  The following code will create three pages application with a top-level menu bar for navigations. Since this application is based on [Flask](https://palletsprojects.com/p/flask/) make sure that you installed it as well.

  ```Python
  from flask import Flask
  from markupsafe import Markup
  from bootwrap import Page, Menu, Image, Anchor, Button, Text

  app = Flask(__name__, static_folder='docs', static_url_path='')

  LOGO = 'https://github.com/mmgalushka/bootwrap/blob/main/docs/logo.png?raw=true'
  FAVICON = 'https://raw.githubusercontent.com/mmgalushka/bootwrap/main/docs/favicon.ico'

  class MyMenu(Menu):
      def __init__(self):
          super().__init__(
              logo=Image(LOGO, width=32, alt='Logo'),
              brand=Text('Bootwrap').as_strong().as_light().ms(2),
              anchors=[
                  Anchor('Home').link('/'),
                  Anchor('About').link('/about')
              ],
              actions=[
                  Button('Sign In').as_outline().as_light().link('/signin')
              ]
          )

  class MyPage(Page):
      def __init__(self, container):
          super().__init__(
              favicon = FAVICON,
              title='Hello World Application',
              menu=MyMenu(),
              container=container
          )

  @app.route('/')
  def home():
      return Markup(MyPage(container=Text('Home').as_heading(1)))

  @app.route('/about')
  def about():
      return Markup(MyPage(container=Text('About').as_heading(1)))

  @app.route('/signin')
  def signin():
      return Markup(MyPage(container=Text('Sign In').as_heading(1)))

  if __name__ == '__main__':
      app.run(debug=True)
  ```

  Use the following command to launch the application.

  ```bash
  $ flask run
    * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
  ```

  The result should look like.

  ![Simple Example](https://github.com/mmgalushka/bootwrap/raw/main/docs/multi-pages-app.png)



  For information on how to set up a development environment and how to make a contribution to Bootwrap, see the [contributing guidelines](CONTRIBUTING.md).



  - Documentation: [https://mmgalushka.github.io/bootwrap/](https://mmgalushka.github.io/bootwrap/)
  - PyPI Releases: [https://pypi.org/project/bootwrap/](https://pypi.org/project/bootwrap/)
  - Source Code: [https://github.com/mmgalushka/bootwrap](https://github.com/mmgalushka/bootwrap/)
  - Issue Tracker: [https://github.com/mmgalushka/bootwrap/issues](https://github.com/mmgalushka/bootwrap/)


pkgId: 4d48a7bd4914fdaac98f59b46dfff6a8feef21b27b126b0b345b95e6755490b9
name: python-bosdyn-api
arch: noarch
version: 4.1.1
epoch: 0
release: 1
summary: Boston Dynamics API definition of protobuf messages
url: https://dev.bostondynamics.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bosdyn-api-4.1.1-1.src.rpm
location_href: Packages/python-bosdyn-api-4.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.

  Downloading, reproducing, distributing or otherwise using the SDK Software
  is subject to the terms and conditions of the Boston Dynamics Software
  Development Kit License (20191101-BDSDK-SL).
  -->



  <p align="center">
  <img src="https://www.bostondynamics.com/sites/default/files/2020-05/spot.png" style="max-width:50%;">
  </p>

  The bosdyn-api wheel contains the Python implementation for the Protobuf definitions in the Boston
  Dynamics Spot API. The message and service types defined in this wheel are used by the clients in
  [bosdyn-client](https://pypi.org/project/bosdyn-client/),
  [bosdyn-mission](https://pypi.org/project/bosdyn-mission/) and [bosdyn-choreography-client](https://pypi.org/project/bosdyn-choreography-client/) wheels to communicate with the services
  running on the Spot robots.


pkgId: 36b2fb3d48d592bef2507860e1ae63ae14a3f63fb6a9bb0dbeec066bbdc00bfa
name: python-bosdyn-choreography-protos
arch: noarch
version: 4.1.1
epoch: 0
release: 1
summary: Boston Dynamics API Choreography protobufs
url: https://dev.bostondynamics.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bosdyn-choreography-protos-4.1.1-1.src.rpm
location_href: Packages/python-bosdyn-choreography-protos-4.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.

  Downloading, reproducing, distributing or otherwise using the SDK Software
  is subject to the terms and conditions of the Boston Dynamics Software
  Development Kit License (20191101-BDSDK-SL).
  -->



  <p align="center">
  <img src="https://www.bostondynamics.com/sites/default/files/2020-05/spot.png" style="max-width:50%;">
  </p>

  The bosdyn-choreography-protos wheel has been deprecated. The Python implementation for the Protobuf definitions previously stored in this build has been integrated with the [bosdyn-api wheel](https://pypi.org/project/bosdyn-api/).


pkgId: c65867707bd5df125ab50f915e2ff5c766351fcb96696d2fff43832d2e65ba3c
name: python-boto3-assist-help
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: Development documents and examples for boto3-assist
url: https://pypi.org/project/boto3-assist/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-boto3-assist-0.2.8-1.src.rpm
location_href: Packages/python-boto3-assist-help-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
  This is in beta and subject to changes before it's initial 1.0.0 release

  This libary was created to make life a little easier when using boto3.

  Currently it supports:
  - User Authentication / Session Mapping
  - DynamoDB model mapping and key generation.



  Have you ever needed an easy way to load your sessions for a local, dev or production enviroment? Well this library
  makes it a little easier by lazy loading your boto3 session so that tools like `python-dotenv` can be used to load your
  environment vars first and then load your session.


  It's a light weight mapping tool to turn your python classes / object models to DynamoDB items that are ready
  for saving.  See the [examples](https://github.com/geekcafe/boto3-assist/tree/main/examples) directory in the repo for more information.


  ```sh
  python -m vevn .venv
  source ./.venv/bin/activate

  pip install --upgrade pip
  pip install boto3-assist

  ```


pkgId: ca4d8e15681490233ac5f21e45521351a93e36f5949a81dde19546f35d766067
name: python-boto3-stubs-full-help
arch: noarch
version: 1.35.81
epoch: 0
release: 1
summary: Development documents and examples for boto3-stubs-full
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-boto3-stubs-full-1.35.81-1.src.rpm
location_href: Packages/python-boto3-stubs-full-help-1.35.81-1.noarch.rpm
checksum_type: sha256
description:
  <a id="boto3-stubs-full"></a>



  [![PyPI - boto3-stubs-full](https://img.shields.io/pypi/v/boto3-stubs-full.svg?color=blue)](https://pypi.org/project/boto3-stubs-full/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/boto3-stubs-full.svg?color=blue)](https://pypi.org/project/boto3-stubs-full/)
  [![Docs](https://img.shields.io/readthedocs/boto3-stubs.svg?color=blue)](https://youtype.github.io/boto3_stubs_docs/)
  [![PyPI - Downloads](https://static.pepy.tech/badge/boto3-stubs-full)](https://pypistats.org/packages/boto3-stubs-full)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 1.35.81](https://pypi.org/project/boto3/)
  compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated with
  [mypy-boto3-builder 8.6.3](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [boto3-stubs-full docs](https://youtype.github.io/boto3_stubs_docs/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [boto3-stubs-full](#boto3-stubs-full)
    - [How to install](#how-to-install)
      - [Generate locally (recommended)](<#generate-locally-(recommended)>)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
      - [Pylint compatibility](#pylint-compatibility)
      - [Explicit type annotations](#explicit-type-annotations)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="generate-locally-(recommended)"></a>



  You can generate type annotations for `boto3` package locally with
  `mypy_boto3_builder`. Use
  [uv](https://docs.astral.sh/uv/getting-started/installation/) for build
  isolation.

  1. Run mypy-boto3-builder in your package root directory:
     `uvx --with 'boto3==1.35.81' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add all available services.
  4. Use provided commands to install generated packages.

  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Auto-discover services` and select services you use in the current
  project.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs-full` to add type checking for `boto3` package.

  ```bash

  python -m pip install 'boto3-stubs[full]'


  python -m pip install 'boto3-stubs[full,boto3]'
  ```

  <a id="how-to-uninstall"></a>



  ```bash

  python -m pip uninstall -y boto3-stubs-full boto3-stubs
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  > ⚠️ Due to slow PyCharm performance on `Literal` overloads (issue
  > [PY-40997](https://youtrack.jetbrains.com/issue/PY-40997)), it is recommended
  > to use [boto3-stubs-lite](https://pypi.org/project/boto3-stubs-lite/) until
  > the issue is resolved.

  > ⚠️ If you experience slow performance and high CPU usage, try to disable
  > `PyCharm` type checker and use [mypy](https://github.com/python/mypy) or
  > [pyright](https://github.com/microsoft/pyright) instead.

  > ⚠️ To continue using `PyCharm` type checker, you can try to replace
  > `boto3-stubs` with
  > [boto3-stubs-lite](https://pypi.org/project/boto3-stubs-lite/):

  ```bash
  python -m pip uninstall -y boto3-stubs
  python -m pip install 'boto3-stubs-lite[full]'
  ```

  Install `boto3-stubs-lite` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[full]'
  ```

  Both type checking and code completion should now work.

  <a id="emacs"></a>



  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed
    `boto3-stubs-full`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  Optionally, you can install `boto3-stubs-full` to `typings` directory.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pylint-compatibility"></a>



  It is totally safe to use `TYPE_CHECKING` flag in order to avoid
  `boto3-stubs-full` dependency in production. However, there is an issue in
  `pylint` that it complains about undefined variables. To fix it, set all types
  to `object` in non-`TYPE_CHECKING` mode.

  ```python
  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      from mypy_boto3_ec2 import EC2Client, EC2ServiceResource
      from mypy_boto3_ec2.waiters import BundleTaskCompleteWaiter
      from mypy_boto3_ec2.paginators import DescribeVolumesPaginator
  else:
      EC2Client = object
      EC2ServiceResource = object
      BundleTaskCompleteWaiter = object
      DescribeVolumesPaginator = object

  ...
  ```

  <a id="explicit-type-annotations"></a>



  To speed up type checking and code completion, you can set types explicitly.

  ```python
  import boto3
  from boto3.session import Session

  from mypy_boto3_ec2.client import EC2Client
  from mypy_boto3_ec2.service_resource import EC2ServiceResource
  from mypy_boto3_ec2.waiter import BundleTaskCompleteWaiter
  from mypy_boto3_ec2.paginator import DescribeVolumesPaginator

  session = Session(region_name="us-west-1")

  ec2_client: EC2Client = boto3.client("ec2", region_name="us-west-1")
  ec2_resource: EC2ServiceResource = session.resource("ec2")

  bundle_task_complete_waiter: BundleTaskCompleteWaiter = ec2_client.get_waiter(
      "bundle_task_complete"
  )
  describe_volumes_paginator: DescribeVolumesPaginator = ec2_client.get_paginator("describe_volumes")
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from `botocore` schemas.
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [ruff](https://docs.astral.sh/ruff/) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore`, `aiobotocore` and `aioboto3`
    libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.resource` calls
  - Auto discovery of types for `session.client` and `session.resource` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `boto3-stubs-full` version is the same as related `boto3` version and follows
  [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: 23e1f9eec70cb7d36715a40365bab78ff4e986be37fb96b7fe7b62aaca4e5238
name: python-boto3-stubs-full-help
arch: noarch
version: 1.35.85
epoch: 0
release: 1
summary: Development documents and examples for boto3-stubs-full
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-boto3-stubs-full-1.35.85-1.src.rpm
location_href: Packages/python-boto3-stubs-full-help-1.35.85-1.noarch.rpm
checksum_type: sha256
description:
  <a id="boto3-stubs-full"></a>



  [![PyPI - boto3-stubs-full](https://img.shields.io/pypi/v/boto3-stubs-full.svg?color=blue)](https://pypi.org/project/boto3-stubs-full/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/boto3-stubs-full.svg?color=blue)](https://pypi.org/project/boto3-stubs-full/)
  [![Docs](https://img.shields.io/readthedocs/boto3-stubs.svg?color=blue)](https://youtype.github.io/boto3_stubs_docs/)
  [![PyPI - Downloads](https://static.pepy.tech/badge/boto3-stubs-full)](https://pypistats.org/packages/boto3-stubs-full)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 1.35.85](https://pypi.org/project/boto3/)
  compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated with
  [mypy-boto3-builder 8.7.0](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [boto3-stubs-full docs](https://youtype.github.io/boto3_stubs_docs/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [boto3-stubs-full](#boto3-stubs-full)
    - [How to install](#how-to-install)
      - [Generate locally (recommended)](<#generate-locally-(recommended)>)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
      - [Pylint compatibility](#pylint-compatibility)
      - [Explicit type annotations](#explicit-type-annotations)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="generate-locally-(recommended)"></a>



  You can generate type annotations for `boto3` package locally with
  `mypy_boto3_builder`. Use
  [uv](https://docs.astral.sh/uv/getting-started/installation/) for build
  isolation.

  1. Run mypy-boto3-builder in your package root directory:
     `uvx --with 'boto3==1.35.85' mypy_boto3_builder`
  2. Select `boto3-stubs` AWS SDK.
  3. Add all available services.
  4. Use provided commands to install generated packages.

  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Auto-discover services` and select services you use in the current
  project.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs-full` to add type checking for `boto3` package.

  ```bash

  python -m pip install 'boto3-stubs[full]'


  python -m pip install 'boto3-stubs[full,boto3]'
  ```

  <a id="how-to-uninstall"></a>



  ```bash

  python -m pip uninstall -y boto3-stubs-full boto3-stubs
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  > ⚠️ Due to slow PyCharm performance on `Literal` overloads (issue
  > [PY-40997](https://youtrack.jetbrains.com/issue/PY-40997)), it is recommended
  > to use [boto3-stubs-lite](https://pypi.org/project/boto3-stubs-lite/) until
  > the issue is resolved.

  > ⚠️ If you experience slow performance and high CPU usage, try to disable
  > `PyCharm` type checker and use [mypy](https://github.com/python/mypy) or
  > [pyright](https://github.com/microsoft/pyright) instead.

  > ⚠️ To continue using `PyCharm` type checker, you can try to replace
  > `boto3-stubs` with
  > [boto3-stubs-lite](https://pypi.org/project/boto3-stubs-lite/):

  ```bash
  python -m pip uninstall -y boto3-stubs
  python -m pip install 'boto3-stubs-lite[full]'
  ```

  Install `boto3-stubs-lite` in your environment:

  ```bash
  python -m pip install 'boto3-stubs-lite[full]'
  ```

  Both type checking and code completion should now work.

  <a id="emacs"></a>



  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed
    `boto3-stubs-full`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs-full` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[full]'
  ```

  Optionally, you can install `boto3-stubs-full` to `typings` directory.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pylint-compatibility"></a>



  It is totally safe to use `TYPE_CHECKING` flag in order to avoid
  `boto3-stubs-full` dependency in production. However, there is an issue in
  `pylint` that it complains about undefined variables. To fix it, set all types
  to `object` in non-`TYPE_CHECKING` mode.

  ```python
  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      from mypy_boto3_ec2 import EC2Client, EC2ServiceResource
      from mypy_boto3_ec2.waiters import BundleTaskCompleteWaiter
      from mypy_boto3_ec2.paginators import DescribeVolumesPaginator
  else:
      EC2Client = object
      EC2ServiceResource = object
      BundleTaskCompleteWaiter = object
      DescribeVolumesPaginator = object

  ...
  ```

  <a id="explicit-type-annotations"></a>



  To speed up type checking and code completion, you can set types explicitly.

  ```python
  import boto3
  from boto3.session import Session

  from mypy_boto3_ec2.client import EC2Client
  from mypy_boto3_ec2.service_resource import EC2ServiceResource
  from mypy_boto3_ec2.waiter import BundleTaskCompleteWaiter
  from mypy_boto3_ec2.paginator import DescribeVolumesPaginator

  session = Session(region_name="us-west-1")

  ec2_client: EC2Client = boto3.client("ec2", region_name="us-west-1")
  ec2_resource: EC2ServiceResource = session.resource("ec2")

  bundle_task_complete_waiter: BundleTaskCompleteWaiter = ec2_client.get_waiter(
      "bundle_task_complete"
  )
  describe_volumes_paginator: DescribeVolumesPaginator = ec2_client.get_paginator("describe_volumes")
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from `botocore` schemas.
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [ruff](https://docs.astral.sh/ruff/) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore`, `aiobotocore` and `aioboto3`
    libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.resource` calls
  - Auto discovery of types for `session.client` and `session.resource` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `boto3-stubs-full` version is the same as related `boto3` version and follows
  [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: dab7ed3541ed1089a67f8e462b4d5401c7f78a161258f9b1af2d97956f28cc08
name: python-boto3-stubs-help
arch: noarch
version: 1.35.81
epoch: 0
release: 1
summary: Development documents and examples for boto3-stubs
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-boto3-stubs-1.35.81-1.src.rpm
location_href: Packages/python-boto3-stubs-help-1.35.81-1.noarch.rpm
checksum_type: sha256
description:
  <a id="boto3-stubs"></a>



  [![PyPI - boto3-stubs](https://img.shields.io/pypi/v/boto3-stubs.svg?color=blue)](https://pypi.org/project/boto3-stubs/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/boto3-stubs.svg?color=blue)](https://pypi.org/project/boto3-stubs/)
  [![Docs](https://img.shields.io/readthedocs/boto3-stubs.svg?color=blue)](https://youtype.github.io/boto3_stubs_docs/)
  [![PyPI - Downloads](https://static.pepy.tech/badge/boto3-stubs)](https://pypistats.org/packages/boto3-stubs)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 1.35.81](https://pypi.org/project/boto3/)
  compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated with
  [mypy-boto3-builder 8.6.3](https://github.com/youtype/mypy_boto3_builder).

  More information can be found in
  [boto3-stubs docs](https://youtype.github.io/boto3_stubs_docs/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [boto3-stubs](#boto3-stubs)
    - [How to install](#how-to-install)
      - [Generate locally (recommended)](<#generate-locally-(recommended)>)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
      - [From conda-forge](#from-conda-forge)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
      - [Pylint compatibility](#pylint-compatibility)
      - [Explicit type annotations](#explicit-type-annotations)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)
    - [Submodules](#submodules)

  <a id="how-to-install"></a>



  <a id="generate-locally-(recommended)"></a>



  You can generate type annotations for `boto3` package locally with
  `mypy_boto3_builder`. Use
  [uv](https://docs.astral.sh/uv/getting-started/installation/) for build
  isolation.

  1. Run mypy-boto3-builder in your package root directory:
     `uvx --with 'boto3==1.35.81' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Select services you use in the current project.
  4. Use provided commands to install generated packages.

  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Auto-discover services` and select services you use in the current
  project.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` to add type checking for `boto3` package.

  ```bash

  python -m pip install boto3-stubs



  python -m pip install 'boto3-stubs[essential]'


  python -m pip install 'boto3-stubs[acm,apigateway]'


  python -m pip install 'boto3-stubs[boto3]'


  python -m pip install 'boto3-stubs[full]'



  python -m pip install 'boto3-stubs-lite[essential]'
  ```

  <a id="from-conda-forge"></a>



  Add `conda-forge` to your channels with:

  ```bash
  conda config --add channels conda-forge
  conda config --set channel_priority strict
  ```

  Once the `conda-forge` channel has been enabled, `boto3-stubs` and
  `boto3-stubs-essential` can be installed with:

  ```bash
  conda install boto3-stubs boto3-stubs-essential
  ```

  List all available versions of `boto3-stubs` available on your platform with:

  ```bash
  conda search boto3-stubs --channel conda-forge
  ```

  <a id="how-to-uninstall"></a>



  ```bash

  python -m pip uninstall -y boto3-stubs
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `boto3-stubs[essential]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[essential]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  > ⚠️ Due to slow PyCharm performance on `Literal` overloads (issue
  > [PY-40997](https://youtrack.jetbrains.com/issue/PY-40997)), it is recommended
  > to use [boto3-stubs-lite](https://pypi.org/project/boto3-stubs-lite/) until
  > the issue is resolved.

  > ⚠️ If you experience slow performance and high CPU usage, try to disable
  > `PyCharm` type checker and use [mypy](https://github.com/python/mypy) or
  > [pyright](https://github.com/microsoft/pyright) instead.

  > ⚠️ To continue using `PyCharm` type checker, you can try to replace
  > `boto3-stubs` with
  > [boto3-stubs-lite](https://pypi.org/project/boto3-stubs-lite/):

  ```bash
  pip uninstall boto3-stubs
  pip install boto3-stubs-lite
  ```

  Install `boto3-stubs[essential]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[essential]'
  ```

  Both type checking and code completion should now work.

  <a id="emacs"></a>



  - Install `boto3-stubs` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[essential]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `boto3-stubs`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `boto3-stubs[essential]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[essential]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `boto3-stubs[essential]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[essential]'
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `boto3-stubs[essential]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[essential]'
  ```

  Optionally, you can install `boto3-stubs` to `typings` directory.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pylint-compatibility"></a>



  It is totally safe to use `TYPE_CHECKING` flag in order to avoid `boto3-stubs`
  dependency in production. However, there is an issue in `pylint` that it
  complains about undefined variables. To fix it, set all types to `object` in
  non-`TYPE_CHECKING` mode.

  ```python
  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      from mypy_boto3_ec2 import EC2Client, EC2ServiceResource
      from mypy_boto3_ec2.waiters import BundleTaskCompleteWaiter
      from mypy_boto3_ec2.paginators import DescribeVolumesPaginator
  else:
      EC2Client = object
      EC2ServiceResource = object
      BundleTaskCompleteWaiter = object
      DescribeVolumesPaginator = object

  ...
  ```

  <a id="explicit-type-annotations"></a>



  To speed up type checking and code completion, you can set types explicitly.

  ```python
  import boto3
  from boto3.session import Session

  from mypy_boto3_ec2.client import EC2Client
  from mypy_boto3_ec2.service_resource import EC2ServiceResource
  from mypy_boto3_ec2.waiter import BundleTaskCompleteWaiter
  from mypy_boto3_ec2.paginator import DescribeVolumesPaginator

  session = Session(region_name="us-west-1")

  ec2_client: EC2Client = boto3.client("ec2", region_name="us-west-1")
  ec2_resource: EC2ServiceResource = session.resource("ec2")

  bundle_task_complete_waiter: BundleTaskCompleteWaiter = ec2_client.get_waiter(
      "bundle_task_complete"
  )
  describe_volumes_paginator: DescribeVolumesPaginator = ec2_client.get_paginator("describe_volumes")
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from `botocore` schemas.
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [ruff](https://docs.astral.sh/ruff/) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore`, `aiobotocore` and `aioboto3`
    libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.resource` calls
  - Auto discovery of types for `session.client` and `session.resource` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `boto3-stubs` version is the same as related `boto3` version and follows
  [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/boto3_stubs_docs/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.

  <a id="submodules"></a>



  - `boto3-stubs[full]` - Type annotations for all 404 services in one package
    (recommended).
  - `boto3-stubs[all]` - Type annotations for all 404 services in separate
    packages.
  - `boto3-stubs[essential]` - Type annotations for
    [CloudFormation](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudformation/),
    [DynamoDB](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_dynamodb/),
    [EC2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ec2/),
    [Lambda](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lambda/),
    [RDS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_rds/),
    [S3](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_s3/) and
    [SQS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sqs/) services.
  - `boto3-stubs[boto3]` - Install annotations in sync with `boto3` version.
  - `boto3-stubs[accessanalyzer]` - Type annotations for
    [AccessAnalyzer](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_accessanalyzer/)
    service.
  - `boto3-stubs[account]` - Type annotations for
    [Account](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_account/)
    service.
  - `boto3-stubs[acm]` - Type annotations for
    [ACM](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_acm/) service.
  - `boto3-stubs[acm-pca]` - Type annotations for
    [ACMPCA](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_acm_pca/)
    service.
  - `boto3-stubs[amp]` - Type annotations for
    [PrometheusService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amp/)
    service.
  - `boto3-stubs[amplify]` - Type annotations for
    [Amplify](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amplify/)
    service.
  - `boto3-stubs[amplifybackend]` - Type annotations for
    [AmplifyBackend](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amplifybackend/)
    service.
  - `boto3-stubs[amplifyuibuilder]` - Type annotations for
    [AmplifyUIBuilder](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amplifyuibuilder/)
    service.
  - `boto3-stubs[apigateway]` - Type annotations for
    [APIGateway](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_apigateway/)
    service.
  - `boto3-stubs[apigatewaymanagementapi]` - Type annotations for
    [ApiGatewayManagementApi](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_apigatewaymanagementapi/)
    service.
  - `boto3-stubs[apigatewayv2]` - Type annotations for
    [ApiGatewayV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_apigatewayv2/)
    service.
  - `boto3-stubs[appconfig]` - Type annotations for
    [AppConfig](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appconfig/)
    service.
  - `boto3-stubs[appconfigdata]` - Type annotations for
    [AppConfigData](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appconfigdata/)
    service.
  - `boto3-stubs[appfabric]` - Type annotations for
    [AppFabric](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appfabric/)
    service.
  - `boto3-stubs[appflow]` - Type annotations for
    [Appflow](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appflow/)
    service.
  - `boto3-stubs[appintegrations]` - Type annotations for
    [AppIntegrationsService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appintegrations/)
    service.
  - `boto3-stubs[application-autoscaling]` - Type annotations for
    [ApplicationAutoScaling](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_application_autoscaling/)
    service.
  - `boto3-stubs[application-insights]` - Type annotations for
    [ApplicationInsights](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_application_insights/)
    service.
  - `boto3-stubs[application-signals]` - Type annotations for
    [CloudWatchApplicationSignals](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_application_signals/)
    service.
  - `boto3-stubs[applicationcostprofiler]` - Type annotations for
    [ApplicationCostProfiler](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_applicationcostprofiler/)
    service.
  - `boto3-stubs[appmesh]` - Type annotations for
    [AppMesh](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appmesh/)
    service.
  - `boto3-stubs[apprunner]` - Type annotations for
    [AppRunner](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_apprunner/)
    service.
  - `boto3-stubs[appstream]` - Type annotations for
    [AppStream](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appstream/)
    service.
  - `boto3-stubs[appsync]` - Type annotations for
    [AppSync](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appsync/)
    service.
  - `boto3-stubs[apptest]` - Type annotations for
    [MainframeModernizationApplicationTesting](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_apptest/)
    service.
  - `boto3-stubs[arc-zonal-shift]` - Type annotations for
    [ARCZonalShift](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_arc_zonal_shift/)
    service.
  - `boto3-stubs[artifact]` - Type annotations for
    [Artifact](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_artifact/)
    service.
  - `boto3-stubs[athena]` - Type annotations for
    [Athena](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_athena/)
    service.
  - `boto3-stubs[auditmanager]` - Type annotations for
    [AuditManager](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_auditmanager/)
    service.
  - `boto3-stubs[autoscaling]` - Type annotations for
    [AutoScaling](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_autoscaling/)
    service.
  - `boto3-stubs[autoscaling-plans]` - Type annotations for
    [AutoScalingPlans](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_autoscaling_plans/)
    service.
  - `boto3-stubs[b2bi]` - Type annotations for
    [B2BI](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_b2bi/) service.
  - `boto3-stubs[backup]` - Type annotations for
    [Backup](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_backup/)
    service.
  - `boto3-stubs[backup-gateway]` - Type annotations for
    [BackupGateway](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_backup_gateway/)
    service.
  - `boto3-stubs[batch]` - Type annotations for
    [Batch](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_batch/)
    service.
  - `boto3-stubs[bcm-data-exports]` - Type annotations for
    [BillingandCostManagementDataExports](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_bcm_data_exports/)
    service.
  - `boto3-stubs[bcm-pricing-calculator]` - Type annotations for
    [BillingandCostManagementPricingCalculator](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_bcm_pricing_calculator/)
    service.
  - `boto3-stubs[bedrock]` - Type annotations for
    [Bedrock](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_bedrock/)
    service.
  - `boto3-stubs[bedrock-agent]` - Type annotations for
    [AgentsforBedrock](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_bedrock_agent/)
    service.
  - `boto3-stubs[bedrock-agent-runtime]` - Type annotations for
    [AgentsforBedrockRuntime](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_bedrock_agent_runtime/)
    service.
  - `boto3-stubs[bedrock-data-automation]` - Type annotations for
    [DataAutomationforBedrock](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_bedrock_data_automation/)
    service.
  - `boto3-stubs[bedrock-data-automation-runtime]` - Type annotations for
    [RuntimeforBedrockDataAutomation](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_bedrock_data_automation_runtime/)
    service.
  - `boto3-stubs[bedrock-runtime]` - Type annotations for
    [BedrockRuntime](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_bedrock_runtime/)
    service.
  - `boto3-stubs[billing]` - Type annotations for
    [Billing](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_billing/)
    service.
  - `boto3-stubs[billingconductor]` - Type annotations for
    [BillingConductor](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_billingconductor/)
    service.
  - `boto3-stubs[braket]` - Type annotations for
    [Braket](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_braket/)
    service.
  - `boto3-stubs[budgets]` - Type annotations for
    [Budgets](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_budgets/)
    service.
  - `boto3-stubs[ce]` - Type annotations for
    [CostExplorer](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ce/)
    service.
  - `boto3-stubs[chatbot]` - Type annotations for
    [Chatbot](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_chatbot/)
    service.
  - `boto3-stubs[chime]` - Type annotations for
    [Chime](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_chime/)
    service.
  - `boto3-stubs[chime-sdk-identity]` - Type annotations for
    [ChimeSDKIdentity](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_chime_sdk_identity/)
    service.
  - `boto3-stubs[chime-sdk-media-pipelines]` - Type annotations for
    [ChimeSDKMediaPipelines](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_chime_sdk_media_pipelines/)
    service.
  - `boto3-stubs[chime-sdk-meetings]` - Type annotations for
    [ChimeSDKMeetings](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_chime_sdk_meetings/)
    service.
  - `boto3-stubs[chime-sdk-messaging]` - Type annotations for
    [ChimeSDKMessaging](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_chime_sdk_messaging/)
    service.
  - `boto3-stubs[chime-sdk-voice]` - Type annotations for
    [ChimeSDKVoice](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_chime_sdk_voice/)
    service.
  - `boto3-stubs[cleanrooms]` - Type annotations for
    [CleanRoomsService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cleanrooms/)
    service.
  - `boto3-stubs[cleanroomsml]` - Type annotations for
    [CleanRoomsML](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cleanroomsml/)
    service.
  - `boto3-stubs[cloud9]` - Type annotations for
    [Cloud9](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloud9/)
    service.
  - `boto3-stubs[cloudcontrol]` - Type annotations for
    [CloudControlApi](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudcontrol/)
    service.
  - `boto3-stubs[clouddirectory]` - Type annotations for
    [CloudDirectory](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_clouddirectory/)
    service.
  - `boto3-stubs[cloudformation]` - Type annotations for
    [CloudFormation](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudformation/)
    service.
  - `boto3-stubs[cloudfront]` - Type annotations for
    [CloudFront](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudfront/)
    service.
  - `boto3-stubs[cloudfront-keyvaluestore]` - Type annotations for
    [CloudFrontKeyValueStore](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudfront_keyvaluestore/)
    service.
  - `boto3-stubs[cloudhsm]` - Type annotations for
    [CloudHSM](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudhsm/)
    service.
  - `boto3-stubs[cloudhsmv2]` - Type annotations for
    [CloudHSMV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudhsmv2/)
    service.
  - `boto3-stubs[cloudsearch]` - Type annotations for
    [CloudSearch](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudsearch/)
    service.
  - `boto3-stubs[cloudsearchdomain]` - Type annotations for
    [CloudSearchDomain](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudsearchdomain/)
    service.
  - `boto3-stubs[cloudtrail]` - Type annotations for
    [CloudTrail](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudtrail/)
    service.
  - `boto3-stubs[cloudtrail-data]` - Type annotations for
    [CloudTrailDataService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudtrail_data/)
    service.
  - `boto3-stubs[cloudwatch]` - Type annotations for
    [CloudWatch](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudwatch/)
    service.
  - `boto3-stubs[codeartifact]` - Type annotations for
    [CodeArtifact](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codeartifact/)
    service.
  - `boto3-stubs[codebuild]` - Type annotations for
    [CodeBuild](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codebuild/)
    service.
  - `boto3-stubs[codecatalyst]` - Type annotations for
    [CodeCatalyst](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codecatalyst/)
    service.
  - `boto3-stubs[codecommit]` - Type annotations for
    [CodeCommit](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codecommit/)
    service.
  - `boto3-stubs[codeconnections]` - Type annotations for
    [CodeConnections](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codeconnections/)
    service.
  - `boto3-stubs[codedeploy]` - Type annotations for
    [CodeDeploy](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codedeploy/)
    service.
  - `boto3-stubs[codeguru-reviewer]` - Type annotations for
    [CodeGuruReviewer](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codeguru_reviewer/)
    service.
  - `boto3-stubs[codeguru-security]` - Type annotations for
    [CodeGuruSecurity](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codeguru_security/)
    service.
  - `boto3-stubs[codeguruprofiler]` - Type annotations for
    [CodeGuruProfiler](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codeguruprofiler/)
    service.
  - `boto3-stubs[codepipeline]` - Type annotations for
    [CodePipeline](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codepipeline/)
    service.
  - `boto3-stubs[codestar-connections]` - Type annotations for
    [CodeStarconnections](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codestar_connections/)
    service.
  - `boto3-stubs[codestar-notifications]` - Type annotations for
    [CodeStarNotifications](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codestar_notifications/)
    service.
  - `boto3-stubs[cognito-identity]` - Type annotations for
    [CognitoIdentity](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cognito_identity/)
    service.
  - `boto3-stubs[cognito-idp]` - Type annotations for
    [CognitoIdentityProvider](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cognito_idp/)
    service.
  - `boto3-stubs[cognito-sync]` - Type annotations for
    [CognitoSync](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cognito_sync/)
    service.
  - `boto3-stubs[comprehend]` - Type annotations for
    [Comprehend](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_comprehend/)
    service.
  - `boto3-stubs[comprehendmedical]` - Type annotations for
    [ComprehendMedical](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_comprehendmedical/)
    service.
  - `boto3-stubs[compute-optimizer]` - Type annotations for
    [ComputeOptimizer](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_compute_optimizer/)
    service.
  - `boto3-stubs[config]` - Type annotations for
    [ConfigService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_config/)
    service.
  - `boto3-stubs[connect]` - Type annotations for
    [Connect](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connect/)
    service.
  - `boto3-stubs[connect-contact-lens]` - Type annotations for
    [ConnectContactLens](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connect_contact_lens/)
    service.
  - `boto3-stubs[connectcampaigns]` - Type annotations for
    [ConnectCampaignService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connectcampaigns/)
    service.
  - `boto3-stubs[connectcampaignsv2]` - Type annotations for
    [ConnectCampaignServiceV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connectcampaignsv2/)
    service.
  - `boto3-stubs[connectcases]` - Type annotations for
    [ConnectCases](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connectcases/)
    service.
  - `boto3-stubs[connectparticipant]` - Type annotations for
    [ConnectParticipant](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connectparticipant/)
    service.
  - `boto3-stubs[controlcatalog]` - Type annotations for
    [ControlCatalog](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_controlcatalog/)
    service.
  - `boto3-stubs[controltower]` - Type annotations for
    [ControlTower](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_controltower/)
    service.
  - `boto3-stubs[cost-optimization-hub]` - Type annotations for
    [CostOptimizationHub](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cost_optimization_hub/)
    service.
  - `boto3-stubs[cur]` - Type annotations for
    [CostandUsageReportService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cur/)
    service.
  - `boto3-stubs[customer-profiles]` - Type annotations for
    [CustomerProfiles](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_customer_profiles/)
    service.
  - `boto3-stubs[databrew]` - Type annotations for
    [GlueDataBrew](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_databrew/)
    service.
  - `boto3-stubs[dataexchange]` - Type annotations for
    [DataExchange](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_dataexchange/)
    service.
  - `boto3-stubs[datapipeline]` - Type annotations for
    [DataPipeline](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_datapipeline/)
    service.
  - `boto3-stubs[datasync]` - Type annotations for
    [DataSync](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_datasync/)
    service.
  - `boto3-stubs[datazone]` - Type annotations for
    [DataZone](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_datazone/)
    service.
  - `boto3-stubs[dax]` - Type annotations for
    [DAX](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_dax/) service.
  - `boto3-stubs[deadline]` - Type annotations for
    [DeadlineCloud](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_deadline/)
    service.
  - `boto3-stubs[detective]` - Type annotations for
    [Detective](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_detective/)
    service.
  - `boto3-stubs[devicefarm]` - Type annotations for
    [DeviceFarm](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_devicefarm/)
    service.
  - `boto3-stubs[devops-guru]` - Type annotations for
    [DevOpsGuru](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_devops_guru/)
    service.
  - `boto3-stubs[directconnect]` - Type annotations for
    [DirectConnect](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_directconnect/)
    service.
  - `boto3-stubs[discovery]` - Type annotations for
    [ApplicationDiscoveryService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_discovery/)
    service.
  - `boto3-stubs[dlm]` - Type annotations for
    [DLM](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_dlm/) service.
  - `boto3-stubs[dms]` - Type annotations for
    [DatabaseMigrationService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_dms/)
    service.
  - `boto3-stubs[docdb]` - Type annotations for
    [DocDB](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_docdb/)
    service.
  - `boto3-stubs[docdb-elastic]` - Type annotations for
    [DocDBElastic](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_docdb_elastic/)
    service.
  - `boto3-stubs[drs]` - Type annotations for
    [Drs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_drs/) service.
  - `boto3-stubs[ds]` - Type annotations for
    [DirectoryService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ds/)
    service.
  - `boto3-stubs[ds-data]` - Type annotations for
    [DirectoryServiceData](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ds_data/)
    service.
  - `boto3-stubs[dsql]` - Type annotations for
    [AuroraDSQL](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_dsql/)
    service.
  - `boto3-stubs[dynamodb]` - Type annotations for
    [DynamoDB](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_dynamodb/)
    service.
  - `boto3-stubs[dynamodbstreams]` - Type annotations for
    [DynamoDBStreams](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_dynamodbstreams/)
    service.
  - `boto3-stubs[ebs]` - Type annotations for
    [EBS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ebs/) service.
  - `boto3-stubs[ec2]` - Type annotations for
    [EC2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ec2/) service.
  - `boto3-stubs[ec2-instance-connect]` - Type annotations for
    [EC2InstanceConnect](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ec2_instance_connect/)
    service.
  - `boto3-stubs[ecr]` - Type annotations for
    [ECR](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ecr/) service.
  - `boto3-stubs[ecr-public]` - Type annotations for
    [ECRPublic](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ecr_public/)
    service.
  - `boto3-stubs[ecs]` - Type annotations for
    [ECS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ecs/) service.
  - `boto3-stubs[efs]` - Type annotations for
    [EFS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_efs/) service.
  - `boto3-stubs[eks]` - Type annotations for
    [EKS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_eks/) service.
  - `boto3-stubs[eks-auth]` - Type annotations for
    [EKSAuth](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_eks_auth/)
    service.
  - `boto3-stubs[elastic-inference]` - Type annotations for
    [ElasticInference](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_elastic_inference/)
    service.
  - `boto3-stubs[elasticache]` - Type annotations for
    [ElastiCache](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_elasticache/)
    service.
  - `boto3-stubs[elasticbeanstalk]` - Type annotations for
    [ElasticBeanstalk](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_elasticbeanstalk/)
    service.
  - `boto3-stubs[elastictranscoder]` - Type annotations for
    [ElasticTranscoder](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_elastictranscoder/)
    service.
  - `boto3-stubs[elb]` - Type annotations for
    [ElasticLoadBalancing](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_elb/)
    service.
  - `boto3-stubs[elbv2]` - Type annotations for
    [ElasticLoadBalancingv2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_elbv2/)
    service.
  - `boto3-stubs[emr]` - Type annotations for
    [EMR](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_emr/) service.
  - `boto3-stubs[emr-containers]` - Type annotations for
    [EMRContainers](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_emr_containers/)
    service.
  - `boto3-stubs[emr-serverless]` - Type annotations for
    [EMRServerless](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_emr_serverless/)
    service.
  - `boto3-stubs[entityresolution]` - Type annotations for
    [EntityResolution](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_entityresolution/)
    service.
  - `boto3-stubs[es]` - Type annotations for
    [ElasticsearchService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_es/)
    service.
  - `boto3-stubs[events]` - Type annotations for
    [EventBridge](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_events/)
    service.
  - `boto3-stubs[evidently]` - Type annotations for
    [CloudWatchEvidently](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_evidently/)
    service.
  - `boto3-stubs[finspace]` - Type annotations for
    [Finspace](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_finspace/)
    service.
  - `boto3-stubs[finspace-data]` - Type annotations for
    [FinSpaceData](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_finspace_data/)
    service.
  - `boto3-stubs[firehose]` - Type annotations for
    [Firehose](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_firehose/)
    service.
  - `boto3-stubs[fis]` - Type annotations for
    [FIS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_fis/) service.
  - `boto3-stubs[fms]` - Type annotations for
    [FMS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_fms/) service.
  - `boto3-stubs[forecast]` - Type annotations for
    [ForecastService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_forecast/)
    service.
  - `boto3-stubs[forecastquery]` - Type annotations for
    [ForecastQueryService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_forecastquery/)
    service.
  - `boto3-stubs[frauddetector]` - Type annotations for
    [FraudDetector](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_frauddetector/)
    service.
  - `boto3-stubs[freetier]` - Type annotations for
    [FreeTier](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_freetier/)
    service.
  - `boto3-stubs[fsx]` - Type annotations for
    [FSx](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_fsx/) service.
  - `boto3-stubs[gamelift]` - Type annotations for
    [GameLift](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_gamelift/)
    service.
  - `boto3-stubs[geo-maps]` - Type annotations for
    [LocationServiceMapsV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_geo_maps/)
    service.
  - `boto3-stubs[geo-places]` - Type annotations for
    [LocationServicePlacesV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_geo_places/)
    service.
  - `boto3-stubs[geo-routes]` - Type annotations for
    [LocationServiceRoutesV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_geo_routes/)
    service.
  - `boto3-stubs[glacier]` - Type annotations for
    [Glacier](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_glacier/)
    service.
  - `boto3-stubs[globalaccelerator]` - Type annotations for
    [GlobalAccelerator](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_globalaccelerator/)
    service.
  - `boto3-stubs[glue]` - Type annotations for
    [Glue](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_glue/) service.
  - `boto3-stubs[grafana]` - Type annotations for
    [ManagedGrafana](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_grafana/)
    service.
  - `boto3-stubs[greengrass]` - Type annotations for
    [Greengrass](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_greengrass/)
    service.
  - `boto3-stubs[greengrassv2]` - Type annotations for
    [GreengrassV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_greengrassv2/)
    service.
  - `boto3-stubs[groundstation]` - Type annotations for
    [GroundStation](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_groundstation/)
    service.
  - `boto3-stubs[guardduty]` - Type annotations for
    [GuardDuty](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_guardduty/)
    service.
  - `boto3-stubs[health]` - Type annotations for
    [Health](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_health/)
    service.
  - `boto3-stubs[healthlake]` - Type annotations for
    [HealthLake](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_healthlake/)
    service.
  - `boto3-stubs[iam]` - Type annotations for
    [IAM](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iam/) service.
  - `boto3-stubs[identitystore]` - Type annotations for
    [IdentityStore](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_identitystore/)
    service.
  - `boto3-stubs[imagebuilder]` - Type annotations for
    [Imagebuilder](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_imagebuilder/)
    service.
  - `boto3-stubs[importexport]` - Type annotations for
    [ImportExport](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_importexport/)
    service.
  - `boto3-stubs[inspector]` - Type annotations for
    [Inspector](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_inspector/)
    service.
  - `boto3-stubs[inspector-scan]` - Type annotations for
    [Inspectorscan](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_inspector_scan/)
    service.
  - `boto3-stubs[inspector2]` - Type annotations for
    [Inspector2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_inspector2/)
    service.
  - `boto3-stubs[internetmonitor]` - Type annotations for
    [CloudWatchInternetMonitor](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_internetmonitor/)
    service.
  - `boto3-stubs[invoicing]` - Type annotations for
    [Invoicing](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_invoicing/)
    service.
  - `boto3-stubs[iot]` - Type annotations for
    [IoT](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iot/) service.
  - `boto3-stubs[iot-data]` - Type annotations for
    [IoTDataPlane](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iot_data/)
    service.
  - `boto3-stubs[iot-jobs-data]` - Type annotations for
    [IoTJobsDataPlane](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iot_jobs_data/)
    service.
  - `boto3-stubs[iot1click-devices]` - Type annotations for
    [IoT1ClickDevicesService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iot1click_devices/)
    service.
  - `boto3-stubs[iot1click-projects]` - Type annotations for
    [IoT1ClickProjects](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iot1click_projects/)
    service.
  - `boto3-stubs[iotanalytics]` - Type annotations for
    [IoTAnalytics](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotanalytics/)
    service.
  - `boto3-stubs[iotdeviceadvisor]` - Type annotations for
    [IoTDeviceAdvisor](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotdeviceadvisor/)
    service.
  - `boto3-stubs[iotevents]` - Type annotations for
    [IoTEvents](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotevents/)
    service.
  - `boto3-stubs[iotevents-data]` - Type annotations for
    [IoTEventsData](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotevents_data/)
    service.
  - `boto3-stubs[iotfleethub]` - Type annotations for
    [IoTFleetHub](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotfleethub/)
    service.
  - `boto3-stubs[iotfleetwise]` - Type annotations for
    [IoTFleetWise](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotfleetwise/)
    service.
  - `boto3-stubs[iotsecuretunneling]` - Type annotations for
    [IoTSecureTunneling](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotsecuretunneling/)
    service.
  - `boto3-stubs[iotsitewise]` - Type annotations for
    [IoTSiteWise](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotsitewise/)
    service.
  - `boto3-stubs[iotthingsgraph]` - Type annotations for
    [IoTThingsGraph](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotthingsgraph/)
    service.
  - `boto3-stubs[iottwinmaker]` - Type annotations for
    [IoTTwinMaker](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iottwinmaker/)
    service.
  - `boto3-stubs[iotwireless]` - Type annotations for
    [IoTWireless](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_iotwireless/)
    service.
  - `boto3-stubs[ivs]` - Type annotations for
    [IVS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ivs/) service.
  - `boto3-stubs[ivs-realtime]` - Type annotations for
    [Ivsrealtime](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ivs_realtime/)
    service.
  - `boto3-stubs[ivschat]` - Type annotations for
    [Ivschat](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ivschat/)
    service.
  - `boto3-stubs[kafka]` - Type annotations for
    [Kafka](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kafka/)
    service.
  - `boto3-stubs[kafkaconnect]` - Type annotations for
    [KafkaConnect](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kafkaconnect/)
    service.
  - `boto3-stubs[kendra]` - Type annotations for
    [Kendra](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kendra/)
    service.
  - `boto3-stubs[kendra-ranking]` - Type annotations for
    [KendraRanking](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kendra_ranking/)
    service.
  - `boto3-stubs[keyspaces]` - Type annotations for
    [Keyspaces](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_keyspaces/)
    service.
  - `boto3-stubs[kinesis]` - Type annotations for
    [Kinesis](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kinesis/)
    service.
  - `boto3-stubs[kinesis-video-archived-media]` - Type annotations for
    [KinesisVideoArchivedMedia](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kinesis_video_archived_media/)
    service.
  - `boto3-stubs[kinesis-video-media]` - Type annotations for
    [KinesisVideoMedia](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kinesis_video_media/)
    service.
  - `boto3-stubs[kinesis-video-signaling]` - Type annotations for
    [KinesisVideoSignalingChannels](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kinesis_video_signaling/)
    service.
  - `boto3-stubs[kinesis-video-webrtc-storage]` - Type annotations for
    [KinesisVideoWebRTCStorage](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kinesis_video_webrtc_storage/)
    service.
  - `boto3-stubs[kinesisanalytics]` - Type annotations for
    [KinesisAnalytics](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kinesisanalytics/)
    service.
  - `boto3-stubs[kinesisanalyticsv2]` - Type annotations for
    [KinesisAnalyticsV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kinesisanalyticsv2/)
    service.
  - `boto3-stubs[kinesisvideo]` - Type annotations for
    [KinesisVideo](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kinesisvideo/)
    service.
  - `boto3-stubs[kms]` - Type annotations for
    [KMS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_kms/) service.
  - `boto3-stubs[lakeformation]` - Type annotations for
    [LakeFormation](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lakeformation/)
    service.
  - `boto3-stubs[lambda]` - Type annotations for
    [Lambda](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lambda/)
    service.
  - `boto3-stubs[launch-wizard]` - Type annotations for
    [LaunchWizard](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_launch_wizard/)
    service.
  - `boto3-stubs[lex-models]` - Type annotations for
    [LexModelBuildingService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lex_models/)
    service.
  - `boto3-stubs[lex-runtime]` - Type annotations for
    [LexRuntimeService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lex_runtime/)
    service.
  - `boto3-stubs[lexv2-models]` - Type annotations for
    [LexModelsV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lexv2_models/)
    service.
  - `boto3-stubs[lexv2-runtime]` - Type annotations for
    [LexRuntimeV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lexv2_runtime/)
    service.
  - `boto3-stubs[license-manager]` - Type annotations for
    [LicenseManager](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_license_manager/)
    service.
  - `boto3-stubs[license-manager-linux-subscriptions]` - Type annotations for
    [LicenseManagerLinuxSubscriptions](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_license_manager_linux_subscriptions/)
    service.
  - `boto3-stubs[license-manager-user-subscriptions]` - Type annotations for
    [LicenseManagerUserSubscriptions](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_license_manager_user_subscriptions/)
    service.
  - `boto3-stubs[lightsail]` - Type annotations for
    [Lightsail](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lightsail/)
    service.
  - `boto3-stubs[location]` - Type annotations for
    [LocationService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_location/)
    service.
  - `boto3-stubs[logs]` - Type annotations for
    [CloudWatchLogs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_logs/)
    service.
  - `boto3-stubs[lookoutequipment]` - Type annotations for
    [LookoutEquipment](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lookoutequipment/)
    service.
  - `boto3-stubs[lookoutmetrics]` - Type annotations for
    [LookoutMetrics](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lookoutmetrics/)
    service.
  - `boto3-stubs[lookoutvision]` - Type annotations for
    [LookoutforVision](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_lookoutvision/)
    service.
  - `boto3-stubs[m2]` - Type annotations for
    [MainframeModernization](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_m2/)
    service.
  - `boto3-stubs[machinelearning]` - Type annotations for
    [MachineLearning](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_machinelearning/)
    service.
  - `boto3-stubs[macie2]` - Type annotations for
    [Macie2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_macie2/)
    service.
  - `boto3-stubs[mailmanager]` - Type annotations for
    [MailManager](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mailmanager/)
    service.
  - `boto3-stubs[managedblockchain]` - Type annotations for
    [ManagedBlockchain](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_managedblockchain/)
    service.
  - `boto3-stubs[managedblockchain-query]` - Type annotations for
    [ManagedBlockchainQuery](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_managedblockchain_query/)
    service.
  - `boto3-stubs[marketplace-agreement]` - Type annotations for
    [AgreementService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_marketplace_agreement/)
    service.
  - `boto3-stubs[marketplace-catalog]` - Type annotations for
    [MarketplaceCatalog](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_marketplace_catalog/)
    service.
  - `boto3-stubs[marketplace-deployment]` - Type annotations for
    [MarketplaceDeploymentService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_marketplace_deployment/)
    service.
  - `boto3-stubs[marketplace-entitlement]` - Type annotations for
    [MarketplaceEntitlementService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_marketplace_entitlement/)
    service.
  - `boto3-stubs[marketplace-reporting]` - Type annotations for
    [MarketplaceReportingService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_marketplace_reporting/)
    service.
  - `boto3-stubs[marketplacecommerceanalytics]` - Type annotations for
    [MarketplaceCommerceAnalytics](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_marketplacecommerceanalytics/)
    service.
  - `boto3-stubs[mediaconnect]` - Type annotations for
    [MediaConnect](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mediaconnect/)
    service.
  - `boto3-stubs[mediaconvert]` - Type annotations for
    [MediaConvert](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mediaconvert/)
    service.
  - `boto3-stubs[medialive]` - Type annotations for
    [MediaLive](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_medialive/)
    service.
  - `boto3-stubs[mediapackage]` - Type annotations for
    [MediaPackage](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mediapackage/)
    service.
  - `boto3-stubs[mediapackage-vod]` - Type annotations for
    [MediaPackageVod](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mediapackage_vod/)
    service.
  - `boto3-stubs[mediapackagev2]` - Type annotations for
    [Mediapackagev2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mediapackagev2/)
    service.
  - `boto3-stubs[mediastore]` - Type annotations for
    [MediaStore](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mediastore/)
    service.
  - `boto3-stubs[mediastore-data]` - Type annotations for
    [MediaStoreData](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mediastore_data/)
    service.
  - `boto3-stubs[mediatailor]` - Type annotations for
    [MediaTailor](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mediatailor/)
    service.
  - `boto3-stubs[medical-imaging]` - Type annotations for
    [HealthImaging](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_medical_imaging/)
    service.
  - `boto3-stubs[memorydb]` - Type annotations for
    [MemoryDB](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_memorydb/)
    service.
  - `boto3-stubs[meteringmarketplace]` - Type annotations for
    [MarketplaceMetering](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_meteringmarketplace/)
    service.
  - `boto3-stubs[mgh]` - Type annotations for
    [MigrationHub](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mgh/)
    service.
  - `boto3-stubs[mgn]` - Type annotations for
    [Mgn](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mgn/) service.
  - `boto3-stubs[migration-hub-refactor-spaces]` - Type annotations for
    [MigrationHubRefactorSpaces](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_migration_hub_refactor_spaces/)
    service.
  - `boto3-stubs[migrationhub-config]` - Type annotations for
    [MigrationHubConfig](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_migrationhub_config/)
    service.
  - `boto3-stubs[migrationhuborchestrator]` - Type annotations for
    [MigrationHubOrchestrator](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_migrationhuborchestrator/)
    service.
  - `boto3-stubs[migrationhubstrategy]` - Type annotations for
    [MigrationHubStrategyRecommendations](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_migrationhubstrategy/)
    service.
  - `boto3-stubs[mq]` - Type annotations for
    [MQ](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mq/) service.
  - `boto3-stubs[mturk]` - Type annotations for
    [MTurk](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mturk/)
    service.
  - `boto3-stubs[mwaa]` - Type annotations for
    [MWAA](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_mwaa/) service.
  - `boto3-stubs[neptune]` - Type annotations for
    [Neptune](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_neptune/)
    service.
  - `boto3-stubs[neptune-graph]` - Type annotations for
    [NeptuneGraph](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_neptune_graph/)
    service.
  - `boto3-stubs[neptunedata]` - Type annotations for
    [NeptuneData](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_neptunedata/)
    service.
  - `boto3-stubs[network-firewall]` - Type annotations for
    [NetworkFirewall](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_network_firewall/)
    service.
  - `boto3-stubs[networkflowmonitor]` - Type annotations for
    [NetworkFlowMonitor](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_networkflowmonitor/)
    service.
  - `boto3-stubs[networkmanager]` - Type annotations for
    [NetworkManager](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_networkmanager/)
    service.
  - `boto3-stubs[networkmonitor]` - Type annotations for
    [CloudWatchNetworkMonitor](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_networkmonitor/)
    service.
  - `boto3-stubs[notifications]` - Type annotations for
    [UserNotifications](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_notifications/)
    service.
  - `boto3-stubs[notificationscontacts]` - Type annotations for
    [UserNotificationsContacts](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_notificationscontacts/)
    service.
  - `boto3-stubs[oam]` - Type annotations for
    [CloudWatchObservabilityAccessManager](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_oam/)
    service.
  - `boto3-stubs[observabilityadmin]` - Type annotations for
    [CloudWatchObservabilityAdminService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_observabilityadmin/)
    service.
  - `boto3-stubs[omics]` - Type annotations for
    [Omics](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_omics/)
    service.
  - `boto3-stubs[opensearch]` - Type annotations for
    [OpenSearchService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_opensearch/)
    service.
  - `boto3-stubs[opensearchserverless]` - Type annotations for
    [OpenSearchServiceServerless](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_opensearchserverless/)
    service.
  - `boto3-stubs[opsworks]` - Type annotations for
    [OpsWorks](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_opsworks/)
    service.
  - `boto3-stubs[opsworkscm]` - Type annotations for
    [OpsWorksCM](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_opsworkscm/)
    service.
  - `boto3-stubs[organizations]` - Type annotations for
    [Organizations](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_organizations/)
    service.
  - `boto3-stubs[osis]` - Type annotations for
    [OpenSearchIngestion](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_osis/)
    service.
  - `boto3-stubs[outposts]` - Type annotations for
    [Outposts](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_outposts/)
    service.
  - `boto3-stubs[panorama]` - Type annotations for
    [Panorama](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_panorama/)
    service.
  - `boto3-stubs[partnercentral-selling]` - Type annotations for
    [PartnerCentralSellingAPI](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_partnercentral_selling/)
    service.
  - `boto3-stubs[payment-cryptography]` - Type annotations for
    [PaymentCryptographyControlPlane](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_payment_cryptography/)
    service.
  - `boto3-stubs[payment-cryptography-data]` - Type annotations for
    [PaymentCryptographyDataPlane](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_payment_cryptography_data/)
    service.
  - `boto3-stubs[pca-connector-ad]` - Type annotations for
    [PcaConnectorAd](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pca_connector_ad/)
    service.
  - `boto3-stubs[pca-connector-scep]` - Type annotations for
    [PrivateCAConnectorforSCEP](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pca_connector_scep/)
    service.
  - `boto3-stubs[pcs]` - Type annotations for
    [ParallelComputingService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pcs/)
    service.
  - `boto3-stubs[personalize]` - Type annotations for
    [Personalize](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_personalize/)
    service.
  - `boto3-stubs[personalize-events]` - Type annotations for
    [PersonalizeEvents](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_personalize_events/)
    service.
  - `boto3-stubs[personalize-runtime]` - Type annotations for
    [PersonalizeRuntime](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_personalize_runtime/)
    service.
  - `boto3-stubs[pi]` - Type annotations for
    [PI](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pi/) service.
  - `boto3-stubs[pinpoint]` - Type annotations for
    [Pinpoint](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pinpoint/)
    service.
  - `boto3-stubs[pinpoint-email]` - Type annotations for
    [PinpointEmail](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pinpoint_email/)
    service.
  - `boto3-stubs[pinpoint-sms-voice]` - Type annotations for
    [PinpointSMSVoice](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pinpoint_sms_voice/)
    service.
  - `boto3-stubs[pinpoint-sms-voice-v2]` - Type annotations for
    [PinpointSMSVoiceV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pinpoint_sms_voice_v2/)
    service.
  - `boto3-stubs[pipes]` - Type annotations for
    [EventBridgePipes](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pipes/)
    service.
  - `boto3-stubs[polly]` - Type annotations for
    [Polly](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_polly/)
    service.
  - `boto3-stubs[pricing]` - Type annotations for
    [Pricing](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_pricing/)
    service.
  - `boto3-stubs[privatenetworks]` - Type annotations for
    [Private5G](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_privatenetworks/)
    service.
  - `boto3-stubs[proton]` - Type annotations for
    [Proton](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_proton/)
    service.
  - `boto3-stubs[qapps]` - Type annotations for
    [QApps](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_qapps/)
    service.
  - `boto3-stubs[qbusiness]` - Type annotations for
    [QBusiness](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_qbusiness/)
    service.
  - `boto3-stubs[qconnect]` - Type annotations for
    [QConnect](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_qconnect/)
    service.
  - `boto3-stubs[qldb]` - Type annotations for
    [QLDB](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_qldb/) service.
  - `boto3-stubs[qldb-session]` - Type annotations for
    [QLDBSession](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_qldb_session/)
    service.
  - `boto3-stubs[quicksight]` - Type annotations for
    [QuickSight](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_quicksight/)
    service.
  - `boto3-stubs[ram]` - Type annotations for
    [RAM](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ram/) service.
  - `boto3-stubs[rbin]` - Type annotations for
    [RecycleBin](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_rbin/)
    service.
  - `boto3-stubs[rds]` - Type annotations for
    [RDS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_rds/) service.
  - `boto3-stubs[rds-data]` - Type annotations for
    [RDSDataService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_rds_data/)
    service.
  - `boto3-stubs[redshift]` - Type annotations for
    [Redshift](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_redshift/)
    service.
  - `boto3-stubs[redshift-data]` - Type annotations for
    [RedshiftDataAPIService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_redshift_data/)
    service.
  - `boto3-stubs[redshift-serverless]` - Type annotations for
    [RedshiftServerless](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_redshift_serverless/)
    service.
  - `boto3-stubs[rekognition]` - Type annotations for
    [Rekognition](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_rekognition/)
    service.
  - `boto3-stubs[repostspace]` - Type annotations for
    [RePostPrivate](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_repostspace/)
    service.
  - `boto3-stubs[resiliencehub]` - Type annotations for
    [ResilienceHub](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_resiliencehub/)
    service.
  - `boto3-stubs[resource-explorer-2]` - Type annotations for
    [ResourceExplorer](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_resource_explorer_2/)
    service.
  - `boto3-stubs[resource-groups]` - Type annotations for
    [ResourceGroups](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_resource_groups/)
    service.
  - `boto3-stubs[resourcegroupstaggingapi]` - Type annotations for
    [ResourceGroupsTaggingAPI](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_resourcegroupstaggingapi/)
    service.
  - `boto3-stubs[robomaker]` - Type annotations for
    [RoboMaker](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_robomaker/)
    service.
  - `boto3-stubs[rolesanywhere]` - Type annotations for
    [IAMRolesAnywhere](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_rolesanywhere/)
    service.
  - `boto3-stubs[route53]` - Type annotations for
    [Route53](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_route53/)
    service.
  - `boto3-stubs[route53-recovery-cluster]` - Type annotations for
    [Route53RecoveryCluster](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_route53_recovery_cluster/)
    service.
  - `boto3-stubs[route53-recovery-control-config]` - Type annotations for
    [Route53RecoveryControlConfig](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_route53_recovery_control_config/)
    service.
  - `boto3-stubs[route53-recovery-readiness]` - Type annotations for
    [Route53RecoveryReadiness](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_route53_recovery_readiness/)
    service.
  - `boto3-stubs[route53domains]` - Type annotations for
    [Route53Domains](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_route53domains/)
    service.
  - `boto3-stubs[route53profiles]` - Type annotations for
    [Route53Profiles](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_route53profiles/)
    service.
  - `boto3-stubs[route53resolver]` - Type annotations for
    [Route53Resolver](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_route53resolver/)
    service.
  - `boto3-stubs[rum]` - Type annotations for
    [CloudWatchRUM](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_rum/)
    service.
  - `boto3-stubs[s3]` - Type annotations for
    [S3](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_s3/) service.
  - `boto3-stubs[s3control]` - Type annotations for
    [S3Control](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_s3control/)
    service.
  - `boto3-stubs[s3outposts]` - Type annotations for
    [S3Outposts](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_s3outposts/)
    service.
  - `boto3-stubs[s3tables]` - Type annotations for
    [S3Tables](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_s3tables/)
    service.
  - `boto3-stubs[sagemaker]` - Type annotations for
    [SageMaker](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sagemaker/)
    service.
  - `boto3-stubs[sagemaker-a2i-runtime]` - Type annotations for
    [AugmentedAIRuntime](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sagemaker_a2i_runtime/)
    service.
  - `boto3-stubs[sagemaker-edge]` - Type annotations for
    [SagemakerEdgeManager](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sagemaker_edge/)
    service.
  - `boto3-stubs[sagemaker-featurestore-runtime]` - Type annotations for
    [SageMakerFeatureStoreRuntime](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sagemaker_featurestore_runtime/)
    service.
  - `boto3-stubs[sagemaker-geospatial]` - Type annotations for
    [SageMakergeospatialcapabilities](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sagemaker_geospatial/)
    service.
  - `boto3-stubs[sagemaker-metrics]` - Type annotations for
    [SageMakerMetrics](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sagemaker_metrics/)
    service.
  - `boto3-stubs[sagemaker-runtime]` - Type annotations for
    [SageMakerRuntime](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sagemaker_runtime/)
    service.
  - `boto3-stubs[savingsplans]` - Type annotations for
    [SavingsPlans](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_savingsplans/)
    service.
  - `boto3-stubs[scheduler]` - Type annotations for
    [EventBridgeScheduler](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_scheduler/)
    service.
  - `boto3-stubs[schemas]` - Type annotations for
    [Schemas](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_schemas/)
    service.
  - `boto3-stubs[sdb]` - Type annotations for
    [SimpleDB](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sdb/)
    service.
  - `boto3-stubs[secretsmanager]` - Type annotations for
    [SecretsManager](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_secretsmanager/)
    service.
  - `boto3-stubs[security-ir]` - Type annotations for
    [SecurityIncidentResponse](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_security_ir/)
    service.
  - `boto3-stubs[securityhub]` - Type annotations for
    [SecurityHub](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_securityhub/)
    service.
  - `boto3-stubs[securitylake]` - Type annotations for
    [SecurityLake](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_securitylake/)
    service.
  - `boto3-stubs[serverlessrepo]` - Type annotations for
    [ServerlessApplicationRepository](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_serverlessrepo/)
    service.
  - `boto3-stubs[service-quotas]` - Type annotations for
    [ServiceQuotas](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_service_quotas/)
    service.
  - `boto3-stubs[servicecatalog]` - Type annotations for
    [ServiceCatalog](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_servicecatalog/)
    service.
  - `boto3-stubs[servicecatalog-appregistry]` - Type annotations for
    [AppRegistry](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_servicecatalog_appregistry/)
    service.
  - `boto3-stubs[servicediscovery]` - Type annotations for
    [ServiceDiscovery](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_servicediscovery/)
    service.
  - `boto3-stubs[ses]` - Type annotations for
    [SES](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ses/) service.
  - `boto3-stubs[sesv2]` - Type annotations for
    [SESV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sesv2/)
    service.
  - `boto3-stubs[shield]` - Type annotations for
    [Shield](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_shield/)
    service.
  - `boto3-stubs[signer]` - Type annotations for
    [Signer](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_signer/)
    service.
  - `boto3-stubs[simspaceweaver]` - Type annotations for
    [SimSpaceWeaver](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_simspaceweaver/)
    service.
  - `boto3-stubs[sms]` - Type annotations for
    [SMS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sms/) service.
  - `boto3-stubs[sms-voice]` - Type annotations for
    [PinpointSMSVoice](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sms_voice/)
    service.
  - `boto3-stubs[snow-device-management]` - Type annotations for
    [SnowDeviceManagement](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_snow_device_management/)
    service.
  - `boto3-stubs[snowball]` - Type annotations for
    [Snowball](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_snowball/)
    service.
  - `boto3-stubs[sns]` - Type annotations for
    [SNS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sns/) service.
  - `boto3-stubs[socialmessaging]` - Type annotations for
    [EndUserMessagingSocial](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_socialmessaging/)
    service.
  - `boto3-stubs[sqs]` - Type annotations for
    [SQS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sqs/) service.
  - `boto3-stubs[ssm]` - Type annotations for
    [SSM](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ssm/) service.
  - `boto3-stubs[ssm-contacts]` - Type annotations for
    [SSMContacts](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ssm_contacts/)
    service.
  - `boto3-stubs[ssm-incidents]` - Type annotations for
    [SSMIncidents](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ssm_incidents/)
    service.
  - `boto3-stubs[ssm-quicksetup]` - Type annotations for
    [SystemsManagerQuickSetup](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ssm_quicksetup/)
    service.
  - `boto3-stubs[ssm-sap]` - Type annotations for
    [SsmSap](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_ssm_sap/)
    service.
  - `boto3-stubs[sso]` - Type annotations for
    [SSO](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sso/) service.
  - `boto3-stubs[sso-admin]` - Type annotations for
    [SSOAdmin](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sso_admin/)
    service.
  - `boto3-stubs[sso-oidc]` - Type annotations for
    [SSOOIDC](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sso_oidc/)
    service.
  - `boto3-stubs[stepfunctions]` - Type annotations for
    [SFN](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_stepfunctions/)
    service.
  - `boto3-stubs[storagegateway]` - Type annotations for
    [StorageGateway](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_storagegateway/)
    service.
  - `boto3-stubs[sts]` - Type annotations for
    [STS](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_sts/) service.
  - `boto3-stubs[supplychain]` - Type annotations for
    [SupplyChain](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_supplychain/)
    service.
  - `boto3-stubs[support]` - Type annotations for
    [Support](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_support/)
    service.
  - `boto3-stubs[support-app]` - Type annotations for
    [SupportApp](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_support_app/)
    service.
  - `boto3-stubs[swf]` - Type annotations for
    [SWF](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_swf/) service.
  - `boto3-stubs[synthetics]` - Type annotations for
    [Synthetics](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_synthetics/)
    service.
  - `boto3-stubs[taxsettings]` - Type annotations for
    [TaxSettings](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_taxsettings/)
    service.
  - `boto3-stubs[textract]` - Type annotations for
    [Textract](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_textract/)
    service.
  - `boto3-stubs[timestream-influxdb]` - Type annotations for
    [TimestreamInfluxDB](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_timestream_influxdb/)
    service.
  - `boto3-stubs[timestream-query]` - Type annotations for
    [TimestreamQuery](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_timestream_query/)
    service.
  - `boto3-stubs[timestream-write]` - Type annotations for
    [TimestreamWrite](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_timestream_write/)
    service.
  - `boto3-stubs[tnb]` - Type annotations for
    [TelcoNetworkBuilder](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_tnb/)
    service.
  - `boto3-stubs[transcribe]` - Type annotations for
    [TranscribeService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_transcribe/)
    service.
  - `boto3-stubs[transfer]` - Type annotations for
    [Transfer](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_transfer/)
    service.
  - `boto3-stubs[translate]` - Type annotations for
    [Translate](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_translate/)
    service.
  - `boto3-stubs[trustedadvisor]` - Type annotations for
    [TrustedAdvisorPublicAPI](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_trustedadvisor/)
    service.
  - `boto3-stubs[verifiedpermissions]` - Type annotations for
    [VerifiedPermissions](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_verifiedpermissions/)
    service.
  - `boto3-stubs[voice-id]` - Type annotations for
    [VoiceID](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_voice_id/)
    service.
  - `boto3-stubs[vpc-lattice]` - Type annotations for
    [VPCLattice](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_vpc_lattice/)
    service.
  - `boto3-stubs[waf]` - Type annotations for
    [WAF](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_waf/) service.
  - `boto3-stubs[waf-regional]` - Type annotations for
    [WAFRegional](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_waf_regional/)
    service.
  - `boto3-stubs[wafv2]` - Type annotations for
    [WAFV2](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_wafv2/)
    service.
  - `boto3-stubs[wellarchitected]` - Type annotations for
    [WellArchitected](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_wellarchitected/)
    service.
  - `boto3-stubs[wisdom]` - Type annotations for
    [ConnectWisdomService](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_wisdom/)
    service.
  - `boto3-stubs[workdocs]` - Type annotations for
    [WorkDocs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_workdocs/)
    service.
  - `boto3-stubs[workmail]` - Type annotations for
    [WorkMail](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_workmail/)
    service.
  - `boto3-stubs[workmailmessageflow]` - Type annotations for
    [WorkMailMessageFlow](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_workmailmessageflow/)
    service.
  - `boto3-stubs[workspaces]` - Type annotations for
    [WorkSpaces](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_workspaces/)
    service.
  - `boto3-stubs[workspaces-thin-client]` - Type annotations for
    [WorkSpacesThinClient](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_workspaces_thin_client/)
    service.
  - `boto3-stubs[workspaces-web]` - Type annotations for
    [WorkSpacesWeb](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_workspaces_web/)
    service.
  - `boto3-stubs[xray]` - Type annotations for
    [XRay](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_xray/) service.


pkgId: e87965b199ea917c9e2ce79eed03cdfdae9e6b483e486a3677cccf58536d9a1e
name: python-botocore-help
arch: noarch
version: 1.35.81
epoch: 0
release: 1
summary: Development documents and examples for botocore
url: https://github.com/boto/botocore
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-botocore-1.35.81-1.src.rpm
location_href: Packages/python-botocore-help-1.35.81-1.noarch.rpm
checksum_type: sha256
description:
  |Version| |Python| |License|
  A low-level interface to a growing number of Amazon Web Services. The
  botocore package is the foundation for the
  `AWS CLI <https://github.com/aws/aws-cli>`__ as well as
  `boto3 <https://github.com/boto/boto3>`__.
  Botocore is maintained and published by `Amazon Web Services`_.


pkgId: 95161d41ccf33537db9e476d55d5b42fc3efa7b7987cad5c566c39e7fb8d022e
name: python-botocore-stubs-help
arch: noarch
version: 1.35.81
epoch: 0
release: 1
summary: Development documents and examples for botocore-stubs
url: https://github.com/youtype/botocore-stubs
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-botocore-stubs-1.35.81-1.src.rpm
location_href: Packages/python-botocore-stubs-help-1.35.81-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - botocore-stubs](https://img.shields.io/pypi/v/botocore-stubs.svg?color=blue&label=botocore-stubs)](https://pypi.org/project/botocore-stubs)
  [![PyPI - botocore](https://img.shields.io/pypi/v/botocore.svg?color=blue&label=botocore)](https://pypi.org/project/botocore)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/botocore-stubs.svg?color=blue)](https://pypi.org/project/botocore-stubs)
  [![PyPI - Downloads](https://static.pepy.tech/badge/botocore-stubs)](https://pypistats.org/packages/botocore-stubs)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations and code completion for [botocore](https://pypi.org/project/botocore/) package.
  This package is a part of [mypy_boto3_builder](https://github.com/youtype/mypy_boto3_builder) project.

  [![Publish botocore-stubs](https://github.com/youtype/botocore-stubs/actions/workflows/publish_on_update.yml/badge.svg)](https://github.com/youtype/botocore-stubs/actions/workflows/publish_on_update.yml)

  - [botocore-stubs](#botocore-stubs)
    - [Installation](#installation)
    - [Usage](#usage)
    - [Versioning](#versioning)
    - [Support and contributing](#support-and-contributing)



  ```bash
  python -m pip install botocore-stubs
  ```



  Use [mypy](https://github.com/python/mypy) or [pyright](https://github.com/microsoft/pyright) for type checking.



  `botocore-stubs` version is the same as related `botocore` version and follows
  [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.



  Please reports any bugs or request new features in
  [botocore-stubs](https://github.com/youtype/botocore-stubs/issues/) repository.

rpm_license:
  MIT License  Copyright (c) 2022 Vlad Emelianov  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: a76e0515c39d03cad9d46c55a92dec7e325072dfa9cb2ad1f0639fb927a0b732
name: python-botrun-flow-lang-help
arch: noarch
version: 4.12.161
epoch: 0
release: 1
summary: Development documents and examples for botrun-flow-lang
url: https://pypi.org/project/botrun-flow-lang/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-botrun-flow-lang-4.12.161-1.src.rpm
location_href: Packages/python-botrun-flow-lang-help-4.12.161-1.noarch.rpm
checksum_type: sha256
description:
  - 用 poetry 管理 python 環境


  ```bash
  poetry export -f requirements.txt --output requirements.txt --without-hashes --without-urls
  ```


  ```bash
  gcloud firestore indexes composite create \
    --collection-group=botrun-hatch-dev-hatch \
    --field-config=field-path=user_id,order=ascending \
    --field-config=field-path=name,order=ascending \
    --field-config=field-path=__name__,order=ascending \
    --project=scoop-386004
  ```


  ```bash
  gcloud builds submit --config cloudbuild_fastapi_dev.yaml --project=scoop-386004
  ```

  ```bash
  gcloud run deploy botrun-flow-lang-fastapi-dev \
    --image asia-east1-docker.pkg.dev/scoop-386004/botrun-flow-lang/botrun-flow-lang-fastapi-dev \
    --port 8080 \
    --platform managed \
    --allow-unauthenticated \
    --project=scoop-386004 \
    --region=asia-east1 \
    --cpu 2 \
    --memory 8Gi \
    --min-instances 0 \
    --max-instances 5 \
    --timeout 3600s \
    --concurrency 300 \
    --cpu-boost \
  ```


  ```bash
  gcloud firestore indexes composite create \
    --collection-group=botrun-hatch-hatch \
    --field-config=field-path=user_id,order=ascending \
    --field-config=field-path=name,order=ascending \
    --field-config=field-path=__name__,order=ascending \
    --project=scoop-386004
  ```


  ```bash
  gcloud builds submit --config cloudbuild_fastapi.yaml --project=scoop-386004
  ```


  ```bash
  gcloud run deploy botrun-flow-lang-fastapi \
    --image asia-east1-docker.pkg.dev/scoop-386004/botrun-flow-lang/botrun-flow-lang-fastapi \
    --port 8080 \
    --platform managed \
    --allow-unauthenticated \
    --project=scoop-386004 \
    --region=asia-east1 \
    --cpu 2 \
    --memory 8Gi \
    --min-instances 0 \
    --max-instances 5 \
    --timeout 3600s \
    --concurrency 300 \
    --cpu-boost \
  ```


  ```bash
  gcloud scheduler jobs create http botrun-flow-lang-heartbeat-job-$ENV \
    --schedule "*/10 * * * *" \
    --time-zone "Asia/Taipei" \
    --uri "https://botrun-flow-lang-fastapi-$ENV-36186877499.asia-east1.run.app/heartbeat" \
    --http-method GET \
    --location "asia-east1" \
    --project "scoop-386004"
  ```
  測試 scheduler
  ```bash
  gcloud scheduler jobs run botrun-flow-lang-heartbeat-job-$ENV --location "asia-east1" --project "scoop-386004"
  ```


pkgId: 42ef7d47e69185951c08ad3111a69e79a7b925dcbc0ee53c1ef6510d5ad1ea83
name: python-botrun-litellm-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for botrun-litellm
url: https://pypi.org/project/botrun-litellm/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-botrun-litellm-0.2.3-1.src.rpm
location_href: Packages/python-botrun-litellm-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  A wrapper for litellm with TAIDE configuration support.



  ```bash
  pip install botrun_litellm
  ```



  ```python
  from botrun_litellm import botrun_litellm_completion

  response = botrun_litellm_completion(
      messages=[{"role": "user", "content": "Hello!"}],
      model="openai/gpt-4"
  )
  ```

  ```python
  from botrun_litellm import botrun_litellm_completion

  response = botrun_litellm_completion(
      messages=[{"role": "user", "content": "Hello!"}],
      model="taide/openai/Llama3-TAIDE-LX-70B-Chat",
      api_base: "base_url",
      api_key: "api_key"

  )
  ```




  The following environment variables are required:

  - `TAIDE_BASE_URL`: Base URL for TAIDE API
  - `TAIDE_API_KEY`: API key for TAIDE


  - "taide/openai/Llama-3.1-405B-Instruct-FP8",
  - "taide/openai/Llama-3.1-70B",
  - "taide/openai/Llama-3.1-Nemotron-70B-Instruct",
  - "taide/openai/Llama3-TAIDE-LX-70B-Chat",
  - "taide/openai/TAIDE-LX-70B-Chat"




  MIT License


  ```bash
  poetry export -f requirements.txt --output requirements.txt --without-hashes --without-urls
  ```


pkgId: 9fca52d429335760e5663af3b4232b98312eb6a2d07db0826df886e887ef26bd
name: python-bps-restpy-help
arch: noarch
version: 10.0.100030007
epoch: 0
release: 1
summary: Development documents and examples for bps-restpy
url: https://github.com/OpenIxia/BreakingPoint
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bps-restpy-10.0.100030007-1.src.rpm
location_href: Packages/python-bps-restpy-help-10.0.100030007-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/bps-restpy.svg)](https://pypi.org/project/bps-restpy)
  [![python](https://img.shields.io/pypi/pyversions/bps-restpy.svg)](https://pypi.python.org/pypi/bps-restpy)
  [![license](https://img.shields.io/badge/license-MIT-green.svg)](https://en.wikipedia.org/wiki/MIT_License)
  [![downloads](https://pepy.tech/badge/bps-restpy)](https://pepy.tech/project/bps-restpy)


  Network testing with  [BreakingPoint®](https://www.ixiacom.com/products/network-security-testing-breakingpoint). By simulating real-world legitimate traffic, distributed denial of service (DDoS), exploits, malware, and fuzzing, BreakingPoint validates an organization’s security infrastructure, reduces the risk of network degradation by almost 80%, and increases attack readiness by nearly 70%. And with our new TrafficREWIND solution, you'll get even more realistic and high-fidelity validation by adding production network insight into BreakingPoint test traffic configuration
  More details:


  ```
  pip install --upgrade bps-restpy
  ```


  ```python
  """This script demonstrates how to get started with bps_restpy scripting.
















  import time, sys, os

  sys.path.insert(1, os.path.dirname(os.getcwd()))

  from bps_restpy.bps import BPS, pp








  canned_test_name = 'AppSim'

  bps_system  = '<BPS_BOX_IP/HOSTNAME>'
  bpsuser     = 'bps user'
  bpspass     = 'bps pass'


  slot_number = 2
  port_list   = [0, 1]






  bps = BPS(bps_system, bpsuser, bpspass)
  bps.login()



  print("Load a canned test: ")
  bps.testmodel.load(canned_test_name)


  print("Reserve Ports")
  for p in port_list:
      bps.topology.reserve([{'slot': slot_number, 'port': p, 'group': 2}])



  print("Run test and Get Stats:")
  test_id_json = bps.testmodel.run(modelname=canned_test_name, group=2)
  testid = str( test_id_json["runid"] )
  run_id = 'TEST-' + testid
  print("Test Run Id: %s"%run_id)


  runningTests_Ids = [test['id'] for  test in bps.topology.runningTest.get()]

  while run_id in runningTests_Ids:
       run_state =  bps.topology.runningTest[run_id].get()
       
       try: print ('progress: %s% , runtime %ss' % (run_state['progress'], run_state['runtime'] ))
       except: print ("Starting...")
       time.sleep(2)
       
       runningTests_Ids = [test['id'] for  test in bps.topology.runningTest.get()]

  print("~The test finished the execution.")
  results = bps.reports.search(searchString=canned_test_name, limit=10, sort="endTime", sortorder="descending")
  result  = results[0]
  print ("%s execution duration %s ended with status: %s " % (result['name'], result['duration'], result['result']) )


  tabledata = bps.reports.getReportTable(runid=testid, sectionId="3.4")
  pp(tabledata)

  print ("Unreserving the ports")
  for p in port_list:
      bps.topology.unreserve([{'slot': slot_number, 'port': p, 'group': 2}])

  bps.logout()
  ```
  wew

  Documentation is available using the following methods:
  * [Online web based documentation and samples](https://github.com/OpenIxia/BreakingPoint)
  * On your BreakingPoint System RestApi found near the BreakingPoint App
  * Documentation available in the online doc browser is also inlined in each class, property and method and can be viewed using the python help command
    ```python
    from bps_restpy.bps import BPS, pp

    
    help(BPS)
    bps = BPS('your_bps_IP_or_FQDN', 'admin', 'admin')

    help(bps.testmodel.importModel)

    ```


  Visit the [OpenIxia breakingpoint-restpy sample site maintained by solution architects](https://github.com/OpenIxia/BreakingPoint) for in depth end-to-end samples that demonstrate the following:
  * building a configuration
      * from scratch
      * from an existing BreakingPoint configuration
  * running the configuration
      * connecting ports to hardware
      * starting protocols
      * starting traffic
  * getting statistics
      * port stats
      * traffic stats


pkgId: a88c010342399afa4d6a3893acf0652421273f26c827545a604aca352bd7bdec
name: python-bqemulatormanager-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for bqemulatormanager
url: https://pypi.org/project/bqemulatormanager/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bqemulatormanager-0.2.3-1.src.rpm
location_href: Packages/python-bqemulatormanager-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  this package is wrapper of [bigquery-emulator](https://github.com/goccy/bigquery-emulator) which provides us BigQuery mock working in local machine.

  using this package, you can

  - do unit test of your sql
  - download the schema of big query, and use it to make test data


  1. following [instruction](https://github.com/goccy/bigquery-emulator#install),  download `bigquery-emulator` command.

  2. install this package.
  ```
  pip install bqemulatormanager
  ```

  3. test your sql.
  ```python
  import bqemulatormanager as bqem
  import pandas as pd

  manager = bqem.Manager(project='test', schema_path='resources/schema_example.yaml')

  with manager:
      data = pd.DataFrame([
          {'id': 1, 'name': 'sato'},
          {'id': 2, 'name': 'yamada'}
      ])

      manager.load(data, 'dataset1.table_a')

      sql = 'SELECT id, name FROM `dataset1.table_a`'

      df = manager.query(sql)
  print(df)
  ```

  unit test example is [here](https://github.com/gyuta/bqemulatormanager/blob/main/examples/testing.py).


  When called `Manager.load`, `SchemaManager` search correspond table schema from `schema_path` (default is `bqem_master_schema.yaml`).

  If schema definition cannot be found, `SchemaManager` request it from BigQuery in production environment and update master schema file.


pkgId: d830a6d27685d1f90080d21a21c7bc6fbfab0caed200c5f5434d5845f6be217c
name: python-brain2-oc-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for brain2-oc
url: https://ouroboroscoding.com/body/brain2
rpm_license: Custom
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-brain2-oc-2.0.0-1.src.rpm
location_href: Packages/python-brain2-oc-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Body 2.0 service that handles users and permissions.

  This code comes without documentation as it's not meant to be used by anyone
  outside of Ouroboros Coding Inc. Please see LICENSE for further information.


pkgId: 0f13575761396623b358176efde4c856dbee9c02fb1d96b741d3c145b2625ffd
name: python-brainannex-help
arch: noarch
version: 5.0rc0
epoch: 0
release: 1
summary: Development documents and examples for brainannex
url: https://brainannex.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-brainannex-5.0rc0-1.src.rpm
location_href: Packages/python-brainannex-help-5.0rc0-1.noarch.rpm
checksum_type: sha256
description:
  The diagram below is split in 2 parts, for readability.
  "chem" is an example of a custom Class.
  ![Classes and Properties in Brain Annex - Non-record types](docs/Classes_and_Properties_Non_record_types.png)
  The following second half of the diagram shows the remainder of the Schema, detailing Classes that are instances of the "Records" Class.
  Most of the items in this diagram are examples of typical user-added schema:
  ![Classes and Properties in Brain Annex - Record types](docs/Classes_and_Properties_Record_types.png)
  **Optional: add Neo4j Indexes and Constraints**
  Not strictly needed for test runs, but at some point Neo4j Indexes and Constraints
  need to be added, for speed and reliability.
  From the Neo4j browser interface, issue the following Cypher commands:
      CREATE CONSTRAINT unique_BA_ID ON (n:BA) ASSERT n.uri IS UNIQUE
      CREATE CONSTRAINT unique_CLASS_ID ON (n:CLASS) ASSERT n.uri IS UNIQUE
      CREATE CONSTRAINT unique_CLASS_NAME ON (n:CLASS) ASSERT n.name IS UNIQUE
      CREATE CONSTRAINT unique_PROPERTY_ID ON (n:PROPERTY) ASSERT n.uri IS UNIQUE

  * **NeoAccess** : a library to connect to Neo4j with python. It provides many services.
    [Link](https://github.com/BrainAnnex/neoaccess)
  * **NeoSchema** : a higher-level schema-based library on top of NeoAccess.
    [Link](https://github.com/BrainAnnex/brain-annex/blob/main/BrainAnnex/modules/neo_schema/neo_schema.py)<!-- @IGNORE PREVIOUS: link -->
    [Article explaining this layer](https://julianspolymathexplorations.blogspot.com/2022/11/schema-graph-databases-neo4j.html)
  * **CK Editor** : open-source JavaScript library to implement an online HTML Editor.
    [Website](https://www.quackit.com/html/online-html-editor/full/).
    (Note: Brain Annex uses [version 4](https://ckeditor.com/docs/ckeditor4/latest/) of the CK Editor)
  * **API** : the endpoints appear in [this file](https://github.com/BrainAnnex/brain-annex/blob/main/BrainAnnex/api/BA_api_routing.py)<!-- @IGNORE PREVIOUS: link -->
  * **Web pages** : the pages generated by Brain Annex are listed in [this routing file](https://github.com/BrainAnnex/brain-annex/blob/main/BrainAnnex/pages/BA_pages_routing.py)<!-- @IGNORE PREVIOUS: link -->
  * **Navigation bar** : Brain Annex can be used either as a standalone web app, or integrated with another site.
    The navigation is implemented [in this package](https://github.com/BrainAnnex/brain-annex/tree/main/navigation)


pkgId: d6e7c1311c4f19d46e0d6db01a6383f62932d552db30d0785b158bdad7fd1e1b
name: python-brainscore-brainio-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for brainscore-brainio
url: https://github.com/brain-score/brainio
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-brainscore-brainio-1.1.0-1.src.rpm
location_href: Packages/python-brainscore-brainio-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/brain-score/brainio.svg?branch=main)](https://app.travis-ci.com/brain-score/brainio)


  BrainIO is a framework for standardizing the exchange of data between
  experimental and computational neuroscientists.  It includes a minimal
  specification for packaged data and tools for working with that packaged data.

  [Glossary](docs/glossary.md)

  [BrainIO Format Specification](docs/SPECIFICATION.md)

  Currently the tools are written in [Python](https://www.python.org/), but the format is language-agnostic.


  * To safeguard the **value** of the data you have collected by ensuring it never gets separated from its metadata.
  * To adopt a **consistent format** in order to provide a minimum level of interoperability.
  * For a fair exchange of effort.  BrainIO is intended to find a **balance** between the effort it requires of the consumer of data and the effort it requires of the provider of data, and to minimize both where possible.

  There are three terms that are important to understanding BrainIO:
  * **Stimulus Set**
  * **Data Assembly**
  * **BrainIO Catalog**

  We define these terms below.  For other terms, see the [glossary](docs/glossary.md).

  A **Stimulus Set** is a collection of stimuli intended for use in experiments, packaged so that it is organized and easy to obtain.  The parts of a Stimulus Set are:
  * a CSV file of metadata
  * a ZIP file of stimuli
  * a few [rules](docs/SPECIFICATION.md) for how the metadata are organized (like, include a column called "stimulus_id")

  A **Data Assembly** is a coherent body of data collected during an experiment, packaged with the metadata which describe it.  The term "assembly" is used in engineering for a set of parts that have been assembled to form a coherent unit.  The parts of a Data Assembly are:
  * a [netCDF-4](https://www.unidata.ucar.edu/software/netcdf/) file (internally an [HDF5](https://www.hdfgroup.org/solutions/hdf5/) file) containing numeric data and metadata
  * a few [rules](docs/SPECIFICATION.md) about what's in the netCDF file (names for dimensions, a reference to a stimulus set)

  A **BrainIO Catalog** is a list of Stimulus Sets and Data Assemblies that provides information on how to obtain them and load them into memory.  The only thing a BrainIO Catalog requires is a CSV file containing [specified](docs/SPECIFICATION.md) lookup data for Stimulus Sets And Data Assemblies.



  There are two main ways to install BrainIO, corresponding to two of the main ways of using it:
  * For obtaining and using packaged stimuli and data
  * For creating new packages of stimuli and data and adding them to an existing catalog

  These are described below.  We recommend installing in a managed Python environment like a `conda` environment.



  1. Install BrainIO using `pip` in an existing environment
      1. Activate your environment.
      1. `pip install git+https://github.com/brain-score/brainio.git`
  1. Install a project that provides a BrainIO Catalog
      * If you intend to use a BrainIO catalog to access data or stimuli that have already been packaged, you will need to install the project that provides the catalog that you intend to use.  Here we illustrate with [a project called `brainio-dicarlo`](https://github.com/dicarlolab/brainio-dicarlo) provided by the DiCarlo Lab:
      1. Activate your environment
      1. `pip install git+https://github.com/dicarlolab/brainio-dicarlo.git`
      * This registers the catalog with the Python interpreter in your environment
  so that the BrainIO tools can use it.



  If you intend to package Stimulus Sets And Data Assemblies and add them to a project's catalog, instead of installing the project as above, you will need to clone the repository for that project and install it in your environment in editable mode.  In the example below we set up to add to the BrainIO Catalog provided by [a project called `brainio-dicarlo`](https://github.com/dicarlolab/brainio-dicarlo):

  1.  Activate your environment.
  1.  Change to the directory where you store your [Git](https://git-scm.com/) repositories:
  `cd ~/projects`
  1.  `git clone https://github.com/dicarlolab/brainio-dicarlo.git`
  1.  `pip install -e brainio-dicarlo`

  You should now have a directory `~/projects/brainio-dicarlo` which contains the
  source for the project.  Packaging and cataloging are covered below.





  The most commonly used methods of the BrainIO API are:

  * **List Stimulus Sets**:  `brainio.list_stimulus_sets()` lists the identifiers of all the BrainIO stimulus sets available via your installed catalogs.
  * **List Data Assemblies**:  `brainio.list_assemblies()` lists the identifiers of all the BrainIO data assemblies available via your installed catalogs.
  * **List Catalogs**: `brainio.list_catalogs()` lists the identifiers of all the BrainIO catalogs installed in your current Python environment.


  * **Get Stimulus Set**:  `brainio.get_stimulus_set(identifier)` looks up, fetches, loads and returns the stimulus set matching the given unique identifier.
  * **Get Data Assembly**:  `brainio.get_assembly(identifier)` looks up, fetches, loads and returns the data assembly matching the given unique identifier (including getting any associated stimulus set).


  * **Stimulus Set From Files**:  `brainio.stimuli.StimulusSet.from_files(csv_path, dir_path)` loads into memory a stimulus set contained in the provided files.
  * **Data Assembly From Files**:  `brainio.assemblies.DataAssembly.from_files(file_path, **kwargs)` loads into memory a data assembly contained in the provided file.  Usually called from a subclass of DataAssembly.



  There are four main ways to use the Python BrainIO tools:
  * To look up and fetch stimuli and data that are packaged and cataloged.
  * To access and analyze stimuli and data stored in files conforming to the [BrainIO Format Specification](docs/SPECIFICATION.md)
  * To add packages of stimuli and data to an existing catalog.
  * To create a new project that provides a catalog.



  Here's an example of using BrainIO in a Python interactive interpreter session, retrieving a Stimulus Set and a Data Assembly and displaying their text representations, and retrieving a stimulus file.  The types of the returned objects are `StimulusSet`, a subclass of a [pandas](https://pandas.pydata.org/) `DataFrame`, and `DataAssembly`, a subclass of an [xarray](https://xarray.pydata.org/) `DataArray`.  We use the functions `get_stimulus_set` and `get_assembly` and the `StimulusSet` method `get_stimulus`:

  ```pycon
  >>> from brainio import get_assembly, get_stimulus_set
  >>> hvm_stim = get_stimulus_set(identifier="dicarlo.hvm")
  >>> hvm_stim
          id                             background_id         s  ... rxy_semantic ryz_semantic        rxz
  0        1  ecd40f3f6d7a4d6d88134d648884e0b9b364efc9  1.000000  ...    90.000000    -0.000000   0.000000
  1        2  006d66c207c6417574f62f0560c6b2b40a9ec5a1  1.000000  ...    -0.000000    -0.000000   0.000000
  ...
  5758  5759  2363c8c3859603ee9db7f83dd7ba5b6989154258  0.791250  ...   -75.159000    12.283000  29.466000
  5759  5760  a7fc954d2bd08fc2c4d3ade347f41a03a5850131  1.050000  ...   -67.467580     7.598457 -25.152591

  [5760 rows x 18 columns]
  >>> hvm_assy = get_assembly(identifier="dicarlo.MajajHong2015.public")
  >>> hvm_assy
  <xarray.NeuronRecordingAssembly 'dicarlo.MajajHong2015.public' (neuroid: 256, presentation: 148480, time_bin: 1)>
  array([[[ 0.06092933],
          [-0.8479065 ],
  ...
          [ 1.0052351 ],
          [-0.2989609 ]]], dtype=float32)
  Coordinates:
    * neuroid          (neuroid) MultiIndex
    - neuroid_id       (neuroid) object 'Chabo_L_M_5_9' ... 'Tito_L_M_8_0'
  ...
    * time_bin         (time_bin) MultiIndex
    - time_bin_start   (time_bin) int64 70
    - time_bin_end     (time_bin) int64 170
  Attributes:
      stimulus_set_identifier:  dicarlo.hvm-public
      stimulus_set:                     id                             backgrou...
      identifier:               dicarlo.MajajHong2015.public

  >>> hvm_stim.get_stimulus(stimulus_id="ecd40f3f6d7a4d6d88134d648884e0b9b364efc9")
  "/Users/me/.brainio/stimulus_dicarlo_hvm/astra_rx+00.000_ry+00.000_rz+00.000_tx+00.000_ty+00.000_s+01.000_ecd40f3f6d7a4d6d88134d648884e0b9b364efc9_256x256.png"
  ```



  If you have a CSV file describing a BrainIO Stimulus Set and a directory containing the associated stimulus files,
  you can load the `StimulusSet` into memory with `brainio.stimuli.StimulusSet.from_files()`.
  An example of using BrainIO in a Python interactive interpreter session to load a `StimulusSet`:
  ```pycon
  >>> from brainio.stimuli import StimulusSet
  >>> hvm_stim = StimulusSet.from_files(csv_path='hvm-public/hvm-public.csv', dir_path='hvm-public')
  >>> hvm_stim
          id                             background_id  ...  ryz_semantic        rxz
  0        1  ecd40f3f6d7a4d6d88134d648884e0b9b364efc9  ...     -0.000000   0.000000
  1        2  006d66c207c6417574f62f0560c6b2b40a9ec5a1  ...     -0.000000   0.000000
  2        3  3b3c1d65865028d0fad0b0bf8f305098db717e7f  ...     -0.000000   0.000000
  3        4  687ade2f9ee4d52af9705865395471a24ba38d5f  ...     -0.000000   0.000000
  4        5  724e5703cc42aa2c3ff135e3508038a90e4ebcb3  ...     -0.000000   0.000000
      ...                                       ...  ...           ...        ...
  3195  3196  70222407751181c4b7723cb09dbda63e7f9c7333  ...     17.585453 -12.905496
  3196  3197  f144e3aabccefb4228b8257506a2aa26ba5b4a6d  ...     22.244000  -6.302000
  3197  3198  9b87c8be1440ce9626bcfe656700ff3ac8f909fe  ...      9.423000 -13.140000
  3198  3199  c3edce2a8fce8c088605bd27fe1f2e7958939f54  ...     38.652000  11.926000
  3199  3200  91e68c65ff92e5a77f0fb13693bfe01bc429da18  ...     16.609000 -36.603000
  [3200 rows x 18 columns]
  >>> hvm_stim.get_stimulus('8a72e2bfdb8c267b57232bf96f069374d5b21832')
  'hvm-public/astra_rx+00.000_ry+00.000_rz+00.000_tx+00.000_ty+00.000_s+01.000_ecd40f3f6d7a4d6d88134d648884e0b9b364efc9_256x256.png'
  ```

  If you have a netCDF file containing a BrainIO Data Assembly, you can open it with
  `brainio.assemblies.<DataAssembly subclass>.from_files()`.
  An example of using BrainIO in a Python interactive interpreter session to load a `DataAssembly`:

  ```pycon
  >>> from brainio.assemblies import NeuronRecordingAssembly
  >>> hvm_assy = NeuronRecordingAssembly.from_files(file_path='MajajHong2015_public.nc', stimulus_set_identifier='dicarlo.hvm.public', stimulus_set=hvm_stim)
  >>> hvm_assy
  <xarray.NeuronRecordingAssembly 'dicarlo.MajajHong2015.public' (neuroid: 256, presentation: 148480, time_bin: 1)>
  array([[[ 0.06092933],
          [-0.8479065 ],
          [-1.618728  ],
          ...,
          [ 0.42337415],
          [ 0.0775381 ],
          [-0.614134  ]],
         [[ 0.30726328],
          [ 0.35321778],
          [ 0.10181567],
          ...,
          [-2.2552547 ],
          [ 1.0052351 ],
          [-0.2989609 ]]], dtype=float32)
  Coordinates:
    * neuroid          (neuroid) MultiIndex
    - neuroid_id       (neuroid) object 'Chabo_L_M_5_9' ... 'Tito_L_M_8_0'
    - arr              (neuroid) object 'M' 'M' 'M' 'M' 'M' ... 'M' 'M' 'M' 'M'
    - col              (neuroid) int64 9 9 8 9 8 8 7 7 5 6 ... 1 0 1 0 1 0 0 1 1 0
    - hemisphere       (neuroid) object 'L' 'L' 'L' 'L' 'L' ... 'L' 'L' 'L' 'L'
    - subregion        (neuroid) object 'cIT' 'cIT' 'cIT' ... 'pIT' 'pIT' 'pIT'
    - animal           (neuroid) object 'Chabo' 'Chabo' 'Chabo' ... 'Tito' 'Tito'
    - y                (neuroid) float64 0.2 0.6 0.2 1.0 0.6 ... 1.0 1.0 1.8 1.4
    - x                (neuroid) float64 1.8 1.8 1.4 1.8 ... -1.8 -1.4 -1.4 -1.8
    - region           (neuroid) object 'IT' 'IT' 'IT' 'IT' ... 'IT' 'IT' 'IT'
    - row              (neuroid) int64 5 6 5 7 6 7 9 7 9 8 ... 4 4 5 5 6 6 7 7 9 8
    * presentation     (presentation) MultiIndex
    - stimulus_id         (presentation) object '8a72e2bfdb8c267b57232bf96f069374d...
    - repetition       (presentation) int64 0 18 18 18 18 18 ... 16 16 16 17 17 17
    - stimulus         (presentation) int64 0 426 427 428 429 ... 2569 2566 0 1 2
  ...
    - object_name      (presentation) object 'car_astra' 'face0' ... 'apple'
    - variation        (presentation) int64 0 0 0 0 0 0 0 0 0 ... 3 3 3 3 3 3 3 3
    - size             (presentation) float64 256.0 256.0 256.0 ... 256.0 256.0
    - rxy_semantic     (presentation) float64 90.0 -0.0 -0.0 ... 0.02724 -10.4
    - ryz_semantic     (presentation) float64 -0.0 -0.0 -0.0 ... -16.89 -0.2055
    - rxz              (presentation) float64 0.0 0.0 0.0 ... 13.22 -2.621 -14.72
    * time_bin         (time_bin) MultiIndex
    - time_bin_start   (time_bin) int64 70
    - time_bin_end     (time_bin) int64 170
  Attributes:
      stimulus_set_identifier:  dicarlo.hvm.public
      stimulus_set:                     id                             backgrou...
  ```

  You can also write a Data Assembly to a netCDF file with `brainio.packaging.write_netcdf()`.
  `write_netcdf` returns the new file's SHA-1 hash.

  ```pycon
  >>> from brainio.packaging import write_netcdf
  >>> hvm_assy_new = hvm_assy.sel(subregion='aIT', object_name='apple')
  >>> hvm_assy_new
  <xarray.NeuronRecordingAssembly 'dicarlo.MajajHong2015.public' (neuroid: 17, presentation: 2320, time_bin: 1)>
  array([[[-0.64983755],
          [-1.058876  ],
          [ 1.3953547 ],
          ...,
          [-0.21288353],
          [ 1.6455535 ],
          [ 3.1486752 ]],
         [[-0.5977455 ],
          [ 2.806696  ],
          [ 0.25336486],
          ...,
          [ 0.6877102 ],
          [ 0.683575  ],
          [ 2.6989598 ]]], dtype=float32)
  Coordinates:
    * neuroid          (neuroid) MultiIndex
    - neuroid_id       (neuroid) object 'Chabo_L_A_8_8' ... 'Chabo_L_A_6_5'
    - arr              (neuroid) object 'A' 'A' 'A' 'A' 'A' ... 'A' 'A' 'A' 'A'
    - col              (neuroid) int64 8 8 6 7 5 7 7 6 6 5 6 5 5 5 6 5 5
    - hemisphere       (neuroid) object 'L' 'L' 'L' 'L' 'L' ... 'L' 'L' 'L' 'L'
    - animal           (neuroid) object 'Chabo' 'Chabo' ... 'Chabo' 'Chabo'
    - y                (neuroid) float64 1.4 1.8 0.6 1.4 1.0 ... -0.2 -0.2 0.2 0.6
    - x                (neuroid) float64 1.4 1.4 0.6 1.0 0.2 ... 0.2 0.6 0.2 0.2
    - region           (neuroid) object 'IT' 'IT' 'IT' 'IT' ... 'IT' 'IT' 'IT'
    - row              (neuroid) int64 8 9 6 8 7 9 7 9 7 9 8 8 3 4 4 5 6
    * presentation     (presentation) MultiIndex
    - stimulus_id         (presentation) object '5cde85cc63e677623c606ebf6d21a6b02...
    - repetition       (presentation) int64 18 18 18 18 19 19 ... 17 16 16 17 17
    - stimulus         (presentation) int64 431 310 344 530 60 ... 2551 2544 5 2
  ...
    - ryz_semantic     (presentation) float64 -0.0 -0.0 -0.0 ... 42.79 -0.2055
    - rxz              (presentation) float64 0.0 0.0 0.0 ... -23.87 -3.039 -14.72
    * time_bin         (time_bin) MultiIndex
    - time_bin_start   (time_bin) int64 70
    - time_bin_end     (time_bin) int64 170
  Attributes:
      stimulus_set_identifier:  dicarlo.hvm.public
      stimulus_set:                     id                             backgrou...
  >>> write_netcdf(assembly=hvm_assy_new, target_netcdf_file='hvm_aIT_apple.nc')
  '7da262e1d35de5fc26bbbe9b10c481792cef1bde'
  ```



  To package Stimulus Sets and Data Assemblies and add them to a BrainIO Catalog, first install a project in editable mode as described above.  Make sure you have commit privileges on [GitHub](https://github.com/) for the repository you're editing.  Then (using the same [example project](https://github.com/dicarlolab/brainio-dicarlo) as above):

  1.  Activate your environment.
  1.  `cd ~/projects/brainio-dicarlo`
  1.  Create a new Git branch (the branch name doesn't really matter):
  `git branch dicarlo.Me2025.public`
  1.  `git checkout dicarlo.Me2025.public`
  1.  Write a script that packages your Stimulus Set and/or Data Assembly.
  We'll call our example `brainio-dicarlo/packaging/scripts/me2025.py`.
      * See the [documentation](docs/packaging.rst) for the packaging methods
      * The packaging scripts in a repository serve as a historical record.  The
    interface to the BrainIO API may have changed since a given script was written.
    Notably, the `package_stimulus_set` and `package_data_assembly` functions now
    require a `catalog_name` argument.  In this example we would use
    `"brainio-dicarlo"`.
  1.  `git add packaging/scripts/me2025.py`
  1.  `git commit -m "Added script for dicarlo.Me2025.public"`
  1.  `git push`
  1.  Run your script.  Make sure lines for your packaged files are now present in
  the catalog file at `brainio_dicarlo/lookup.csv`.
  1.  `git add brainio_dicarlo/lookup.csv`
  1.  `git commit -m "Packaged dicarlo.Me2025.public"`
  1.  `git push`
  1.  In the [GitHub](https://github.com/) web interface for the project, open a Pull Request for your branch.

  Depending on the configuration of the project, once a colleague reviews your
  changes and approves them, you can merge the pull request to `main`, and your
  packaged Stimulus Sets and Data Assemblies will be available to anyone who
  installs the project.



  ```shell
  mkdir -p ~/projects/my-project/my_project
  cd ~/projects/my-project/
  touch setup.py my_project/entrypoint.py my_project/lookup.csv /my_project/__init__.py
  echo include my_project/lookup.csv > MANIFEST.in
  ```
  Use your favorite editor to edit `setup.py`:
  ```python
  from setuptools import setup, find_packages

  setup(
      name='my-project',
      version="0.1.0",
      packages=find_packages(),
      install_requires=[
          "brainio @ git+https://github.com/brain-score/brainio",
      ],
      entry_points={
          'my_project': [
              'my_project = my_project.entrypoint:my_project',
          ],
      },)
  ```
  Then edit `entrypoint.py`:

  ```python
  import logging
  from pathlib import Path
  import pandas as pd
  from brainio.catalogs import Catalog

  _logger = logging.getLogger(__name__)


  def my_project():
      path = Path(__file__).parent / "lookup.csv"
      _logger.debug(f"Loading lookup from {path}")
      print(f"Loading lookup from {path}")
      catalog = Catalog.from_files("my_project", path)
      return catalog
  ```
  Now install your project in editable mode:
  ```shell
  conda create -n my-project python==3.8
  conda activate my-project
  pip install -e ~/projects/my-project
  ```
  You should now be able to use packaging scripts (with the argument
  `catalog_name=my_project`) to add to your catalog.


  If terminology is unclear, see the [Glossary](docs/glossary.md).

  If you have questions, [get in touch with us]("mailto:jjpr@mit.edu?subject=BrainIO question).



  [MIT License](LICENSE)


pkgId: 2ce6dd6744c866b51c771f2968190ee775a013e653bb1a1f345ee7986fbb4aec
name: python-brainscore-vision-help
arch: noarch
version: 2.2.3
epoch: 0
release: 1
summary: Development documents and examples for brainscore-vision
url: https://pypi.org/project/brainscore-vision/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-brainscore-vision-2.2.3-1.src.rpm
location_href: Packages/python-brainscore-vision-help-2.2.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://app.travis-ci.com/brain-score/vision.svg?token=vqt7d2yhhpLGwHsiTZvT&branch=master)](https://app.travis-ci.com/brain-score/vision)
  [![Documentation Status](https://readthedocs.org/projects/brain-score/badge/?version=latest)](https://brain-score.readthedocs.io/en/latest/?badge=latest)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md)

  Brain-Score is a platform to evaluate computational models of brain function
  on their match to brain measurements in primate vision.
  The intent of Brain-Score is to adopt many (ideally all) the experimental benchmarks in the field
  for the purpose of model testing, falsification, and comparison.
  To that end, Brain-Score operationalizes experimental data into quantitative benchmarks
  that any model candidate following the [`BrainModel`](brainscore_vision/model_interface.py) interface can be scored on.

  Note that you can only access a limited set of public benchmarks when running locally. To score a model on all benchmarks, submit it via the [brain-score.org website](http://www.brain-score.org).

  See the [documentation](https://brain-score.readthedocs.io) for more details, e.g. for submitting a [model](https://brain-score.readthedocs.io/en/latest/modules/model_tutorial.html) or [benchmark](https://brain-score.readthedocs.io/en/latest/modules/benchmark_tutorial.html) to Brain-Score. For a step-by-step walkthrough on submitting models to the Brain-Score website, see these [web tutorials](https://www.brain-score.org/tutorial/).

  See these [code examples](https://github.com/brain-score/vision/blob/master/examples) on scoring models, retrieving data, using and defining benchmarks and metrics.
  These [previous examples](https://github.com/brain-score/candidate_models/blob/master/examples/score-model.ipynb) might be helpful, but their usage has been deprecated after the 2.0 update.

  Brain-Score is made by and for the community.
  To contribute, please [send in a pull request](https://github.com/brain-score/vision/pulls).




  You will need Python = 3.11 and pip >= 18.1.

  `pip install git+https://github.com/brain-score/vision.git`

  Test if the installation is successful by scoring a model on a public benchmark:

  ```python
  from brainscore_vision.benchmarks import public_benchmark_pool

  benchmark = public_benchmark_pool['dicarlo.MajajHong2015public.IT-pls']
  model = my_model()
  score = benchmark(model)










  ```

  Some steps may take minutes because data has to be downloaded during first-time use.



  | Variable               | Description                                                                                                                           |
  |------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
  | RESULTCACHING_HOME     | directory to cache results (benchmark ceilings) in, `~/.result_caching` by default (see https://github.com/brain-score/result_caching) |




  MIT license




  <details>
  <summary>`ValueError: did not find HDF5 headers` during netcdf4 installation</summary>
  pip seems to fail properly setting up the HDF5_DIR required by netcdf4.
  Use conda: `conda install netcdf4`
  </details>

  <details>
  <summary>repeated runs of a benchmark / model do not change the outcome even though code was changed</summary>
  results (scores, activations) are cached on disk using https://github.com/mschrimpf/result_caching.
  Delete the corresponding file or directory to clear the cache.
  </details>




  Add CI related build commands to `test_setup.sh`. The script is executed in CI environment for unittests.




  If you use Brain-Score in your work, please cite
  ["Brain-Score: Which Artificial Neural Network for Object Recognition is most Brain-Like?"](https://www.biorxiv.org/content/10.1101/407007v2) (technical) and
  ["Integrative Benchmarking to Advance Neurally Mechanistic Models of Human Intelligence"](https://www.cell.com/neuron/fulltext/S0896-6273(20)30605-X) (perspective)
  as well as the respective benchmark sources.

  ```bibtex
  @article{SchrimpfKubilius2018BrainScore,
    title={Brain-Score: Which Artificial Neural Network for Object Recognition is most Brain-Like?},
    author={Martin Schrimpf and Jonas Kubilius and Ha Hong and Najib J. Majaj and Rishi Rajalingham and Elias B. Issa and Kohitij Kar and Pouya Bashivan and Jonathan Prescott-Roy and Franziska Geiger and Kailyn Schmidt and Daniel L. K. Yamins and James J. DiCarlo},
    journal={bioRxiv preprint},
    year={2018},
    url={https://www.biorxiv.org/content/10.1101/407007v2}
  }

  @article{Schrimpf2020integrative,
    title={Integrative Benchmarking to Advance Neurally Mechanistic Models of Human Intelligence},
    author={Schrimpf, Martin and Kubilius, Jonas and Lee, Michael J and Murty, N Apurva Ratan and Ajemian, Robert and DiCarlo, James J},
    journal={Neuron},
    year={2020},
    url={https://www.cell.com/neuron/fulltext/S0896-6273(20)30605-X}
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2017, Martin Schrimpf and Jon Prescott-Roy  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.


