# packages

pkgId: 24c797a8e8edaadcafb61b32eb35a0a88b4cd10e653147d262fb6b367a00db17
name: python-msal-streamlit-button-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for msal-streamlit-button
url: https://pypi.org/project/msal-streamlit-button/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msal-streamlit-button-1.0.2-1.src.rpm
location_href: Packages/python-msal-streamlit-button-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Streamlit component that allows you to do X



  ```sh
  pip install streamlit-custom-component
  ```



  ```python
  import streamlit as st

  from microsoft_login_button import microsoft_login_button

  value = microsoft_login_button(client_id, tenant_id,LoginText,styles )

  st.write(value)
  ```


pkgId: 512f75b061cabe217326bd7501cf97a05da94647db9272d2ccd290ddc00430fd
name: python-msconvert-help
arch: noarch
version: 1.3.post2
epoch: 0
release: 1
summary: Development documents and examples for msconvert
url: https://pypi.org/project/msconvert/
rpm_license: GNU Affero General Public License v3 or later (AGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msconvert-1.3.post2-1.src.rpm
location_href: Packages/python-msconvert-help-1.3.post2-1.noarch.rpm
checksum_type: sha256
description:
  A Python wrapper for the `pwiz/msconvert docker image <https://hub.docker.com/r/proteowizard/pwiz-skyline-i-agree-to-the-vendor-licenses>`_.


pkgId: 8fd4e2bd59c5c9a8a5a45668951479bb4516cf47db6ddfc5dea45e3e0a388fad
name: python-msfootprint-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for msfootprint
url: https://github.com/supathdhitalGEO/msfootprint
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msfootprint-0.1.1-1.src.rpm
location_href: Packages/python-msfootprint-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This tool allows users to retrieve microsoft global building footprint data based on a specified boundary (such as a shapefile or GeoJSON). The footprints are then saved as GeoJSON files to a specified output directory.



  - Supports multiple boundary input file formats: `.shp`, `.gpkg`, `.kml`, `.geojson`.
  - Allows users to specify a boundary and retrieve building footprint data for a specific country or region or small study area.
  - Compatible with Google Earth Engine (GEE)/ required GEE authentications.


  **It needs a GEE account to access the data.**

  To install the required dependencies, run the following:

  ```bash
  pip install msfootprint
  ```

  Once installed,
  import it in notebook or any python compiler.

  ```bash
  import msfootprint as msf
  ```
  **Initialize all the variables**
  ```bash

  import pathlib as Path
  boundary_shp = Path('./shapefile_directory')
  out_dir = Path('./output_directory')


  country = 'Nepal'


  msf.FindTableorFolder('US')




  country = "US/Alabama"
  ```
  **Now, run the main script**
  ```bash
  msf.getBuildingFootprint(country, boundary_shp, out_dir)
  ```
  It will save the building footprint as geojson format in designated location.



  Feel free to reach out to me:
  **Supath Dhital**
  Email: [sdhital@crimson.ua.edu](mailto:sdhital@crimson.ua.edu)


pkgId: 56879bba1cee54543c1cb5f3d51a37210407a7440cc15389c5b1cb562a2dda8a
name: python-msfootprint-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for msfootprint
url: https://github.com/supathdhitalGEO/msfootprint
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msfootprint-0.1.2-1.src.rpm
location_href: Packages/python-msfootprint-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  This tool allows users to retrieve microsoft global building footprint data based on a specified boundary (such as a shapefile or GeoJSON). The footprints are then saved as GeoJSON files to a specified output directory.



  - Supports multiple boundary input file formats: `.shp`, `.gpkg`, `.kml`, `.geojson`.
  - Allows users to specify a boundary and retrieve building footprint data for a specific country or region or small study area.
  - Compatible with Google Earth Engine (GEE)/ required GEE authentications.


  **It needs a GEE account to access the data.**

  To install the required dependencies, run the following:

  ```bash
  pip install msfootprint
  ```

  Once installed,
  import it in notebook or any python compiler.

  ```bash
  import msfootprint as msf
  ```
  **Initialize all the variables**
  ```bash

  import pathlib as Path
  boundary_shp = Path('./shapefile_directory')
  out_dir = Path('./output_directory')


  country = 'Nepal'


  msf.FindTableorFolder('Indonesia')




  country = "Indonesia/{table_name}"
  ```

  **For US, it is automated, so no need to give statename but for other countries having multiple tables need to follow aforementioned step**

  **Now, run the main script**
  ```bash
  msf.getBuildingFootprint(country, boundary_shp, out_dir)
  ```
  It will save the building footprint as geojson format in designated location.



  Feel free to reach out to me:
  **Supath Dhital**
  Email: [sdhital@crimson.ua.edu](mailto:sdhital@crimson.ua.edu)


pkgId: 02d4186b7e1ea0755da7b821eb0a4cc19fa8e98cf9763ed9f008f7ac2c4b8b92
name: python-msgraph-beta-sdk-help
arch: noarch
version: 1.15.0
epoch: 0
release: 1
summary: Development documents and examples for msgraph-beta-sdk
url: https://pypi.org/project/msgraph-beta-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msgraph-beta-sdk-1.15.0-1.src.rpm
location_href: Packages/python-msgraph-beta-sdk-help-1.15.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/msgraph-beta-sdk.svg)](https://badge.fury.io/py/msgraph-beta-sdk)
  [![Downloads](https://pepy.tech/badge/msgraph-beta-sdk)](https://pepy.tech/project/msgraph-beta-sdk)
  [![Supported Versions](https://img.shields.io/pypi/pyversions/msgraph-beta-sdk.svg)](https://pypi.org/project/msgraph-beta-sdk)
  [![Contributors](https://img.shields.io/github/contributors/microsoftgraph/msgraph-beta-sdk-python.svg)](https://github.com/microsoftgraph/msgraph-beta-sdk-python/graphs/contributors)

  Get started with the Microsoft Graph Beta SDK for Python by integrating the [Microsoft Graph API](https://docs.microsoft.com/graph/overview) into your Python application.

  > **Note:**
  >
  > * This SDK allows you to build applications using the latest [beta](https://docs.microsoft.com/graph/use-the-api#version) version of Microsoft Graph. If you want to try the v1.0 Microsoft Graph API, use the [v1.0](https://github.com/microsoftgraph/msgraph-sdk-python) SDK.



  ```py
  pip install msgraph-beta-sdk
  ```

  > **Note:**
  >
  > * The Microsoft Graph Beta SDK for Python is a fairly large package. It may take a few minutes for the initial installation to complete.
  > * Enable long paths in your environment if you receive a `Could not install packages due to an OSError`. For details, see [Enable Long Paths in Windows 10, Version 1607, and Later](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=powershell#enable-long-paths-in-windows-10-version-1607-and-later).





  Register your application by following the steps at [Register your app with the Microsoft Identity Platform](https://docs.microsoft.com/graph/auth-register-app-v2).



  You must get a **GraphServiceClient** object to make requests against the service.

  An instance of the **GraphServiceClient** class handles building client. To create a new instance of this class, you need to provide an instance of **Credential**, which can authenticate requests to Microsoft Graph.

  > **Note**: For authentication we support both `sync` and `async` credential classes from `azure.identity`. Please see the azure identity [docs](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity?view=azure-python) for more information.

  ```py

  from azure.identity.aio import EnvironmentCredential
  from msgraph_beta import GraphServiceClient

  scopes = ['User.Read', 'Mail.Read']
  credential = EnvironmentCredential()
  client = GraphServiceClient(credential, scopes=scopes)
  ```

  > **Note**: Refer to the [following documentation page](https://learn.microsoft.com/graph/sdks/customize-client?tabs=python#configuring-the-http-proxy-for-the-client) if you need to configure an HTTP proxy.



  After you have a **GraphServiceClient** that is authenticated, you can begin making calls against the service. The requests against the service look like our [REST API](https://docs.microsoft.com/graph/api/overview?view=graph-rest-1.0).

  > **Note**: This SDK offers an asynchronous API by default. Async is a concurrency model that is far more efficient than multi-threading, and can provide significant performance benefits and enable the use of long-lived network connections such as WebSockets. We support popular python async envronments such as `asyncio`, `anyio` or `trio`.

  The following is a complete example that shows how to fetch a user from Microsoft Graph.

  ```py
  import asyncio
  from azure.identity.aio import ClientSecretCredential
  from msgraph_beta import GraphServiceClient

  credential = ClientSecretCredential(
      'tenant_id',
      'client_id',
      'client_secret'
  )
  scopes = ['https://graph.microsoft.com/.default']
  client = GraphServiceClient(credential, scopes=scopes)

  async def get_user():
      user = await client.users.by_user_id('userPrincipalName').get()
      if user:
        print(user.display_name)
  asyncio.run(get_user())
  ```

  Note that to calling `me` requires a signed-in user and therefore delegated permissions. See [Authenticating Users](https://learn.microsoft.com/en-us/python/api/overview/azure/identity-readme?view=azure-python#authenticate-users)) for more:

  ```py
  import asyncio
  from azure.identity import InteractiveBrowserCredential
  from msgraph_beta import GraphServiceClient

  credential = InteractiveBrowserCredential()
  scopes=['User.Read']
  client = GraphServiceClient(credential, scopes=scopes)

  async def me():
      me = await client.me.get()
      if me:
          print(me.display_name)
  asyncio.run(me())
  ```



  Failed requests raise `APIError` exceptions. You can handle these exceptions using `try` `catch` statements.

  ```py
  from kiota_abstractions.api_error import APIError
  async def get_user():
      try:
          user = await client.users.by_user_id('userID').get()
          print(user.user_principal_name, user.display_name, user.id)
      except APIError as e:
          print(f'Error: {e.error.message}')
  asyncio.run(get_user())
  ```



  * [Overview](https://docs.microsoft.com/graph/overview)

  * [Microsoft Graph website](https://aka.ms/graph)

  * [Samples](docs)



  For detailed information on breaking changes, bug fixes and new functionality introduced during major upgrades, check out our [Upgrade Guide](UPGRADING.md)



  View or log issues on the [Issues](https://github.com/microsoftgraph/msgraph-beta-sdk-python/issues) tab in the repo.



  Please read our [Contributing](CONTRIBUTING.md) guidelines carefully for advice on how to contribute to this repo.



  Copyright (c) Microsoft Corporation. All Rights Reserved. Licensed under the MIT [license](LICENSE).

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.



  [Third-party notices](THIRD%20PARTY%20NOTICES)


pkgId: 7a483b9def60a073ecfa8b6e7dd5dcb6db390afa61ebc7c2ce649d457433913e
name: python-msgraph-core-help
arch: noarch
version: 1.1.8
epoch: 0
release: 1
summary: Development documents and examples for msgraph-core
url: https://pypi.org/project/msgraph-core/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msgraph-core-1.1.8-1.src.rpm
location_href: Packages/python-msgraph-core-help-1.1.8-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/msgraph-core.svg)](https://badge.fury.io/py/msgraph-core)
  [![CI Actions Status](https://github.com/microsoftgraph/msgraph-sdk-python-core/actions/workflows/build.yml/badge.svg)](https://github.com/microsoftgraph/msgraph-sdk-python-core/actions/workflows/build.yml)
  [![Downloads](https://pepy.tech/badge/msgraph-core)](https://pepy.tech/project/msgraph-core)



  The Microsoft Graph Core Python Client Library contains core classes used by [Microsoft Graph Python Client Library](https://github.com/microsoftgraph/msgraph-sdk-python) to send native HTTP requests to [Microsoft Graph API](https://graph.microsoft.com).

  > NOTE:
  > This is a new major version of the Python Core library for Microsoft Graph based on the [Kiota](https://microsoft.github.io/kiota/) project. We recommend to use this library with the [full Python SDK](https://github.com/microsoftgraph/msgraph-sdk-python).
  > Upgrading to this version from the [previous version of the Python Core library](https://pypi.org/project/msgraph-core/0.2.2/) will introduce breaking changes into your application.



      Python 3.8+

  This library doesn't support [older](https://devguide.python.org/versions/) versions of Python.





  To call Microsoft Graph, your app must acquire an access token from the Microsoft identity platform. Learn more about this -

  - [Authentication and authorization basics for Microsoft Graph](https://docs.microsoft.com/en-us/graph/auth/auth-concepts)
  - [Register your app with the Microsoft identity platform](https://docs.microsoft.com/en-us/graph/auth-register-app-v2)



  msgraph-core is available on PyPI.

  ```cmd
  pip3 install msgraph-core
  pip3 install azure-identity
  ```



  An instance of the `BaseGraphRequestAdapter` class handles building client. To create a new instance of this class, you need to provide an instance of `AuthenticationProvider`, which can authenticate requests to Microsoft Graph.

  > **Note**: This client library offers an asynchronous API by default. Async is a concurrency model that is far more efficient than multi-threading, and can provide significant performance benefits and enable the use of long-lived network connections such as WebSockets. We support popular python async environments such as `asyncio`, `anyio` or `trio`. For authentication you need to use one of the async credential classes from `azure.identity`.

  ```py



  from azure.identity.aio import EnvironmentCredential
  from msgraph_core.authentication import AzureIdentityAuthenticationProvider

  credential=EnvironmentCredential()
  auth_provider = AzureIdentityAuthenticationProvider(credential)
  ```

  > **Note**: `AzureIdentityAuthenticationProvider` sets the default scopes and allowed hosts.



  ```python
  from msgraph_core import BaseGraphRequestAdapter
  adapter = BaseGraphRequestAdapter(auth_provider)
  ```



  After you have a `BaseGraphRequestAdapter` that is authenticated, you can begin making calls against the service.

  ```python
  import asyncio
  from kiota_abstractions.request_information import RequestInformation

  request_info = RequestInformation()
  request_info.url = 'https://graph.microsoft.com/v1.0/me'


  user = asyncio.run(adapter.send_async(request_info, User, {}))
  print(user.display_name)
  ```



  This library captures metadata by default that provides insights into its usage and helps to improve the developer experience. This metadata includes the `SdkVersion`, `RuntimeEnvironment` and `HostOs` on which the client is running.



  View or log issues on the [Issues](https://github.com/microsoftgraph/msgraph-sdk-python-core/issues) tab in the repo.



  Please see the [contributing guidelines](CONTRIBUTING.md).



  Copyright (c) Microsoft Corporation. All Rights Reserved. Licensed under the MIT [license](LICENSE).

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

rpm_license:
  MIT License  Copyright (c) 2020 Microsoft Graph  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: 433138b662c828fa9d05952e565c4ba26de589386511a6b95bdd37f2cb49180f
name: python-msgraph-sdk-help
arch: noarch
version: 1.15.0
epoch: 0
release: 1
summary: Development documents and examples for msgraph-sdk
url: https://pypi.org/project/msgraph-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msgraph-sdk-1.15.0-1.src.rpm
location_href: Packages/python-msgraph-sdk-help-1.15.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/msgraph-sdk.svg)](https://badge.fury.io/py/msgraph-sdk)
  [![Downloads](https://pepy.tech/badge/msgraph-sdk)](https://pepy.tech/project/msgraph-sdk)
  [![Supported Versions](https://img.shields.io/pypi/pyversions/msgraph-sdk.svg)](https://pypi.org/project/msgraph-sdk)
  [![Contributors](https://img.shields.io/github/contributors/microsoftgraph/msgraph-sdk-python.svg)](https://github.com/microsoftgraph/msgraph-sdk-python/graphs/contributors)

  Get started with the Microsoft Graph SDK for Python by integrating the [Microsoft Graph API](https://docs.microsoft.com/graph/overview) into your Python application.

  > **Note:**
  >
  > * This SDK allows you to build applications using the [v1.0](https://docs.microsoft.com/graph/use-the-api#version) of Microsoft Graph. If you want to try the latest Microsoft Graph APIs, try the [beta](https://github.com/microsoftgraph/msgraph-beta-sdk-python) SDK.



  ```py
  pip install msgraph-sdk
  ```

  > **Note:**
  >
  > * The Microsoft Graph SDK for Python is a fairly large package. It may take a few minutes for the initial installation to complete.
  > * Enable long paths in your environment if you receive a `Could not install packages due to an OSError`. For details, see [Enable Long Paths in Windows 10, Version 1607, and Later](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=powershell#enable-long-paths-in-windows-10-version-1607-and-later).





  Register your application by following the steps at [Register your app with the Microsoft Identity Platform](https://docs.microsoft.com/graph/auth-register-app-v2).



  To start writing code and making requests to the Microsoft Graph service, you need to set up an authentication provider. This object will authenticate your requests to Microsoft Graph. For authentication, the Microsoft Graph Python SDK supports both sync and async credential classes from Azure Identity. Which library to choose depends on the type of application you are building.

  > **Note**: For authentication we support both `sync` and `async` credential classes from `azure.identity`. Please see the azure identity [docs](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity?view=azure-python) for more information.

  The easiest way to filter this decision is by looking at the permissions set you'd use. Microsoft Graph supports 2 different types of permissions: delegated and application permissions:

  * Application permissions are used when you don’t need a user to login to your app, but the app will perform tasks on its own and run in the background.
  * Delegated permissions, also called scopes, are used when your app requires a user to login and interact with data related to this user in a session.

  The following table lists common libraries by permissions set.
  | MSAL library | Permissions set | Common use case |
  |---|---|---|
  | [ClientSecretCredential](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.aio.clientsecretcredential?view=azure-python&preserve-view=true) | Application permissions | Daemon apps or applications running in the background without a signed-in user. |
  | [DeviceCodeCredential](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.devicecodecredential?view=azure-python) | Delegated permissions | Enviroments where authentication is triggered in one machine and completed in another e.g in a cloud server. |
  | [InteractiveBrowserCredentials](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.interactivebrowsercredential?view=azure-python) | Delegated permissions | Environments where a browser is available and the user wants to key in their username/password. |
  | [AuthorizationCodeCredentials](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.authorizationcodecredential?view=azure-python) | Delegated permissions | Usually for custom customer applications where the frontend calls the backend and waits for the authorization code at a particular url. |

  You can also use [EnvironmentCredential](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.environmentcredential?view=azure-python), [DefaultAzureCredential](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.defaultazurecredential?view=azure-python), [OnBehalfOfCredential](https://learn.microsoft.com/en-us/python/api/azure-identity/azure.identity.onbehalfofcredential?view=azure-python), or any other [Azure Identity library](https://learn.microsoft.com/en-us/python/api/overview/azure/identity-readme?view=azure-python#credential-classes).

  Once you've picked an authentication library, we can initiate the authentication provider in your app. The following example uses ClientSecretCredential with application permissions.

  ```python
  import asyncio

  from azure.identity.aio import ClientSecretCredential

  credential = ClientSecretCredential("tenantID",
                                      "clientID",
                                      "clientSecret")
  scopes = ['https://graph.microsoft.com/.default']
  ```

  The following example uses DeviceCodeCredentials with delegated permissions.

  ```python
  import asyncio

  from azure.identity import DeviceCodeCredential

  credential = DeviceCodeCredential("client_id",
                                    "tenant_id")
  scopes = ['https://graph.microsoft.com/.default']
  ```



  You must create **GraphServiceClient** object to make requests against the service. To create a new instance of this class, you need to provide credentials and scopes, which can authenticate requests to Microsoft Graph.

  ```py

  from azure.identity.aio import ClientSecretCredential
  from msgraph import GraphServiceClient

  credentials = ClientSecretCredential(
      'TENANT_ID',
      'CLIENT_ID',
      'CLIENT_SECRET',
  )
  scopes = ['https://graph.microsoft.com/.default']
  client = GraphServiceClient(credentials=credentials, scopes=scopes)
  ```

  The above example uses default scopes for [app-only access](https://learn.microsoft.com/en-us/graph/permissions-overview?tabs=http#application-permissions).  If using [delegated access](https://learn.microsoft.com/en-us/graph/permissions-overview#delegated-permissions) you can provide custom scopes:

  ```py

  from azure.identity import DeviceCodeCredential
  from msgraph import GraphServiceClient

  credentials = DeviceCodeCredential(
      'CLIENT_ID',
      'TENANT_ID',
  )
  scopes = ['https://graph.microsoft.com/.default']
  client = GraphServiceClient(credentials=credentials, scopes=scopes)
  ```

  > **Note**: Refer to the [following documentation page](https://learn.microsoft.com/graph/sdks/customize-client?tabs=python#configuring-the-http-proxy-for-the-client) if you need to configure an HTTP proxy.



  After you have a **GraphServiceClient** that is authenticated, you can begin making calls against the service. The requests against the service look like our [REST API](https://docs.microsoft.com/graph/api/overview?view=graph-rest-1.0).

  > **Note**: This SDK offers an asynchronous API by default. Async is a concurrency model that is far more efficient than multi-threading, and can provide significant performance benefits and enable the use of long-lived network connections such as WebSockets. We support popular python async environments such as `asyncio`, `anyio` or `trio`.

  The following is a complete example that shows how to fetch a user from Microsoft Graph.

  ```py
  import asyncio
  from azure.identity.aio import ClientSecretCredential
  from msgraph import GraphServiceClient

  credential = ClientSecretCredential(
      'tenant_id',
      'client_id',
      'client_secret'
  )
  scopes = ['https://graph.microsoft.com/.default']
  client = GraphServiceClient(credentials=credential, scopes=scopes)


  async def get_user():
      user = await client.users.by_user_id('userPrincipalName').get()
      if user:
          print(user.display_name)
  asyncio.run(get_user())
  ```

  Note that to calling `me` requires a signed-in user and therefore delegated permissions. See [Authenticating Users](https://learn.microsoft.com/en-us/python/api/overview/azure/identity-readme?view=azure-python#authenticate-users) for more:

  ```py
  import asyncio
  from azure.identity import InteractiveBrowserCredential
  from msgraph import GraphServiceClient

  credential = InteractiveBrowserCredential(
      client_id=os.getenv('client_id'),
      tenant_id=os.getenv('tenant_id'),
  )
  scopes = ["User.Read"]
  client = GraphServiceClient(credentials=credential, scopes=scopes,)


  async def me():
      me = await client.me.get()
      if me:
          print(me.display_name)
  asyncio.run(me())
  ```



  Failed requests raise `APIError` exceptions. You can handle these exceptions using `try` `catch` statements.

  ```py
  from kiota_abstractions.api_error import APIError
  async def get_user():
      try:
          user = await client.users.by_user_id('userID').get()
          print(user.user_principal_name, user.display_name, user.id)
      except APIError as e:
          print(f'Error: {e.error.message}')
  asyncio.run(get_user())
  ```



  By default a maximum of 100 rows are returned but in the response if odata_next_link is present, it can be used to fetch the next batch of max 100 rows. Here's an example to fetch the initial rows of members in a group, then iterate over the pages of rows using the odata_next_link

  ```py
          
          members = await client.groups.by_group_id(id).members.get()
          if members:
              print(f"########## Members:")
              for i in range(len(members.value)):
                  print(f"display_name: {members.value[i].display_name}, mail: {members.value[i].mail}, id: {members.value[i].id}")

          
          while members is not None and members.odata_next_link is not None:
              members = await client.groups.by_group_id(id).members.with_url(members.odata_next_link).get()
              if members:
                  print(f"########## Members:")
                  for i in range(len(members.value)):
                      print(f"display_name: {members.value[i].display_name}, mail: {members.value[i].mail}, id: {members.value[i].id}")
  ```



  * [Overview](https://docs.microsoft.com/graph/overview)

  * [Microsoft Graph website](https://aka.ms/graph)

  * [Samples](docs)



  For detailed information on breaking changes, bug fixes and new functionality introduced during major upgrades, check out our [Upgrade Guide](UPGRADING.md)



  View or log issues on the [Issues](https://github.com/microsoftgraph/msgraph-sdk-python/issues) tab in the repo.



  Please read our [Contributing](CONTRIBUTING.md) guidelines carefully for advice on how to contribute to this repo.



  Copyright (c) Microsoft Corporation. All Rights Reserved. Licensed under the MIT [license](LICENSE).

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.



  [Third-party notices](THIRD%20PARTY%20NOTICES)


pkgId: 4d28c5714621099604c66c3a1095f7879004d706559a77776fbe616c1e706a51
name: python-msise00-help
arch: noarch
version: 1.11.1
epoch: 0
release: 1
summary: Development documents and examples for msise00
url: https://pypi.org/project/msise00/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msise00-1.11.1-1.src.rpm
location_href: Packages/python-msise00-help-1.11.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Zenodo DOI](https://zenodo.org/badge/32971905.svg)](https://zenodo.org/badge/latestdoi/32971905)
  [![python](https://github.com/space-physics/msise00/actions/workflows/ci.yml/badge.svg)](https://github.com/space-physics/msise00/actions/workflows/ci.yml)
  [![matlab](https://github.com/space-physics/msise00/actions/workflows/ci-matlab.yml/badge.svg)](https://github.com/space-physics/msise00/actions/workflows/ci-matlab.yml)
  [![PyPi Download stats](http://pepy.tech/badge/msise00)](http://pepy.tech/project/msise00)

  NRL MSISE-00 atmospheric model for Python.
  Also accessible via Matlab.
  Valid from altitude z = 0..1000 km.

  The plot immediately below shows a slice at 200km on a world-wide grid.
  The yellow ball represents the sun footprint on Earth.

  ![MSIS global time animation](./src/msise00/tests/msise00_demo.gif)

  This plot is from [Matlab](./src/msise00/tests/test_msise00_matlab.m) calling MSISE00:

  ![MSISE00 Matlab](./src/msise00/tests/msis_matlab.png)



  * Temperature: degrees Kelvin [K]
  * Density: particles per cubic meter [m^-3]
  * Mass density: kilograms per cubic meter [kg m^-3]



  This process is used for the Python and [Matlab](#matlab) access to MSIS.
  Any Fortran compiler should work.
  Fortran compiler may be installed by

  * MacOS / Homebrew: `brew install gcc`
  * Linux: `apt install gfortran`
  * [Windows](https://www.scivision.dev/install-msys2-windows)

  Get MSISE00 and install Python package:

  ```sh
  pip install msise00
  ```

  or for the latest development code

  ```sh
  git clone https://github.com/space-physics/msise00

  pip install -e msise00
  ```

  optionally check that MSIS is working via:

  ```sh
  pytest msise00
  ```

  This Python module uses our build-on-run technique.
  The first time you use this Python module, you will see messages from the Meson build system.



  MSISE00 can be used from the command line, as an imported module, and even from Matlab.



  ```python
  import msise00
  from datetime import datetime

  atmos = msise00.run(time=datetime(2013, 3, 31, 12), altkm=150., glat=65., glon=-148.)
  ```

  atmos is an
  [xarray.Dataset](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.html)
  containing all the simulation output values.
  `atmos` is 4-D: (time, altitude, lat, lon), and indexed like `atmos['N2']`



  Write NetCDF4 output (HDF5 compatible) with command line argument `-w filename.nc`.

  Simple examples under [Examples/](./Examples)

  * Altitude Profile at a single time:

    ```sh
    msise00 -t 2017-08-21T20:48 -c 40 -90
    ```
  * Alt. profile time-range with hourly time step:

    ```sh
    msise00 -t 2017-08-21 2017-08-22 -c 40 -90
    ```
  * Grid: time,lat,lon: generates the plots in the README:

    ```sh
    msise00 -t 2016-09-20 2016-09-21
    ```
  * single time lat/lon can be plotted:

    ```sh
    msise00 -t 2017-01-02T12
    ```



  Matlab use of MSISE00 is demonstrated in
  [Examples](./Examples/)

  MSISE00 will **automatically compile** "build on run" on first run from Matlab as with Python.

  Optionally, verify Matlab is working by from the top `msise00/` directory in Terminal

  ```sh
  buildtool test
  ```



  Those wishing to use MSIS from a plain Fortran program can do from the top-level msise00/ directory:

  ```sh
  cmake -B build
  cmake --build build
  ```

  optionally:

  ```sh
  ctest --test-dir build
  ```



  * Original fortran [code](https://ccmc.gsfc.nasa.gov/pub/modelweb/atmospheric/msis/)
  * 1200+ citations 2002 [paper](http://onlinelibrary.wiley.com/doi/10.1029/2002JA009430/pdf)


pkgId: 86023a4c4161422b38b582a6eea461a33196ac31e5ff03f6c8927ba795372d29
name: python-mskt-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mskt
url: https://github.com/gattia/pymskt/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mskt-0.1.0-1.src.rpm
location_href: Packages/python-mskt-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)<br>
  ![Build Status](https://github.com/gattia/pymskt/actions/workflows/build-test.yml/badge.svg?branch=main)<br>
  |[Documentation](https://anthonygattiphd.com/pymskt/)|

  pyMSKT is an open-source library for performing quantitative analyses of the musculoskeletal system. It enables creation of surface meshes of musculoskeletal anatomy and then processes these meshes to get quantitative outcomes and visualizatons, like for cartilage thickness.

  <p align="center">
  <img src="./images/whole_knee_1.png" width="300">
  </p>




  ```bash
      
      conda env create -n mskt
      conda activate mskt

      pip install mskt
  ```


  ```bash
      
      git clone https://github.com/gattia/pymskt.git

      
      cd pymskt

      
      conda env create -n mskt
      conda activate mskt

      
      
      pip install -r requirements.txt

      
      pip install .
  ```



  1. Clone this repository & install dependencies: <br>
      ```bash
      
      git clone https://github.com/gattia/pymskt.git

      
      cd pymskt

      
      conda env create -n mskt
      conda activate mskt

      
      conda install --file requirements-conda.txt # pip (below) can alternatively be used to install dependencies in conda env

      
      cd ..

      ```

  2. Clone cycpd & install: (ONLY NEEDED FOR CONDA INSTALL)<br>
      ```bash
      git clone https://github.com/gattia/cycpd.git
      cd cycpd
      pip install .
      cd ..
      ```
  3. Clone pyfocusr & install: (ONLY NEEDED FOR CONDA INSTALL)<br>
      ```bash
      git clone https://github.com/gattia/pyfocusr.git
      cd pyfocusr
      pip install .
      cd ..
      ```
  4. Install pymskt: (ONLY NEEDED FOR CONDA INSTALL)<br>
      ```bash
      cd pymskt
      pip install .
      ```



  If you are using jupyterlab instead of jupyter notebook, you also need to install an extension:
  ```
  jupyter labextension install @jupyter-widgets/jupyterlab-manager jupyter-matplotlib jupyterlab-datawidgets itkwidgets
  ```


  There are jupyter notebook examples in the directory `/examples`

  pyMSKT allows you to easily create bone meshes and attribute cartilage to the bone for calculating quantitative outcomes.

  ```python
  femur = BoneMesh(path_seg_image=location_seg,  # path to the segmentation image being used.
                   label_idx=5,                  # what is the label of this bone.
                   list_cartilage_labels=[1]) # labels for cartilage associted with bone.

  femur.create_mesh()

  femur.calc_cartilage_thickness()
  femur.save_mesh(os.path.expanduser'~/Downloads/femur.vtk')
  ```
  The saved file can be viewed in many mesh viewers such as [3D Slicer](https://www.slicer.org/) or [Paraview](https://www.paraview.org/). Or, better yet they can be viewed in your jupyter notebook using [itkwidgets](https://pypi.org/project/itkwidgets/):
  ```python
  from itkwidgets import view

  view(geometries=[femur.mesh])
  ```

  ![](/images/femur_itkwidgets.png)

  After creating the above mesh, creating cartilage subregions & an anatomical coordinate
  system is as simple as:

  ```python

  seg_image = sitk.ReadImage(location_seg)

  seg_image = mskt.image.cartilage_processing.get_knee_segmentation_with_femur_subregions(seg_image)


  femur.seg_image = seg_image
  femur.list_cartilage_labels=[11, 12, 13, 14, 15]
  femur.assign_cartilage_regions()


  femur_acs = FemurACS(femur, cart_label=(11, 12, 13, 14, 15))
  femur_acs.fit()
  ```

  The resulting anatomical coorindate system can be used to create arrows & visualize the result:

  ```python
  AP_arrow = get_arrow(femur_acs.ap_axis, origin=femur_acs.origin )
  IS_arrow = get_arrow(femur_acs.is_axis, origin=femur_acs.origin)
  ML_arrow = get_arrow(femur_acs.ml_axis, origin=femur_acs.origin)

  view(geometries=[femur.mesh, AP_arrow, IS_arrow, ML_arrow])
  ```
  |*Anatomical Coordinate System - Cartilage Thickness* | *Anatomical Coordinate System - Cartilage Subregions* |
  |:---:       |:---:        |
  |![](/images/femur_acs.png)   | ![](/images/femur_subregions.png) |


  An example of how the cartilage thickness values are computed:

  ![](/images/cartilage_thickness_analysis.png)



  General information for contributing can be found [here](https://github.com/gattia/pymskt/blob/main/CONTRIBUTING.md)


  - Running tests requires pytest (`conda install pytest` or `pip install pytest`)
  - Run tests using `pytest` or `make test` in the home directory.


  - Coverage results/info requires `coverage` (`conda install coverage` or `pip install coverage`)
  - Can get coverage statistics by running:
      - `coverage run -m pytest`
      or if using make:
      - `make coverage`


  - When updating cython code, it is not re-built when we re-install using the basic `python setup.py install`. Therefore we force it to do this:
      - `python setup.py build_ext -i --force`


  If you add a new function, or functionality to `pymskt` please add appropriate tests as well.
  The tests are located in `/testing` and are organized as:
  `/testing/[pymskt_submodule]/[python_filename_being_tested]/[name_of_function_being_tested]_test.py`

  The tests use `pytest`. If you are not familiar with `pytest` a brief example is provided [here](https://docs.pytest.org/en/6.2.x/getting-started.html).

  Currently, 37 tests are being skipped for one of 2 (maybe 3) reasons. 1. They arent implemented yet and they are a placeholder. 2. They rely on a function that has small machine-to-machine differences so they dont pass or 3. A breaking change occured since result meshes were last saved. If you want to help but dont know how or where to start, filling in / fixing these tests would be a great place to start! And greatly appreciated.


  We have adopted the code of conduct defined by the [Contributor Covenant](https://www.contributor-covenant.org) to clarify expected behavior in our community. For more information see the [Code of Conduct](https://github.com/gattia/pymskt/blob/main/CODE_OF_CONDUCT.md).


pkgId: e5d44e2354052000b74d8a5eadbe4b6ae41e58581b34a55994027ccbe6bc62ef
name: python-msteamsnotifiers-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for msteamsnotifiers
url: https://pypi.org/project/msteamsnotifiers/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-msteamsnotifiers-0.3.0-1.src.rpm
location_href: Packages/python-msteamsnotifiers-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  `msteamsnotifiers` makes it easy to automatically send notifications to a channel in MS Teams from Python.
  With the [retirement of Office 365 Connectors](https://devblogs.microsoft.com/microsoft365dev/retirement-of-office-365-connectors-within-microsoft-teams/),
  this library has been updated to use Workflows. Follow the instructions in [this simple, short video](https://www.youtube.com/watch?v=jHTU_jUnswY) to set up the Workflow for your Teams channel. You can then get the webhook URL from the "When a Teams webhook request is received" step of the workflow (it's the auto-generated HTTP POST URL field, which has a handy 'copy' button next to it).

  Install with `pip`:
  ```
  pip install msteamsnotifiers
  ```

  Create a Notifier instance by passing in the webhook URL for your workflow:
  ```python
  from msteamsnotifiers import Notifier
  notifier = Notifier('<your Microsoft webhook URL>')
  ```

  This is the simplest way of posting very simple messages to a channel in MS Teams.
  ```python
  from msteamsnotifiers import Notifier
  notifier = Notifier('<your Microsoft webhook URL>')
  notifier.post_simple_teams_message('Hello channel!')
  notifier.post_simple_teams_message('[Markdown formatting](https://www.markdownguide.org/) is supported.')
  notifier.post_simple_teams_message('This was sent using [msteamsnotifiers](https://pypi.org/project/msteamsnotifiers/)')
  ```

  `@Notifiy.notify_exceptions` is a decorator that will catch any exceptions in the decorated function and send a specially formatted message with details about the exception to a channel.
  ```python
  from msteamsnotifiers import Notifier
  notifier = Notifier('<your Microsoft webhook URL>')
  @notifier.notify_exceptions()
  def fn_with_potential_exception(a, b):
      return a + b

  sum1 = fn_with_potential_exception(1, 2)

  sum2 = fn_with_potential_exception('a', True)
  ```
  The format of the channel notification can be specified using the `template` decorator argument. If no template is specified, the default template is `msteamsnotifiers.default_exception_template`, which includes the full traceback:
  ```python
  default_exception_template = """
  *{timestamp}*
  Exception caught in **{funcname}()**, File **"{filename}"**
  **{message}**
  <br>
  Node: {machine_name} ({ip_address})
  <br>
  ```{where}```
  args: {args}
  kwargs: {kwargs}
  Full traceback:
  ```{traceback}```
  """
  ```
  This package variable can be modified similarly to the `default_webhook_url` parameter.
  The `friendly_tracebacks` module is used to format the included traceback to make it easier to read.

  `@notify_complete` is a decorator that will send a message to a channel upon successful completion of the decorated function.
  ```python
  from msteamsnotifiers import Notifier
  notifier = Notifier('<your Microsoft webhook URL>')
  import time
  @notifier.notify_complete()
  def long_running_function(a, b):
      print('Thinking... thinking... thinking...')
      time.sleep(3600)
      print(f"Aha! The answer is {a+b}!")
      return a + b

  sum1 = long_running_function(1, 2)
  ```
  The format of this message can be specified using the `template` decorator argument. If no template is specified, the default template is `msteamsnotifiers.default_completion_template`:
  ```python
  default_completion_template = """
  *{timestamp}*
  Function completed: **{funcname}()** in file **"{filename}"**
  Node: {machine_name} ({ip_address})
  args: {args}
  kwargs: {kwargs}
  """
  ```


pkgId: fcb12375e9e7508c3f667b98765b85d90b66ce9fa44d6db5e1428c0c14d2f442
name: python-mtbenchmark-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for mtbenchmark
url: https://github.com/AgentGuo/MTB
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mtbenchmark-1.0.0-1.src.rpm
location_href: Packages/python-mtbenchmark-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![WWW](https://img.shields.io/badge/WWW'24-PASS-orange)](https://arxiv.org/pdf/2403.20150.pdf) [![license](https://img.shields.io/github/license/AgentGuo/MTB.svg)](https://img.shields.io/github/license/AgentGuo/MTB.svg) [![Visits Badge](https://badges.pufler.dev/visits/AgentGuo/MTB)](https://badges.pufler.dev/visits/AgentGuo/MTB)





  MTB is a time-series prediction benchmarking
  tool tailored to enterprise scenarios. MTB establishes prediction performance evaluation standards that align with enterprise expectations, enabling a fair comparison of time-series prediction algorithms based on their performance with real enterprise traffic data.



  1. **Install Dependencies**: Ensure you have Python and pip installed. Then, install the required dependencies using:
      ```bash
      pip install -r requirements.txt
      ```

  2. **Load Data**: MTB implements the PyTorch dataset interface, and you can load data using the following code. For more details, refer to `example.py`:
      > The data will be automatically downloaded from Google Drive on the first run, or you can manually download it: [link](https://drive.google.com/drive/folders/1hn4jsjJQmZMAPJV3MKMi5tL5ey_9Spq5?usp=sharing).

      ```python
      train_dataset = mt_dataset.MTDataset(features='svc1', split="train")
      val_dataset = mt_dataset.MTDataset(features='svc1', split="val")
      test_dataset = mt_dataset.MTDataset(features='svc1', split="test")
      ```



  If you find this repo useful, please cite our paper.
  ```
  @inproceedings{guo2024pass,
    title={PASS: Predictive Auto-Scaling System for Large-scale Enterprise Web Applications},
    author={Guo, Yunda and Ge, Jiake and Guo, Panfeng and Chai, Yunpeng and Li, Tao and Shi, Mengnan and Tu, Yang and Ouyang, Jian},
    booktitle={Proceedings of the ACM on Web Conference 2024},
    pages={2747--2758},
    year={2024}
  }
  ```



  This dataset is licensed under the **Creative Commons Attribution 4.0 International License (CC BY 4.0)**.

  You are free to:
  - Share: Copy and redistribute the dataset in any medium or format.
  - Adapt: Remix, transform, and build upon the dataset for any purpose, even commercially.

  **Attribution Requirement**:
  If you use this dataset, please cite it as follows:

  > Dataset Name, Author Name(s), Year. Licensed under CC BY 4.0. [Link to your repository or DOI].

  For full license details, see [CC BY 4.0 License](https://creativecommons.org/licenses/by/4.0/).


pkgId: 0e9cb6a49090ac90e8fc6faa5f3e6c77c22fdef9fc2f56d1af91aff659d01cfe
name: python-mteb-help
arch: noarch
version: 1.24.2
epoch: 0
release: 1
summary: Development documents and examples for mteb
url: https://pypi.org/project/mteb/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mteb-1.24.2-1.src.rpm
location_href: Packages/python-mteb-help-1.24.2-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">Massive Text Embedding Benchmark</h1>

  <p align="center">
      <a href="https://github.com/embeddings-benchmark/mteb/releases">
          <img alt="GitHub release" src="https://img.shields.io/github/release/embeddings-benchmark/mteb.svg">
      </a>
      <a href="https://arxiv.org/abs/2210.07316">
          <img alt="GitHub release" src="https://img.shields.io/badge/arXiv-2305.14251-b31b1b.svg">
      </a>
      <a href="https://github.com/embeddings-benchmark/mteb/blob/master/LICENSE">
          <img alt="License" src="https://img.shields.io/github/license/embeddings-benchmark/mteb.svg?color=green">
      </a>
      <a href="https://pepy.tech/project/mteb">
          <img alt="Downloads" src="https://static.pepy.tech/personalized-badge/mteb?period=total&units=international_system&left_color=grey&right_color=orange&left_text=Downloads">
      </a>
  </p>

  <h4 align="center">
      <p>
          <a href="#installation">Installation</a> |
          <a href="#usage-documentation">Usage</a> |
          <a href="https://huggingface.co/spaces/mteb/leaderboard">Leaderboard</a> |
          <a href="#documentation">Documentation</a> |
          <a href="#citing">Citing</a>
      <p>
  </h4>

  <h3 align="center">
      <a href="https://huggingface.co/spaces/mteb/leaderboard"><img style="float: middle; padding: 10px 10px 10px 10px;" width="60" height="55" src="./docs/images/hf_logo.png" /></a>
  </h3>




  ```bash
  pip install mteb
  ```



  * Using a Python script:

  ```python
  import mteb
  from sentence_transformers import SentenceTransformer


  model_name = "average_word_embeddings_komninos"

  model = mteb.get_model(model_name) # if the model is not implemented in MTEB it will be eq. to SentenceTransformer(model_name)
  tasks = mteb.get_tasks(tasks=["Banking77Classification"])
  evaluation = mteb.MTEB(tasks=tasks)
  results = evaluation.run(model, output_folder=f"results/{model_name}")
  ```

  <details>
    <summary> Running SentenceTransformer model with prompts </summary>

  Prompts can be passed to the SentenceTransformer model using the `prompts` parameter. The following code shows how to use prompts with SentenceTransformer:

  ```python
  from sentence_transformers import SentenceTransformer


  model = SentenceTransformer("average_word_embeddings_komninos", prompts={"query": "Query:", "passage": "Passage:"})
  evaluation = mteb.MTEB(tasks=tasks)
  ```

  In prompts the key can be:
  1. Prompt types (`passage`, `query`) - they will be used in reranking and retrieval tasks
  2. Task type - these prompts will be used in all tasks of the given type
     1. `BitextMining`
     2. `Classification`
     3. `MultilabelClassification`
     4. `Clustering`
     5. `PairClassification`
     6. `Reranking`
     7. `Retrieval`
     8. `STS`
     9. `Summarization`
     10. `InstructionRetrieval`
  3. Pair of task type and prompt type like `Retrival-query` - these prompts will be used in all classification tasks
  4. Task name - these prompts will be used in the specific task
  5. Pair of task name and prompt type like `NFCorpus-query` - these prompts will be used in the specific task
  </details>

  * Using CLI

  ```bash
  mteb available_tasks

  mteb run -m sentence-transformers/all-MiniLM-L6-v2 \
      -t Banking77Classification  \
      --verbosity 3


  ```

  * Using multiple GPUs in parallel can be done by just having a custom encode function that distributes the inputs to multiple GPUs like e.g. [here](https://github.com/microsoft/unilm/blob/b60c741f746877293bb85eed6806736fc8fa0ffd/e5/mteb_eval.py#L60) or [here](https://github.com/ContextualAI/gritlm/blob/09d8630f0c95ac6a456354bcb6f964d7b9b6a609/gritlm/gritlm.py#L75).




  Click on each section below to see the details.

  <br />

  <details>
    <summary>  Task selection </summary>



  Tasks can be selected by providing the list of datasets, but also

  * by their task (e.g. "Clustering" or "Classification")

  ```python
  tasks = mteb.get_tasks(task_types=["Clustering", "Retrieval"]) # Only select clustering and retrieval tasks
  ```

  * by their categories e.g. "s2s" (sentence to sentence) or "p2p" (paragraph to paragraph)

  ```python
  tasks = mteb.get_tasks(categories=["s2s", "p2p"]) # Only select sentence2sentence and paragraph2paragraph datasets
  ```

  * by their languages

  ```python
  tasks = mteb.get_tasks(languages=["eng", "deu"]) # Only select datasets which contain "eng" or "deu" (iso 639-3 codes)
  ```

  You can also specify which languages to load for multilingual/cross-lingual tasks like below:

  ```python
  import mteb

  tasks = [
      mteb.get_task("AmazonReviewsClassification", languages = ["eng", "fra"]),
      mteb.get_task("BUCCBitextMining", languages = ["deu"]), # all subsets containing "deu"
  ]


  from mteb.tasks import AmazonReviewsClassification, BUCCBitextMining

  evaluation = mteb.MTEB(tasks=[
          AmazonReviewsClassification(hf_subsets=["en", "fr"]) # Only load "en" and "fr" subsets of Amazon Reviews
          BUCCBitextMining(hf_subsets=["de-en"]), # Only load "de-en" subset of BUCC
  ])

  ```

  </details>

  <details>
    <summary>  Running a benchmark </summary>



  `mteb` comes with a set of predefined benchmarks. These can be fetched using `get_benchmark` and run in a similar fashion to other sets of tasks.
  For instance to select the 56 English datasets that form the "Overall MTEB English leaderboard":

  ```python
  import mteb
  benchmark = mteb.get_benchmark("MTEB(eng, classic)")
  evaluation = mteb.MTEB(tasks=benchmark)
  ```

  The benchmark specified not only a list of tasks, but also what splits and language to run on. To get an overview of all available benchmarks simply run:

  ```python
  import mteb
  benchmarks = mteb.get_benchmarks()
  ```

  Generally we use the naming scheme for benchmarks `MTEB(*)`, where the "*" denotes the target of the benchmark. In the case of a language, we use the three-letter language code. For large groups of languages, we use the group notation, e.g., `MTEB(Scandinavian)` for Scandinavian languages. External benchmarks implemented in MTEB like `CoIR` use their original name. When using a benchmark from MTEB please cite `mteb` along with the citations of the benchmark which you can access using:

  ```python
  benchmark.citation
  ```

  </details>

  <details>
    <summary>  Passing in `encode` arguments </summary>




  To pass in arguments to the model's `encode` function, you can use the encode keyword arguments (`encode_kwargs`):

  ```python
  evaluation.run(model, encode_kwargs={"batch_size": 32})
  ```
  </details>


  <details>
    <summary>  Selecting evaluation split </summary>


  You can evaluate only on `test` splits of all tasks by doing the following:

  ```python
  evaluation.run(model, eval_splits=["test"])
  ```

  Note that the public leaderboard uses the test splits for all datasets except MSMARCO, where the "dev" split is used.

  </details>

  <details>
    <summary>  Using a custom model </summary>




  Models should implement the following interface, implementing an `encode` function taking as inputs a list of sentences, and returning a list of embeddings (embeddings can be `np.array`, `torch.tensor`, etc.). For inspiration, you can look at the [mteb/mtebscripts repo](https://github.com/embeddings-benchmark/mtebscripts) used for running diverse models via SLURM scripts for the paper.

  ```python
  import mteb
  from mteb.encoder_interface import PromptType
  import numpy as np


  class CustomModel:
      def encode(
          self,
          sentences: list[str],
          task_name: str,
          prompt_type: PromptType | None = None,
          **kwargs,
      ) -> np.ndarray:
          """Encodes the given sentences using the encoder.

          Args:
              sentences: The sentences to encode.
              task_name: The name of the task.
              prompt_type: The prompt type to use.
              **kwargs: Additional arguments to pass to the encoder.

          Returns:
              The encoded sentences.
          """
          pass

  model = CustomModel()
  tasks = mteb.get_tasks(tasks=["Banking77Classification"])
  evaluation = MTEB(tasks=tasks)
  evaluation.run(model)
  ```

  </details>

  <details>
    <summary>  Evaluating on a custom dataset </summary>




  To evaluate on a custom task, you can run the following code on your custom task. See [how to add a new task](docs/adding_a_dataset.md), for how to create a new task in MTEB.

  ```python
  from mteb import MTEB
  from mteb.abstasks.AbsTaskReranking import AbsTaskReranking
  from sentence_transformers import SentenceTransformer


  class MyCustomTask(AbsTaskReranking):
      ...

  model = SentenceTransformer("average_word_embeddings_komninos")
  evaluation = MTEB(tasks=[MyCustomTask()])
  evaluation.run(model)
  ```

  </details>

  <details>
    <summary>  Using a cross encoder for reranking</summary>




  To use a cross encoder for reranking, you can directly use a CrossEncoder from SentenceTransformers. The following code shows a two-stage run with the second stage reading results saved from the first stage.

  ```python
  from mteb import MTEB
  import mteb
  from sentence_transformers import CrossEncoder, SentenceTransformer

  cross_encoder = CrossEncoder("cross-encoder/ms-marco-TinyBERT-L-2-v2")
  dual_encoder = SentenceTransformer("all-MiniLM-L6-v2")

  tasks = mteb.get_tasks(tasks=["NFCorpus"], languages=["eng"])

  subset = "default" # subset name used in the NFCorpus dataset
  eval_splits = ["test"]

  evaluation = MTEB(tasks=tasks)
  evaluation.run(
      dual_encoder,
      eval_splits=eval_splits,
      save_predictions=True,
      output_folder="results/stage1",
  )
  evaluation.run(
      cross_encoder,
      eval_splits=eval_splits,
      top_k=5,
      save_predictions=True,
      output_folder="results/stage2",
      previous_results=f"results/stage1/NFCorpus_{subset}_predictions.json",
  )
  ```

  </details>

  <details>
    <summary>  Saving retrieval task predictions </summary>



  To save the predictions from a retrieval task, add the `--save_predictions` flag in the CLI or set `save_predictions=True` in the run method. The filename will be in the "{task_name}_{subset}_predictions.json" format.

  Python:
  ```python
  from mteb import MTEB
  import mteb
  from sentence_transformers import SentenceTransformer

  model = SentenceTransformer("all-MiniLM-L6-v2")

  tasks = mteb.get_tasks(tasks=["NFCorpus"], languages=["eng"])

  evaluation = MTEB(tasks=tasks)
  evaluation.run(
      model,
      eval_splits=["test"],
      save_predictions=True,
      output_folder="results",
  )
  ```

  CLI:
  ```bash
  mteb run -t NFCorpus -m all-MiniLM-L6-v2 --output_folder results --save_predictions
  ```

  </details>

  <details>
    <summary> Fetching result from the results repository </summary>



  Multiple models have already been run on tasks available within MTEB. These results are available results [repository](https://github.com/embeddings-benchmark/results).

  To make the results more easily accessible, we have designed custom functionality for retrieving from the repository. For instance, if you are selecting the best model for your French and English retrieval task on legal documents you could fetch the relevant tasks and create a dataframe of the results using the following code:

  ```python
  import mteb
  from mteb.task_selection import results_to_dataframe

  tasks = mteb.get_tasks(
      task_types=["Retrieval"], languages=["eng", "fra"], domains=["Legal"]
  )

  model_names = [
      "GritLM/GritLM-7B",
      "intfloat/multilingual-e5-small",
      "intfloat/multilingual-e5-base",
      "intfloat/multilingual-e5-large",
  ]
  models = [mteb.get_model_meta(name) for name in model_names]

  results = mteb.load_results(models=models, tasks=tasks)

  df = results_to_dataframe(results)
  ```

  </details>


  <details>
    <summary>  Annotate Contamination in the training data of a model  </summary>



  have your found contamination in the training data of a model? Please let us know, either by opening an issue or ideally by submitting a PR
  annotatig the training datasets of the model:

  ```py
  model_w_contamination = ModelMeta(
      name = "model-with-contamination"
      ...
      training_datasets: {"ArguAna": # name of dataset within MTEB
                          ["test"]} # the splits that have been trained on
      ...
  )
  ```


  </details>

  <details>
    <summary>  Caching Embeddings To Re-Use Them </summary>




  There are times you may want to cache the embeddings so you can re-use them. This may be true if you have multiple query sets for the same corpus (e.g. Wikipedia) or are doing some optimization over the queries (e.g. prompting, other experiments). You can setup a cache by using a simple wrapper, which will save the cache per task in the `cache_embeddings/{task_name}` folder:

  ```python

  ...

  from mteb.models.cache_wrapper import CachedEmbeddingWrapper
  model_with_cached_emb = CachedEmbeddingWrapper(model, cache_path='path_to_cache_dir')

  evaluation.run(model, ...)
  ```

  </details>

  <br />





  | Documentation                  |                        |
  | ------------------------------ | ---------------------- |
  | 📋 [Tasks] | Overview of available tasks |
  | 📐 [Benchmarks] | Overview of available benchmarks |
  | 📈 [Leaderboard] | The interactive leaderboard of the benchmark |
  | 🤖 [Adding a model] | Information related to how to submit a model to the leaderboard |
  | 👩‍🔬 [Reproducible workflows] | Information related to how to reproduce and create reproducible workflows with MTEB |
  | 👩‍💻 [Adding a dataset] | How to add a new task/dataset to MTEB | 
  | 👩‍💻 [Adding a leaderboard tab] | How to add a new leaderboard tab to MTEB | 
  | 🤝 [Contributing] | How to contribute to MTEB and set it up for development |
  | 🌐 [MMTEB] | An open-source effort to extend MTEB to cover a broad set of languages |  

  [Tasks]: docs/tasks.md
  [Benchmarks]: docs/benchmarks.md
  [Contributing]: CONTRIBUTING.md
  [Adding a model]: docs/adding_a_model.md
  [Adding a dataset]: docs/adding_a_dataset.md
  [Adding a leaderboard tab]: docs/adding_a_leaderboard_tab.md
  [Leaderboard]: https://huggingface.co/spaces/mteb/leaderboard
  [MMTEB]: docs/mmteb/readme.md
  [Reproducible workflows]: docs/reproducible_workflow.md



  MTEB was introduced in "[MTEB: Massive Text Embedding Benchmark](https://arxiv.org/abs/2210.07316)", feel free to cite:

  ```bibtex
  @article{muennighoff2022mteb,
    doi = {10.48550/ARXIV.2210.07316},
    url = {https://arxiv.org/abs/2210.07316},
    author = {Muennighoff, Niklas and Tazi, Nouamane and Magne, Lo{\"\i}c and Reimers, Nils},
    title = {MTEB: Massive Text Embedding Benchmark},
    publisher = {arXiv},
    journal={arXiv preprint arXiv:2210.07316},
    year = {2022}
  }
  ```

  You may also want to read and cite the amazing work that has extended MTEB & integrated new datasets:
  - Shitao Xiao, Zheng Liu, Peitian Zhang, Niklas Muennighoff. "[C-Pack: Packaged Resources To Advance General Chinese Embedding](https://arxiv.org/abs/2309.07597)" arXiv 2023
  - Michael Günther, Jackmin Ong, Isabelle Mohr, Alaeddine Abdessalem, Tanguy Abel, Mohammad Kalim Akram, Susana Guzman, Georgios Mastrapas, Saba Sturua, Bo Wang, Maximilian Werk, Nan Wang, Han Xiao. "[Jina Embeddings 2: 8192-Token General-Purpose Text Embeddings for Long Documents](https://arxiv.org/abs/2310.19923)" arXiv 2023
  - Silvan Wehrli, Bert Arnrich, Christopher Irrgang. "[German Text Embedding Clustering Benchmark](https://arxiv.org/abs/2401.02709)" arXiv 2024
  - Orion Weller, Benjamin Chang, Sean MacAvaney, Kyle Lo, Arman Cohan, Benjamin Van Durme, Dawn Lawrie, Luca Soldaini. "[FollowIR: Evaluating and Teaching Information Retrieval Models to Follow Instructions](https://arxiv.org/abs/2403.15246)" arXiv 2024
  - Dawei Zhu, Liang Wang, Nan Yang, Yifan Song, Wenhao Wu, Furu Wei, Sujian Li. "[LongEmbed: Extending Embedding Models for Long Context Retrieval](https://arxiv.org/abs/2404.12096)" arXiv 2024
  - Kenneth Enevoldsen, Márton Kardos, Niklas Muennighoff, Kristoffer Laigaard Nielbo. "[The Scandinavian Embedding Benchmarks: Comprehensive Assessment of Multilingual and Monolingual Text Embedding](https://arxiv.org/abs/2406.02396)" arXiv 2024

  For works that have used MTEB for benchmarking, you can find them on the [leaderboard](https://huggingface.co/spaces/mteb/leaderboard).

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


pkgId: 2fea408d7ad65a141ae4a4d422e1ff83eef2eeda6176f5db61b787fcdb036843
name: python-mth5-help
arch: noarch
version: 0.4.10
epoch: 0
release: 1
summary: Development documents and examples for mth5
url: https://github.com/kujaku11/mth5
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mth5-0.4.10-1.src.rpm
location_href: Packages/python-mth5-help-0.4.10-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi Version](https://img.shields.io/pypi/v/mth5.svg)](https://pypi.python.org/pypi/mth5)
  [![Conda Version](https://img.shields.io/conda/v/conda-forge/mth5.svg)](https://anaconda.org/conda-forge/mth5)
  [![MIT License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://code.chs.usgs.gov/jpeacock/mth5/-/new/master/LICENSE)
  [![Documentation Status](https://readthedocs.org/projects/mth5/badge/?version=latest)](https://mth5.readthedocs.io/en/latest/?badge=latest)
  [![](https://codecov.io/gh/kujaku11/mth5/branch/master/graph/badge.svg?token=XU5QSRM1ZO)](https://codecov.io/gh/kujaku11/mth5)\
  [![](https://zenodo.org/badge/283883448.svg)](https://zenodo.org/badge/latestdoi/283883448)
  [![](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/kujaku11/mth5/master)
  MTH5 is an HDF5 data container for magnetotelluric time series data, but could be extended to other data types.  This package provides tools for reading/writing/manipulating MTH5 files.
  MTH5 uses [h5py](https://www.h5py.org/) to interact with the HDF5 file, [xarray](http://xarray.pydata.org/en/stable/) to interact with the data in a nice way, and all metadata use [mt_metadata](https://github.com/kujaku11/mt_metadata).
  This project is in cooperation with the Incorporated Research Institutes of Seismology, the U.S. Geological Survey, and other collaborators.  Facilities of the IRIS Consortium are supported by the National Science Foundationâ€™s Seismological Facilities for the Advancement of Geoscience (SAGE) Award under Cooperative Support Agreement EAR-1851048.  USGS is partially funded through the Community for Data Integration and IMAGe through the Minerals Resources Program.
  * **Version**: 0.4.10
  * **Free software**: MIT license
  * **Documentation**: https://mth5.readthedocs.io.
  * **Examples**: Click the `Binder` badge above and Jupyter Notebook examples are in **docs/examples/notebooks**
  * **Suggested Citation**: Peacock, J. R., Kappler, K., Ronan, T., Heagy, L.,  Kelbert, A., Frassetto, A. (2022) MTH5: An archive and exchangeable data format for magnetotelluric time series data, *Computers & Geoscience*, **162**, doi:10.1016/j.cageo.2022.105102


pkgId: ff1be52e8a978767533d9d190f4653e6b1a31e323b91108689a45891198cf929
name: python-mtmlib-help
arch: noarch
version: 0.4.169
epoch: 0
release: 1
summary: Development documents and examples for mtmlib
url: https://pypi.org/project/mtmlib/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mtmlib-0.4.169-1.src.rpm
location_href: Packages/python-mtmlib-help-0.4.169-1.noarch.rpm
checksum_type: sha256
description:
  This is a collection of examples for [writing Cloudflare Workers in Python](https://developers.cloudflare.com/workers/languages/python). Use these examples to learn how Python Workers work.



  1. `git clone https://github.com/cloudflare/python-workers-examples`
  2. `cd hello`
  3. `npx wrangler@latest dev`
  4. Press the `b` key to open a browser tab, and make a request to your Worker

  You can run `npx wrangler@latest dev` in any example project directory to run a local development server using [Wrangler](https://developers.cloudflare.com/workers/wrangler/), the CLI for Cloudflare Workers. This local development server is powered by [workerd](https://github.com/cloudflare/workerd), the open-source Workers runtime.

  Need to deploy your Worker to Cloudflare? Python Workers are in open beta and have a few [limitations](#open-beta-and-limits).



  - [**`01-hello/`**](01-hello) — the most basic Python Worker
  - [**`02-binding/`**](02-binding) — shows how [bindings](https://developers.cloudflare.com/workers/configuration/bindings/) work in Python Workers. Put a key into Workers KV, and then read it.
  - [**`03-fastapi/`**](03-fastapi) — demonstrates how to use the [FastAPI](https://fastapi.tiangolo.com/) package with Python Workers
  - [**`04-langchain/`**](04-langchain) — demonstrates how to use the [LangChain](https://pypi.org/project/langchain/) package with Python Workers



  - Python Workers are in open beta. Currently, you can only deploy Python Workers that use the standard library. [Packages](https://developers.cloudflare.com/workers/languages/python/packages/#supported-packages) **cannot be deployed** and will only work in local development for the time being.
  - You must add the `python_workers` compatibility flag to your Worker, while Python Workers are in open beta.

  We’d love your feedback. Join the `#python-workers channel` in the [Cloudflare Developers Discord](https://discord.cloudflare.com/) and let us know what you’d like to see next.



  The [Apache 2.0 license](LICENSE).


pkgId: 71c0c11ac728017e055a8fd4a8d80eb0bf60e9c83238bbdfb46a9063bb9fbe24
name: python-mtproto-help
arch: noarch
version: 0.1.0b3
epoch: 0
release: 1
summary: Development documents and examples for mtproto
url: https://github.com/RuslanUC/mtproto
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mtproto-0.1.0b3-1.src.rpm
location_href: Packages/python-mtproto-help-0.1.0b3-1.noarch.rpm
checksum_type: sha256
description:
  This is a Telegram MTProto protocol library inspired by [h11](https://github.com/python-hyper/h11).

  This library implements the following MTProto transports:
  - Abridged
  - Intermediate
  - Padded Intermediate
  - Full
  - Obfuscated versions of all above (except Full)


  ```shell
  pip install mtproto
  ```
  Note that in order to use obfuscated transports or encrypt/decrypt mtproto messages,
  you MUST specify at least one (if you install both, only tgcrypto will be used)
  a crypto library in square brackets (currently tgcrypto and pyaes are supported):
  ```shell
  pip install mtproto[tgcrypto]
  ```
  or
  ```shell
  pip install mtproto[pyaes]
  ```


  ```python
  from os import urandom

  from mtproto import Connection, ConnectionRole
  from mtproto.transports import IntermediateTransport
  from mtproto.packets import UnencryptedMessagePacket

  conn = Connection(
      ConnectionRole.CLIENT,
      
      
      transport_cls=IntermediateTransport,
      
      transport_obf=False,
  )

  to_send = conn.send(UnencryptedMessagePacket(
      message_id=123456789,
      message_data=b"\xbe\x7e\x8e\xf1"[::-1] + urandom(16)  # req_pq_multi#be7e8ef1 nonce:int128
  ))


  ...

  received = ...
  packet = conn.receive(received)

  print(packet)

  ```


pkgId: d13f0e8d7ebb53ca92fe51ed47b1036afc881c8015daca50c5cf0c5952a3a58e
name: python-mtunn-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for mtunn
url: https://github.com/mishakorzik/mtunn
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mtunn-1.2.0-1.src.rpm
location_href: Packages/python-mtunn-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <img width="99.9%" src="https://raw.githubusercontent.com/mishakorzik/mtunn/refs/heads/main/Logo.jpg"/>

  <p align="center">
  <a href="https://github.com/mishakorzik/mtunn"><img title="Version" src="https://img.shields.io/badge/Build-stable-cornflowerblue?style=for-the-badge&logo="></a>
  <a href="https://github.com/mishakorzik/mtunn/blob/main/LICENSE"><img title="License" src="https://img.shields.io/badge/Apache-License 2.0-blue?style=for-the-badge&logo=apache"></a>
  <a href="https://github.com/mishakorzik"><img title="Made in Ukraine" src="https://img.shields.io/badge/Made in-Ukraine-steelblue?style=for-the-badge&logo="></a>
  <a href="https://github.com/mishakorzik"><img title="Copyring" src="https://img.shields.io/badge/Copyring-2024-skyblue?style=for-the-badge&logo=github"></a>
  <a href="https://github.com/mishakorzik"><img title="Author" src="https://img.shields.io/badge/Author-mishakorzik-lightblue?style=for-the-badge&logo=github"></a>
  </p>

  <p align="center">
  • <a href="https://github.com/mishakorzik/mtunn/blob/main/LICENSE">License</a>
  • <a href="https://github.com/mishakorzik/mtunn/blob/main/mtunn">Source code</a>
  • <a href="https://www.buymeacoffee.com/misakorzik">Donate</a>
  • <a href="https://github.com/mishakorzik/mtunn/issues">Issues</a> •
  </p>

  >  with «make tunnel» you can easily open http and tcp ports to the internet.



  Install the package from the `PyPi`:
  ```
  pip install mtunn
  ```

  Install the package from the `GitHub`:
  ```
  git clone https://github.com/mishakorzik/mtunn
  cd mtunn
  python3 setup.py install
  ```

  Want to learn more about the tunnel update?
  Then check out the details **[here](https://github.com/mishakorzik/mtunn/blob/main/FEATURES.md)**



  In order to start the tunnel, you need to log in to your account and create a configuration file.

  ```yaml
  proto: tcp                # protocol type                        (http/tcp)
  target: 127.0.0.1:25565   # target host
  tunnel: 10000             # port that will be opened
  domain: none              # domain to your tunnel
  console: true             # for tunnel control                   (true/false)
  firewall:
    whitelist: ["UA", "PL"] # whitelist only for asn and countries
    blacklist: ["AS12345"]  # blacklist only for asn and countries
    services:
      vpn: allow            # connection to tunnel from vpn        (allow/deny)
      tor: deny             # connectiom to tunnel from tor        (allow/deny)
    protection:
      level: 3              # set anti ddos protection level       (0-5)
  network:
    threading: true         # use multi threading                  (true/false)
    bandwidth: nolimit      # limit bandwidth                      (ex. 20 mbits, 5 mbytes)
    data:
      compression: false    # use traffic compression              (true/false)
      algorithm: zlib       # set compression algorithm            (zlib/gzip/lzma)
  ping:
    method: icmp            # ping method                          (icmp/tcp)
  ```

  <details id="missing-code-coverage">
    <summary>frequently asked questions</summary>

  **1) What to do if I don't have a domain?**
  - No need to worry, you can run tunnel without a domain just by specifying “none” in the “domain” field.

  **2) if I have a domain, how do i connect it?**
  - Using a domain is quite simple, you just need to specify your domain in the "domain" field and specify the A and AAAA record in the ip address of the tunnel.

  - Please note that if the tunnel does not have IPv6, you do not need to specify an AAAA record for the tunnel's IP address.

  **3) What ping method is the best?**
  - Both options are best, we added the tcp method so that you can know the delay point without the ping command. If you are not sure about choosing icmp or tcp, you can simply not specify, the tunnel will choose automatically.

  **4) Do I need to enable multi threading?**
  - Enabling multithreading in tunnels allows for the simultaneous processing of multiple connections, enhancing performance and reducing latency. This ensures stable data transmission and reliable tunnel operation even under high load. We recommend to enable it.
  </details>

  If you have the correct configuration, you will be able to start the tunnel and everything will work.



  Instead of the name of the example.yml file, you can write your configuration name, but it must have the extension “.yml”.

  ```python

  python3 -m mtunn --version


  python3 -m mtunn --account


  python3 -m mtunn --console


  python3 -m mtunn --config example.yml


  python3 -m mtunn --nodebug --config example.yml



  python3 -m mtunn --fastrun 'from:8080 to:10000 proto:http'
  ```

  When you register you can run tunnels but only on ports in the range from 10000 to 11000. You can change it in your quota settings.



  **Scan all active tunnels on localhost (if enabled console)**
  ```python
  >>> import mtunn
  >>> mtunn.api.scan()
  [{'remote': 'he1zen-de1.hopto.org:10000', 'local': '127.0.0.1:25565', 'console': 7010}]
  >>>
  ```

  **Execute commands on active tunnel (if enabled console)**
  ```python
  >>> import mtunn
  >>> mtunn.api.execute(7010, "latency")
  '{"address": "185.14.92.125", "method": "icmp", "time": "27.1ms"}'
  >>>
  ```

  * All commands that are in the console are also in the API and they are the same.

  * To execute the command you only need to know the port from the console. you can find it by scanning all consoles.

  * Also, the console is only available on the local network (127.0.0.1), you won't be able to launch it remotely.



  Here are examples of how to run and how the tunnel will work.

  <img width="48.9%" src="https://raw.githubusercontent.com/mishakorzik/mtunn/refs/heads/main/IMG_20241116_2.jpg"/> <img width="49.9%" src="https://raw.githubusercontent.com/mishakorzik/mtunn/refs/heads/main/IMG_20241116_3.jpg"/>
  <img width="47.5%" src="https://raw.githubusercontent.com/mishakorzik/mtunn/refs/heads/main/IMG_20241116_1.jpg"/> <img width="51.4%" src="https://raw.githubusercontent.com/mishakorzik/mtunn/refs/heads/main/IMG_20241116_4.jpg"/>

  In order to open ports through the tunnel you need to create a configuration file.



  [![Github](https://img.shields.io/badge/TELEGRAM-MishaKorzhik-orange?style=for-the-badge&logo=telegram)](https://t.me/ubp2q)
  [![Github](https://img.shields.io/badge/Discord-He1Zen-blue?style=for-the-badge&logo=discord)](https://discord.gg/xwpMuMYW57)

  If you find a bug or have any questions about this project, write to us on discord.


pkgId: 954047bf882f859b87aa008859b139ba0c3d6bbc5b8f8c6d0b48b11c97ba1619
name: python-mucklas-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mucklas
url: https://github.com/LukasGold/mucklas
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mucklas-0.1.0-1.src.rpm
location_href: Packages/python-mucklas-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

  [![Built Status](https://api.cirrus-ci.com/github/<USER>/mucklas.svg?branch=main)](https://cirrus-ci.com/github/<USER>/mucklas)
  [![ReadTheDocs](https://readthedocs.org/projects/mucklas/badge/?version=latest)](https://mucklas.readthedocs.io/en/stable/)
  [![Coveralls](https://img.shields.io/coveralls/github/<USER>/mucklas/main.svg)](https://coveralls.io/r/<USER>/mucklas)
  [![PyPI-Server](https://img.shields.io/pypi/v/mucklas.svg)](https://pypi.org/project/mucklas/)
  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/mucklas.svg)](https://anaconda.org/conda-forge/mucklas)
  [![Monthly Downloads](https://pepy.tech/badge/mucklas/month)](https://pepy.tech/project/mucklas)
  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/mucklas)
  -->

  [![Project generated with PyScaffold](https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold)](https://pyscaffold.org/)



  > A collection of useful (Python) functions and concepts. Something you can discover if you look closely - just
  > like the fictional creatures of the same name in Sven Nordqvist's Swedish books 'Pettson och Findus'.

  This is a collection that is organized in a way that makes it easy to discover and use the functions and concepts.
  The collection can be installed as a dependency into projects.



  ```bash
  pip install mucklas
  ```



  The collection is organized in modules. Each module contains a set of functions and concepts that are related to
  each other and have a common theme. The modules are:

  - [`mucklas.dataclasses`](docs/dataclasses.md): A collection of functions to work with dataclasses, e.g., for defining typed param
    objects
    to pass to functions.








  <!-- pyscaffold-notes -->



  This project has been set up using PyScaffold 4.6. For details and usage
  information on PyScaffold see https://pyscaffold.org/.


pkgId: 3587c83efbdbdce9868d013aad29f3d5998971b80e88c7d3bbcdd518c50dc15c
name: python-mugideploy-help
arch: noarch
version: 0.0.26
epoch: 0
release: 1
summary: Development documents and examples for mugideploy
url: https://github.com/mugiseyebrows/mugideploy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mugideploy-0.0.26-1.src.rpm
location_href: Packages/python-mugideploy-help-0.0.26-1.noarch.rpm
checksum_type: sha256
description:
  mugideploy is C++ deploy utility similar to ldd. It reads info about dynamically linked libraries stored in PE file headers and can:

  1) copy all necessary binaries into `name-version-arch` directory (create distribution)

  2) copy linked libraries into specified directory

  3) create inno setup script to build exe installer

  4) print this info in various forms



  ```shell
  mugideploy collect --version 0.0.1 --bin Release\imgzip.exe --plugins imageformats
  ```

  creates `imgzip-0.0.1-win64` directory and copies `Release\imgzip.exe` and dependencies there

  ```
  options:
    --name NAME                                     App name
    --version VERSION                               App version
    --bin BIN [BIN ...]                             Binaries (dlls, exes)
    --data DATA [DATA ...]                          Path to data dirs and files
    --plugins PLUGINS [PLUGINS ...]                 Plugin names
    --plugins-path PLUGINS_PATH [PLUGINS_PATH ...]  Path to plugins
    --dst DST                                       Destination path or path template
    --vcredist VCREDIST                             Path to Microsoft Visual C++ Redistributable
    --ace ACE                                       Path to Access Database Engine
    --system                                        Include system dlls
    --vcruntime                                     Include vcruntime dlls
    --msapi                                         Include msapi dlls
    --unix-dirs                                     bin var etc dirs
    --src SRC                                       Path to sources
    --version-header VERSION_HEADER                 Path to version header
    --dry-run                                       Do not copy files
    --zip                                           Zip collected
  ```



  ```shell
  mugideploy copy-dep --bin C:\qt\6.8.1\mingw_64\bin\qmake.exe --dst C:\qt\6.8.1\mingw_64\bin
  ```

  copies dlls into dst directory

  ```
  options:
    --bin BIN [BIN ...]                             Binaries (dlls, exes)
    --plugins PLUGINS [PLUGINS ...]                 Plugin names
    --plugins-path PLUGINS_PATH [PLUGINS_PATH ...]  Path to plugins
    --dst DST                                       Destination path or path template
    --system                                        Include system dlls
    --vcruntime                                     Include vcruntime dlls
    --msapi                                         Include msapi dlls
    --dry-run                                       Do not copy files
  ```



  ```shell
  mugideploy inno-script --bin Release\imgzip.exe --plugins imageformats --data changelog.json -o setup.iss
  ```

  creates `setup.iss`

  ```
  options:
    --bin BIN [BIN ...]                             Binaries (dlls, exes)
    --plugins PLUGINS [PLUGINS ...]                 Plugin names
    --plugins-path PLUGINS_PATH [PLUGINS_PATH ...]  Path to plugins
    --system                                        Include system dlls
    --vcruntime                                     Include vcruntime dlls
    --msapi                                         Include msapi dlls
    --dry-run                                       Do not copy files
    --output-dir OUTPUT_DIR                         Inno setup script output dir
    -o OUTPUT, --output OUTPUT                      Path to save file
  ```



  ```shell
  mugideploy list --bin Release\imgzip.exe --plugins imageformats 2> NUL
  ```
  prints linked libraries as a list

  ```shell
  mugideploy json --bin Release\imgzip.exe --plugins imageformats -o binaries.json
  ```
  prints linked libraries as a json

  ```shell
  mugideploy tree --no-repeat --bin Release\imgzip.exe --plugins imageformats 2> NUL
  ```
  prints linked libraries as a tree

  ```shell
  mugideploy graph --bin Release\imgzip.exe --plugins imageformats -o graph.dot
  ```
  prints linked libraries as a graph

  ```
  options:
    --bin BIN [BIN ...]                             Binaries (dlls, exes)
    --plugins PLUGINS [PLUGINS ...]                 Plugin names
    --plugins-path PLUGINS_PATH [PLUGINS_PATH ...]  Path to plugins
    --system                                        Include system dlls
    --vcruntime                                     Include vcruntime dlls
    --msapi                                         Include msapi dlls
    --dry-run                                       Do not copy files
    -o OUTPUT, --output OUTPUT                      Path to save file
    --no-repeat                                     Print each dll once (tree)
  ```


pkgId: e169e3a7dea3c6d3aa998f57c03ca9ba5feee7879979a9a54f97c0aa1fe9eab5
name: python-multi-agent-rlenv-help
arch: noarch
version: 2.0.10
epoch: 0
release: 1
summary: Development documents and examples for multi-agent-rlenv
url: https://pypi.org/project/multi-agent-rlenv/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multi-agent-rlenv-2.0.10-1.src.rpm
location_href: Packages/python-multi-agent-rlenv-help-2.0.10-1.noarch.rpm
checksum_type: sha256
description:
  The objective of `marlenv` is to provide a common (typed) interface for many different reinforcement learning environments.

  As such, `marlenv` provides high level abstractions of RL concepts such as `Observation`s or `Transition`s that are commonly represented as mere (confusing) lists or tuples.


  `marlenv` unifies multiple popular libraries under a single interface. Namely, `marlenv` supports `smac`, `gymnasium` and `pettingzoo`.

  ```python
  import marlenv


  gym_env = marlenv.make("CartPole-v1", seed=25)


  from marlenv.adapters import SMAC
  smac_env = env2 = SMAC("3m", debug=True, difficulty="9")


  from pettingzoo.sisl import pursuit_v4
  from marlenv.adapters import PettingZoo
  pz_env = PettingZoo(pursuit_v4.parallel_env())
  ```



  You can create your own custom environment by inheriting from the `RLEnv` class. The below example illustrates a gridworld with a discrete action space. Note that other methods such as `step` or `render` must also be implemented.
  ```python
  import numpy as np
  from marlenv import RLEnv, DiscreteActionSpace, Observation

  N_AGENTS = 3
  N_ACTIONS = 5

  class CustomEnv(RLEnv[DiscreteActionSpace]):
      def __init__(self, width: int, height: int):
          super().__init__(
              action_space=DiscreteActionSpace(N_AGENTS, N_ACTIONS),
              observation_shape=(height, width),
              state_shape=(1,),
          )
          self.time = 0

      def reset(self) -> Observation:
          self.time = 0
          ...
          return obs

      def get_state(self):
          return np.array([self.time])
  ```


  `marlenv` comes with multiple common environment wrappers, check the documentation for a complete list. The preferred way of using the wrappers is through a `marlenv.Builder`. The below example shows how to add a time limit (in number of steps) and an agent id to the observations of a SMAC environment.

  ```python
  from marlenv import Builder
  from marlenv.adapters import SMAC

  env = Builder(SMAC("3m")).agent_id().time_limit(20).build()
  print(env.extra_shape) # -> (4, ) because there are 3 agents and the time counter
  ```



  - MARL: Collection of multi-agent reinforcement learning algorithms based on `marlenv` [https://github.com/yamoling/marl](https://github.com/yamoling/marl)
  - Laser Learning Environment: a multi-agent gridworld that leverages `marlenv`'s capabilities [https://pypi.org/project/laser-learning-environment/](https://pypi.org/project/laser-learning-environment/)


pkgId: 4dcd5ec8173e22b922052c61ec9aa319cc4f46cde02c0fedb74652a42e2d9cdf
name: python-multi-az-observability-help
arch: noarch
version: 0.0.1a25
epoch: 0
release: 1
summary: Development documents and examples for multi-az-observability
url: https://github.com/bamcis-io/multi-az-observability
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multi-az-observability-0.0.1a25-1.src.rpm
location_href: Packages/python-multi-az-observability-help-0.0.1a25-1.noarch.rpm
checksum_type: sha256
description:
  This is a CDK construct for multi-AZ observability to help detect single-AZ impairments. This is currently an `alpha` version, but is being used in the AWS [Advanced Multi-AZ Resilience Patterns](https://catalog.workshops.aws/multi-az-gray-failures/en-US) workshop.

  There is a lot of available information to think through and combine to provide signals about single-AZ impact. To simplify the setup and use reasonable defaults, this construct (available in TypeScript, Go, Python, and .NET [Java coming soon]) sets up the necessary observability. To use the CDK construct, you first define your service like this:

  ```csharp
  var wildRydesService = new Service(new ServiceProps(){
      ServiceName = "WildRydes",
      BaseUrl = "http://www.example.com",
      FaultCountThreshold = 25,
      AvailabilityZoneNames = vpc.AvailabilityZones,
      Period = Duration.Seconds(60),
      LoadBalancer = loadBalancer,
      DefaultAvailabilityMetricDetails = new ServiceMetricDetails(new ServiceMetricDetailsProps() {
          AlarmStatistic = "Sum",
          DatapointsToAlarm = 3,
          EvaluationPeriods = 5,
          FaultAlarmThreshold = 1,
          FaultMetricNames = new string[] { "Fault", "Error" },
          GraphedFaultStatistics = new string[] { "Sum" },
          GraphedSuccessStatistics = new string[] { "Sum" },
          MetricNamespace = metricsNamespace,
          Period = Duration.Seconds(60),
          SuccessAlarmThreshold = 99,
          SuccessMetricNames = new string[] {"Success"},
          Unit = Unit.COUNT,
      }),
      DefaultLatencyMetricDetails = new ServiceMetricDetails(new ServiceMetricDetailsProps(){
          AlarmStatistic = "p99",
          DatapointsToAlarm = 3,
          EvaluationPeriods = 5,
          FaultAlarmThreshold = 1,
          FaultMetricNames = new string[] { "FaultLatency" },
          GraphedFaultStatistics = new string[] { "p50" },
          GraphedSuccessStatistics = new string[] { "p50", "p99", "tm50", "tm99" },
          MetricNamespace = metricsNamespace,
          Period = Duration.Seconds(60),
          SuccessAlarmThreshold = 100,
          SuccessMetricNames = new string[] {"SuccessLatency"},
          Unit = Unit.MILLISECONDS,
      }),
      DefaultContributorInsightRuleDetails =  new ContributorInsightRuleDetails(new ContributorInsightRuleDetailsProps() {
          AvailabilityZoneIdJsonPath = azIdJsonPath,
          FaultMetricJsonPath = faultMetricJsonPath,
          InstanceIdJsonPath = instanceIdJsonPath,
          LogGroups = serverLogGroups,
          OperationNameJsonPath = operationNameJsonPath,
          SuccessLatencyMetricJsonPath = successLatencyMetricJsonPath
      }),
      CanaryTestProps = new AddCanaryTestProps() {
          RequestCount = 10,
          LoadBalancer = loadBalancer,
          Schedule = "rate(1 minute)",
          NetworkConfiguration = new NetworkConfigurationProps() {
              Vpc = vpc,
              SubnetSelection = new SubnetSelection() { SubnetType = SubnetType.PRIVATE_ISOLATED }
          }
      }
  });
  wildRydesService.AddOperation(new Operation(new OperationProps() {
      OperationName = "Signin",
      Path = "/signin",
      Service = wildRydesService,
      Critical = true,
      HttpMethods = new string[] { "GET" },
      ServerSideAvailabilityMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
          OperationName = "Signin",
          MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Signin"}}, "AZ-ID", "Region")
      }, wildRydesService.DefaultAvailabilityMetricDetails),
      ServerSideLatencyMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
          OperationName = "Signin",
          SuccessAlarmThreshold = 150,
          MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Signin"}}, "AZ-ID", "Region")
      }, wildRydesService.DefaultLatencyMetricDetails),
      CanaryTestLatencyMetricsOverride = new CanaryTestMetricsOverride(new CanaryTestMetricsOverrideProps() {
          SuccessAlarmThreshold = 250
      })
  }));
  wildRydesService.AddOperation(new Operation(new OperationProps() {
      OperationName = "Pay",
      Path = "/pay",
      Service = wildRydesService,
      HttpMethods = new string[] { "GET" },
      Critical = true,
      ServerSideAvailabilityMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
          OperationName = "Pay",
          MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Pay"}}, "AZ-ID", "Region")
      }, wildRydesService.DefaultAvailabilityMetricDetails),
      ServerSideLatencyMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
          OperationName = "Pay",
          SuccessAlarmThreshold = 200,
          MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Pay"}}, "AZ-ID", "Region")
      }, wildRydesService.DefaultLatencyMetricDetails),
      CanaryTestLatencyMetricsOverride = new CanaryTestMetricsOverride(new CanaryTestMetricsOverrideProps() {
          SuccessAlarmThreshold = 300
      })
  }));
  wildRydesService.AddOperation(new Operation(new OperationProps() {
      OperationName = "Ride",
      Path = "/ride",
      Service = wildRydesService,
      HttpMethods = new string[] { "GET" },
      Critical = true,
      ServerSideAvailabilityMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
          OperationName = "Ride",
          MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Ride"}}, "AZ-ID", "Region")
      }, wildRydesService.DefaultAvailabilityMetricDetails),
      ServerSideLatencyMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
          OperationName = "Ride",
          SuccessAlarmThreshold = 350,
          MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Ride"}}, "AZ-ID", "Region")
      }, wildRydesService.DefaultLatencyMetricDetails),
      CanaryTestLatencyMetricsOverride = new CanaryTestMetricsOverride(new CanaryTestMetricsOverrideProps() {
          SuccessAlarmThreshold = 550
      })
  }));
  wildRydesService.AddOperation(new Operation(new OperationProps() {
      OperationName = "Home",
      Path = "/home",
      Service = wildRydesService,
      HttpMethods = new string[] { "GET" },
      Critical = true,
      ServerSideAvailabilityMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
          OperationName = "Home",
          MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Ride"}}, "AZ-ID", "Region")
      }, wildRydesService.DefaultAvailabilityMetricDetails),
      ServerSideLatencyMetricDetails = new OperationMetricDetails(new OperationMetricDetailsProps() {
          OperationName = "Home",
          SuccessAlarmThreshold = 100,
          MetricDimensions = new MetricDimensions(new Dictionary<string, string> {{ "Operation", "Ride"}}, "AZ-ID", "Region")
      }, wildRydesService.DefaultLatencyMetricDetails),
      CanaryTestLatencyMetricsOverride = new CanaryTestMetricsOverride(new CanaryTestMetricsOverrideProps() {
          SuccessAlarmThreshold = 200
      })
  }));
  ```

  Then you provide that service definition to the CDK construct.

  ```csharp
  InstrumentedServiceMultiAZObservability multiAvailabilityZoneObservability = new InstrumentedServiceMultiAZObservability(this, "MultiAZObservability", new InstrumentedServiceMultiAZObservabilityProps() {
      Service = wildRydesService,
      CreateDashboards = true,
      Interval = Duration.Minutes(60), // The interval for the dashboard
      OutlierDetectionAlgorithm = OutlierDetectionAlgorithm.STATIC
  });
  ```

  You define some characteristics of the service, default values for metrics and alarms, and then add operations as well as any overrides for default values that you need. The construct can also automatically create synthetic canaries that test each operation with a very simple HTTP check, or you can configure your own synthetics and just tell the construct about the metric details and optionally log files. This creates metrics, alarms, and dashboards that can be used to detect single-AZ impact.

  If you don't have service specific logs and custom metrics with per-AZ dimensions, you can still use the construct to evaluate ALB and NAT Gateway metrics to find single AZ faults.

  ```csharp
  BasicServiceMultiAZObservability multiAvailabilityZoneObservability = new BasicServiceMultiAZObservability(this, "MultiAZObservability", new BasicServiceMultiAZObservabilityProps() {
      ApplicationLoadBalancers = new IApplicationLoadBalancer[] { loadBalancer },
      NatGateways = new Dictionary<string, CfnNatGateway>() {
          { "us-east-1a", natGateway1},
          { "us-east-1b", natGateway2},
          { "us-east-1c", natGateway3},
      },
      CreateDashboard = true,
      OutlierDetectionAlgorithm = OutlierDetectionAlgorithm.STATIC,
      FaultCountPercentageThreshold = 1.0, // The fault rate to alarm on for errors seen from the ALBs in the same AZ
      PacketLossImpactPercentageThreshold = 0.01, // The percentage of packet loss to alarm on for the NAT Gateways in the same AZ
      ServiceName = "WildRydes",
      Period = Duration.Seconds(60), // The period for metric evaluation
      Interval = Duration.Minutes(60) // The interval for the dashboards
      EvaluationPeriods = 5,
      DatapointsToAlarm = 3
  });
  ```

  If you provide a load balancer, the construct assumes it is deployed in each AZ of the VPC the load balancer is associated with and will look for HTTP metrics using those AZs as dimensions.

  Both options support running workloads on EC2, ECS, Lambda, and EKS.



  * Add additional unit tests


pkgId: d77b4ae3a4049719040442d023e157892963efdd6b056da9e8090933c56598d0
name: python-multi-med-image-ml-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for multi-med-image-ml
url: https://github.com/mleming/MultiMedImageML
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multi-med-image-ml-1.0.1-1.src.rpm
location_href: Packages/python-multi-med-image-ml-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  The Multi-Input Medical Image Machine Learning Toolkit (MultiMedImageML) is a library of Pytorch functions that can encode multiple 3D images (designed specifically for brain images) and offer a single- or multi-label output, such as a disease detection.
  Thus, with a dataset of brain images and labels, you can train a model to predict dementia or multiple sclerosis from multiple input brain images.
  To install Multi Med Image ML, simply type into a standard UNIX terminal
      pip install multi-med-image-ml


pkgId: c3c650bfea307ac2682163d22b0c677ef6777c45d754716810025495f6b5e2ed
name: python-multi-mst-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for multi-mst
url: https://github.com/vda-lab/multi_mst
rpm_license: BSD 2-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multi-mst-0.1.4-1.src.rpm
location_href: Packages/python-multi-mst-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Dimensionality reduction (DR) algorithms typically assume the data they are
  given is uniformly sampled from some underlying manifold. When this is not the
  case, and there are observation-gaps along the manifold, these algorithms may
  fail to detect a single connected entity. This repository presents two manifold
  approximation approaches based on minimum spanning trees (MST) for non-uniform
  sampled data.


pkgId: dd9a36475111e432791137d3206ebd8624c1d078d1a68415a59e78896789e663
name: python-multi-time-series-connectedness-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for multi-time-series-connectedness
url: https://pypi.org/project/multi-time-series-connectedness/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multi-time-series-connectedness-0.2.2-1.src.rpm
location_href: Packages/python-multi-time-series-connectedness-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  Multi Time Series Connectedness


  This project is motivated by Financial and Macroeconomics Connectedness created by Diebold and Ylimaz. I want to use this algorithm not only in finance and macroeconomics area but other area, so I start to build this project.


  ```
  python3 -m venv venv
  source venv/bin/activate
  pip3 install -r requirements.txt
  ```


  * calculate volatility
    ```
    python3 volatilities.py --path docs/market_prices --start_at 2024-09-06T00:00:00+01:00 --end_at 2024-09-06T22:27:00+01:00
    ```
  * calculate connectedness of all volatility
    ```
    python3 conn.py
    ```
  * calculate rolling connectedness
    ```
    python3 rolling_connectedness.py
    ```


  * Put a folder with multiple Panel data into docs folder
  * Run the commands in feature section


  http://financialconnectedness.org/


  MIT License


pkgId: fdb3673863cedbe5ba116368c364d06aaa5dce1939ca877bc595e82289cb0a4b
name: python-multilang-probe-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for multilang-probe
url: https://pypi.org/project/multilang-probe/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multilang-probe-0.1.7-1.src.rpm
location_href: Packages/python-multilang-probe-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for analyzing multilingual text.
  [![DOI](https://zenodo.org/badge/902241265.svg)](https://doi.org/10.5281/zenodo.14437170)




  **multilang-probe** is a toolkit designed to classify character sets, detect languages in text files, and extract specific multilingual passages. It supports character detection for a wide range of writing systems using Unicode script properties (e.g., Latin, Japanese, Cyrillic, Arabic, Devanagari, and more). Additionally, it leverages the FastText model for robust language detection.

  Whether you are analyzing large corpora or extracting specific language data, **multilang-probe** simplifies the process with an easy-to-use API.




  - Detect and calculate proportions of character types (e.g., Latin, Japanese, Cyrillic, Arabic, Devanagari) in text.
  - Uses `regex` with Unicode script properties (`\p{Script}`) for more accurate classification.
  - Special handling for Japanese vs Chinese characters (Han script).


  ```python
  from charlang_detect.character_detection import classify_text_with_proportions

  text = "これは日本語と English です。"
  proportions = classify_text_with_proportions(text)
  print(proportions)


  ```

  **Explanation**:
  - If the text contains Hiragana/Katakana, Han characters are considered Japanese Kanji.
  - Otherwise, Han characters are considered Chinese.


  - Identify top languages in text using Facebook's FastText pre-trained model.


  ```python
  from charlang_detect.language_detection import detect_language_fasttext

  text = "Ceci est un texte en français."
  languages = detect_language_fasttext(text)
  print(languages)

  ```


  - Analyze all `.txt` files in a folder to detect multilingual passages and language distributions.
  - **Character-based filtering**: Identify and filter text lines containing specific character sets (e.g., Japanese, Cyrillic, Arabic).
  - **Language-based filtering**: Extract passages in a specific language, with customizable confidence thresholds (e.g., 70%).
  - **Targeted extraction**: Extract lines of text meeting both minimum length requirements and language detection accuracy.
  - **Calculate language proportions**: Aggregate detected languages across files and calculate their proportions.


  ```python
  from charlang_detect.corpus_analysis import analyze_corpus_with_fasttext

  folder_path = "path/to/corpus/"
  results = analyze_corpus_with_fasttext(folder_path)
  for filename, langs in results.items():
      print(filename, langs)
  ```


  ```python
  from charlang_detect.corpus_analysis import filter_passages_by_character_types

  folder_path = "path/to/corpus/"
  character_types = ["japanese", "cyrillic"]
  filtered = filter_passages_by_character_types(folder_path, character_types)
  for filename, passages in filtered.items():
      print(filename, passages)
  ```


  ```python
  from charlang_detect.corpus_analysis import filter_passages_by_language

  folder_path = "path/to/corpus/"
  target_languages = ["fr", "en"]
  threshold = 70
  filtered = filter_passages_by_language(results, target_languages, folder_path, threshold)
  for filename, passages in filtered.items():
      print(filename, passages)
  ```



  - Japanese (Hiragana, Katakana)
  - Han (Kanji; considered Japanese if Hiragana/Katakana present, else Chinese)
  - Korean (Hangul)
  - Cyrillic (for languages like Russian, Bulgarian, etc.)
  - Arabic
  - Hebrew
  - Greek
  - Latin (basic and extended)
  - Devanagari (e.g., Hindi, Sanskrit)
  - Tamil, Bengali, Thai
  - Extendable via Unicode scripts
  - "other" category for characters not belonging to known scripts



  - Python 3.7+
  - FastText
  - Regex (for Unicode script classification)



  This project is licensed under the MIT License. While the MIT License allows unrestricted use, modification, and distribution of this software, I kindly request that proper credit be given when this project is used in academic, research, or published work. For citation purposes, please refer to the following:

  **CAFIERO Florian**, *'multilang-probe'*, 2024, [https://github.com/floriancafiero/multilang-probe].



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



  **Florian Cafiero**
  GitHub: [floriancafiero](https://github.com/floriancafiero)
  Email: florian.cafiero@chartes.psl.eu



  - Support for other pre-trained language models (e.g., spaCy).
  - Detection of mathematical language
  - Visualization tools for multilingual analysis.
  - CLI (Command-Line Interface) for easy usage without writing code.


pkgId: 691715d7abd09c40e572d9c47b6616b1e86b4c93b56c2feb04570a8f7da1dba9
name: python-multilingual-ime-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for multilingual-ime
url: https://github.com/Zen-Transform/Multilingual-IME
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multilingual-ime-0.1.3-1.src.rpm
location_href: Packages/python-multilingual-ime-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  Package manager: [Poetry](https://python-poetry.org/)



  - Datasets
    - Keystroke_Datasets
    - Plain_Text_Datasets
    - Test_Datasets
    - Train_Datasets
  - multilingual_ime
    - core: core functions
    - data_preprocess: codes for data preprocessing
    - src: location for none code source object
    - *.py: main IME handler code
  - references: storing referece paper or documents
  - reports: storing system tesing report or log files
  - scripts: short script for data generations or others
  - tests: storing unit test code



  ```shell

  poetry add [package]


  python -m [module_name].[script]
  ```


  1.


pkgId: 69ba8a2716093401508c5d5bf0ec00ef9b6323756069afcd47e54045209a829a
name: python-multilspy-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for multilspy
url: https://github.com/microsoft/multilspy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multilspy-0.0.2-1.src.rpm
location_href: Packages/python-multilspy-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  This repository hosts multilspy, a library developed as part of research conducted for NeruIPS 2023 paper titled ["Monitor-Guided Decoding of Code LMs with Static Analysis of Repository Context"](https://neurips.cc/virtual/2023/poster/70362) (["Guiding Language Models of Code with Global Context using Monitors"](https://arxiv.org/abs/2306.10763) on Arxiv). The paper introduces Monitor-Guided Decoding (MGD) for code generation using Language Models, where a monitor uses static analysis to guide the decoding, ensuring that the generated code follows various correctness properties, like absence of hallucinated symbol names, valid order of method calls, etc. For further details about Monitor-Guided Decoding, please refer to the paper and GitHub repository [microsoft/monitors4codegen](https://github.com/microsoft/monitors4codegen).

  `multilspy` is a cross-platform library designed to simplify the process of creating language server clients to query and obtain results of various static analyses from a wide variety of language servers that communicate over the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/). It is easily extensible to support any [language that has a Language Server](https://microsoft.github.io/language-server-protocol/implementors/servers/) and currently supports Java, Rust, C# and Python. We aim to continuously add support for more language servers and languages.

  [Language servers]((https://microsoft.github.io/language-server-protocol/overviews/lsp/overview/)) are tools that perform a variety of static analyses on code repositories and provide useful information such as type-directed code completion suggestions, symbol definition locations, symbol references, etc., over the [Language Server Protocol (LSP)](https://microsoft.github.io/language-server-protocol/overviews/lsp/overview/). Since LSP is language-agnostic, `multilspy` can provide the results for static analyses of code in different languages over a common interface.

  `multilspy` intends to ease the process of using language servers, by handling various steps in using a language server:
  * Automatically handling the download of platform-specific server binaries, and setup/teardown of language servers
  * Handling JSON-RPC based communication between the client and the server
  * Maintaining and passing hand-tuned server and language specific configuration parameters
  * Providing a simple API to the user, while executing all steps of server-specific protocol steps to execute the query/request.

  Some of the analyses results that `multilspy` can provide are:
  - Finding the definition of a function or a class ([textDocument/definition](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_definition))
  - Finding the callers of a function or the instantiations of a class ([textDocument/references](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_references))
  - Providing type-based dereference completions ([textDocument/completion](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion))
  - Getting information displayed when hovering over symbols, like method signature ([textDocument/hover](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_hover))
  - Getting list/tree of all symbols defined in a given file, along with symbol type like class, method, etc. ([textDocument/documentSymbol](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_documentSymbol))
  - Please create an issue/PR to add any other LSP request not listed above


  It is ideal to create a new virtual environment with `python>=3.10`. To create a virtual environment using conda and activate it:
  ```
  conda create -n multilspy_env python=3.10
  conda activate multilspy_env
  ```
  Further details and instructions on creation of python virtual environments can be found in the [official documentation](https://docs.python.org/3/library/venv.html). Further, we also refer users to [Miniconda](https://docs.conda.io/en/latest/miniconda.html), as an alternative to the above steps for creation of the virtual environment.

  To install `multilspy` using pip, execute the following command:
  ```
  pip install https://github.com/microsoft/multilspy/archive/main.zip
  ```


  Example usage:
  ```python
  from multilspy import SyncLanguageServer
  from multilspy.multilspy_config import MultilspyConfig
  from multilspy.multilspy_logger import MultilspyLogger
  ...
  config = MultilspyConfig.from_dict({"code_language": "java"}) # Also supports "python", "rust", "csharp"
  logger = MultilspyLogger()
  lsp = SyncLanguageServer.create(config, logger, "/abs/path/to/project/root/")
  with lsp.start_server():
      result = lsp.request_definition(
          "relative/path/to/code_file.java", # Filename of location where request is being made
          163, # line number of symbol for which request is being made
          4 # column number of symbol for which request is being made
      )
      result2 = lsp.request_completions(
          ...
      )
      result3 = lsp.request_references(
          ...
      )
      result4 = lsp.request_document_symbols(
          ...
      )
      result5 = lsp.request_hover(
          ...
      )
      ...
  ```

  `multilspy` also provides an asyncio based API which can be used in async contexts. Example usage (asyncio):
  ```python
  from multilspy import LanguageServer
  ...
  lsp = LanguageServer.create(...)
  async with lsp.start_server():
      result = await lsp.request_definition(
          ...
      )
      ...
  ```

  The file [src/multilspy/language_server.py](src/multilspy/language_server.py) provides the `multilspy` API. Several tests for `multilspy` present under [tests/multilspy/](tests/multilspy/) provide detailed usage examples for `multilspy`. The tests can be executed by running:
  ```bash
  pytest tests/multilspy
  ```


  `multilspy` provides all the features that language-server-protocol provides to IDEs like VSCode. It is useful to develop toolsets that can interface with AI systems like Large Language Models (LLM). One such usecase is Monitor-Guided Decoding, where `multilspy` is used to find results of static analyses like type-directed completions, to guide the token-by-token generation of code using an LLM, ensuring that all generated identifier/method names are valid in the context of the repository, significantly boosting the compilability of generated code. MGD also demonstrates use of `multilspy` to create monitors that ensure all function calls in LLM generated code receive correct number of arguments, and that functions of an object are called in the right order following a protocol (like not calling "read" before "open" on a file object).



  If you get the following error:
  ```
  RuntimeError: Task <Task pending name='Task-2' coro=<_AsyncGeneratorContextManager.__aenter__() running at
      python3.8/contextlib.py:171> cb=[_chain_future.<locals>._call_set_state() at
      python3.8/asyncio/futures.py:367]> got Future <Future pending> attached to a different loop python3.8/asyncio/locks.py:309: RuntimeError
  ```

  Please ensure that you create a new environment with Python ```>=3.10```. For further details, please have a look at the [StackOverflow Discussion](https://stackoverflow.com/questions/73599594/asyncio-works-in-python-3-10-but-not-in-python-3-8).



  This project welcomes contributions and suggestions.  Most contributions require you to agree to a
  Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
  the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.

  When you submit a pull request, a CLA bot will automatically determine whether you need to provide
  a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
  provided by the bot. You will only need to do this once across all repos using our CLA.

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
  For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
  contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.



  This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft
  trademarks or logos is subject to and must follow
  [Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
  Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
  Any use of third-party trademarks or logos are subject to those third-party's policies.


pkgId: bb26f42cd6924439a4f2a38d6f4bd94ec1d61e587d388dbf592cfee16b8746e4
name: python-multinmrfit-help
arch: noarch
version: 2.1.3
epoch: 0
release: 1
summary: Development documents and examples for multinmrfit
url: https://github.com/NMRTeamTBI/MultiNMRFit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multinmrfit-2.1.3-1.src.rpm
location_href: Packages/python-multinmrfit-help-2.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/multinmrfit/badge/?version=latest)](http://multinmrfit.readthedocs.io/?badge=latest)
  [![Python 3.8+](https://img.shields.io/badge/python-%3E%3D3.8-blue)](https://www.python.org/downloads/release/python-380/)



  MultiNMRFit is a scientific tool designed to extract quantitative information (chemical shifts, signal intensity, coupling constants, etc) by fitting a serie of 1D spectra (acquired individually or as pseudo 2D spectra).

  It is one of the routine tools that we use for NMR studies of metabolic systems at the [NMR](https://www.toulouse-biotechnology-institute.fr/en/poles/equipe-rmn-2/) and [MetaSys](https://www.toulouse-biotechnology-institute.fr/en/poles/equipe-metasys/) teams of the [Toulouse Biotechnology Institute](http://www.toulouse-biotechnology-institute.fr/en/).

  The code is open-source, and available under a GPLv3 license. Additional information will be available in an upcoming [publication](https://doi.org/xxx.xxx).

  Detailed documentation can be found online at Read the Docs ([https://multinmrfit.readthedocs.io/](https://multinmrfit.readthedocs.io/)).



  * **fit series of 1D spectra** (acquired as individual 1D spectra, as a pseudo 2D spectrum, or provided as tabulated text files),
  * can be used with **all nuclei** (<sup>1</sup>H, <sup>13</sup>C, <sup>15</sup>N, <sup>31</sup>P, etc),
  * estimation of several parameters for each signal of interest (**intensity**, **area**, **chemical shift**, **linewidth**, **coupling constant(s)**, etc),
  * several **signal models** are provided, and users can add their own models
  * **semi-automated analysis** for **peak picking** and **definition of multiplicity** for each signal,
  * account for **overlaps** between peaks and **zero-order baseline correction**,
  * **visual inspection of the fitted curves**,
  * estimation of **uncertainty** on estimated parameters (standard deviation),
  * shipped as a **library** with a **graphical user interface**,
  * open-source, free and easy to install everywhere where Python 3 and pip run,
  * biologist-friendly.



  MultiNMRFit requires Python 3.8 or higher and run on all platforms (Windows, MacOS and Unix).
  Please check [the documentation](https://multinmrfit.readthedocs.io/en/latest/quickstart.html) for complete
  installation and usage instructions.

  Use `pip` to **install PhysioFit from GitHub**:

  ```bash
  $ pip install multinmrfit
  ```

  Then, start the graphical interface with:

  ```bash
  $ nmrfit
  ```

  MultiNMRFit is also available as a Python library.



  If you have an idea on how we could improve MultiNMRFit please submit a new *issue*
  to [our GitHub issue tracker](https://github.com/NMRTeamTBI/MultiNMRFit/issues).




  Contributions are very welcome! :heart:



  In development mode, do a `pip install -e /path/to/MultiNMRFit` to install
  locally the development version.



  Build the HTML documentation with:

  ```bash
  $ cd doc
  $ make html
  ```

  The PDF documentation can be built locally by replacing `html` by `latexpdf`
  in the command above. You will need a recent latex installation.



  In preparation, 2024, [doi: xxx.xxxx](https://doi.org/xxx.xxxx)



  Pierre Millard, Cyril Charlier



  :email: charlier@insa-toulouse.fr
  :email: millard@insa-toulouse.fr


pkgId: 2eee2d88d608b3b4b7e01a9efda040eef4ee93ee57f6459d3a0136f1500c36b6
name: python-multipie-help
arch: noarch
version: 1.3.2
epoch: 0
release: 1
summary: Development documents and examples for multipie
url: https://github.com/CMT-MU/MultiPie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multipie-1.3.2-1.src.rpm
location_href: Packages/python-multipie-help-1.3.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python library for crystallographic symmetry operations and Symmetry-Adapted Multipole Basis (SAMB).
  Molecular or crystal structures are best drawn by using [QtDraw](https://github.com/CMT-MU/QtDraw).

  - **Authors**: Hiroaki Kusunose and Rikuto Oiwa

  - **Citing MultiPie and QtDraw**: If you are using MultiPie and/or QtDraw in your scientific research, please help our scientific visibility by citing our work:
    > Hiroaki Kusunose, Rikuto Oiwa, and Satoru Hayami, Symmetry-adapted modeling for molecules and crystals, Phys. Rev. B <b>107</b>, 195118 (2023).<br>
    > DOI: [https://doi.org/10.1103/PhysRevB.107.195118](https://doi.org/10.1103/PhysRevB.107.195118)

  - **Installation**: MultiPie can be installed from PyPI using pip on Python >= 3.9:
    ```
    pip install multipie
    ```
    You can also visit
    [PyPI](https://pypi.org/project/multipie/) or [GitHub](https://github.com/CMT-MU/MultiPie) to download the source.

  - **Requirements**:
    - This library optionally requires [TeXLive](https://www.tug.org/texlive/) environment to create LaTeX and PDF files.
    - Molecular or crystal structure files are optionally generated by [QtDraw](https://github.com/CMT-MU/QtDraw).

  - **See also**:
    - [Manual (MultiPie and QtDraw)](https://github.com/CMT-MU/QtDraw/blob/main/docs/src/manual.pdf).
    - [MultiPie tutorial (in Japanese)](https://cmt-mu.github.io/MultiPieTutorial/)
    - [QtDraw tutorial (in Japanese)](https://cmt-mu.github.io/QtDrawTutorial/)


pkgId: 0f65e98397752895c3ac35e225b9ec1332805cb2dade196dca44f8649734f21b
name: python-multipoles-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for multipoles
url: https://github.com/maroba/multipoles
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multipoles-0.4.1-1.src.rpm
location_href: Packages/python-multipoles-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  <p><a href="https://badge.fury.io/py/multipoles"> <img src="https://badge.fury.io/py/multipoles.svg?branch=kill_cache=1" alt="PyPI version"></a> <a href=""> <img src="https://github.com/maroba/multipoles/actions/workflows/python-app.yml/badge.svg" alt="build"></a><a href="https://codecov.io/gh/maroba/multipoles"> <img src="https://codecov.io/gh/maroba/multipoles/branch/master/graph/badge.svg?token=JNH9SP7BRG" alt=""></a></p>

  *multipoles* is a Python package for multipole expansions of the solutions of the Poisson equation (e.g. electrostatic or gravitational potentials). It can handle discrete and continuous charge or mass distributions.




  Simply use `pip`:

  ```
  pip install --upgrade multipoles
  ```



  The documentation is available [here](https://maroba.github.io/multipoles/).



  For a given function $\rho(x,y,z)$, the solution $\Phi(x,y,z)$ of the Poisson equation $\nabla^2\Phi=-4\pi \rho$ with vanishing Dirichlet boundary conditions at infinity is

  $$\Phi(x,y,z)=\int d^3r'\frac{\rho(r')}{|r-r'|}$$

  Examples of this are the electrostatic and Newtonian gravitational potential.
  If you need to evaluate $\Phi(x,y,z)$ at many points, calculating the integral for each point is computationally expensive. As a faster alternative, we can express $\Phi(x,y,z)$ in terms of the multipole moments $q_{lm}$ or $I_{lm}$ (note some literature uses the subscripts $(\cdot)_{nm}$):

  $$\Phi(x,y,z)=\sum_{l=0}^\infty\underbrace{\sqrt{\frac{4\pi}{2l+1}}\sum_{m=-l}^lY_{lm}(\theta, \varphi)\frac{q_{lm}}{r^{l+1}}}_{\Phi^{(l)}}$$

  for a exterior expansion, or

  $$\Phi(x,y,z)=\sum_{l=0}^\infty\underbrace{\sqrt{\frac{4\pi}{2l+1}}\sum_{m=-l}^lY_{lm}(\theta, \varphi)I_{lm}r^{l}}_{\Phi^{(l)}}$$

  for an interior expansion; where $r, \theta, \varphi$ are the usual spherical coordinates corresponding to the cartesian coordinates $x, y, z$ and $Y_{lm}(\theta, \varphi)$ are the spherical harmonics.

  The multipole moments for the exterior expansion are:

  $$q_{lm} = \sqrt{\frac{4\pi}{2l+1}}\int d^3 r' \rho(r')r'^l Y^*_{lm}(\theta', \varphi')$$

  and the multipole moments for the interior expansion are:

  $$I_{lm} = \sqrt{\frac{4\pi}{2l+1}}\int d^3 r' \frac{\rho(r')}{r'^{l+1}} Y^*_{lm}(\theta', \varphi')$$

  This approach is usually much faster because the contributions $\Phi^{(l)}$ are getting smaller with increasing <i>l</i>. So we just have to calculate a few integrals for obtaining some  $q_{lm}$ or  $I_{lm}$.

  Some literature considers the $\sqrt{\frac{4\pi}{2l+1}}$ as part of the definition of $Y_{lm}(\theta, \varphi)$.





  As example for a discrete charge distribution we model two point charges with positive and negative unit charge located on the z-axis:

  ```python
  from multipoles import MultipoleExpansion



  charge_dist = {
      'discrete': True,     # point charges are discrete charge distributions
      'charges': [
          {'q': 1, 'xyz': (0, 0, 1)},
          {'q': -1, 'xyz': (0, 0, -1)},
      ]
  }

  l_max = 2   # where to stop the infinite multipole sum; here we expand up to the quadrupole (l=2)

  Phi = MultipoleExpansion(charge_dist, l_max)



  x, y, z = 30.5, 30.6, 30.7
  value = Phi(x, y, z)


  Phi.multipole_moments
  ```



  As an example for a continuous charge distribution, we smear out the point charges from the previous
  example:

  ```python
  from multipoles import MultipoleExpansion
  import numpy as np



  npoints = 101
  edge = 10
  x, y, z = [np.linspace(-edge/2., edge/2., npoints)]*3
  XYZ = np.meshgrid(x, y, z, indexing='ij')




  def gaussian(XYZ, xyz0, sigma):
      g = np.ones_like(XYZ[0])
      for k in range(3):
          g *= np.exp(-(XYZ[k] - xyz0[k])**2 / sigma**2)
      g *= (sigma**2*np.pi)**-1.5
      return g

  sigma = 1.5   # the width of our gaussians


  rho = gaussian(XYZ, (0, 0, 1), sigma) - gaussian(XYZ, (0, 0, -1), sigma)




  charge_dist = {
      'discrete': False,     # we have a continuous charge distribution here
      'rho': rho,
      'xyz': XYZ
  }



  l_max = 2   # where to stop the infinite multipole sum; here we expand up to the quadrupole (l=2)

  Phi = MultipoleExpansion(charge_dist, l_max)

  x, y, z = 30.5, 30.6, 30.7
  value = Phi(x, y, z)
  ```


pkgId: 5d63bf2feef5f1419c31bc650fa15575c00d702f0c5df6473633fc0f2a7016e5
name: python-multireg-help
arch: noarch
version: 0.0.18
epoch: 0
release: 1
summary: Development documents and examples for multireg
url: https://gitlab.pasteur.fr/gletort/multireg
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multireg-0.0.18-1.src.rpm
location_href: Packages/python-multireg-help-0.0.18-1.noarch.rpm
checksum_type: sha256
description:
  * You can install the plugin directly in `Napari` by going to `Plugins>Install/Uninstall plugins` and search for `multireg`
  * Or you can install `multireg` via [pip]:
      pip install multireg

  You can launch `multireg` in napari by going to `Plugins>multireg: do multiplex registration`.

  It will open a prompt to ask you to select the reference (fixed) image, compared to which all other images will be aligned.
  Then you have to choose the `reference chanel` that will be used in all the stacks to calculate the alignement. So this chanel should be common to all stacks.
  ![](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/plugin_step0.png)

  The first part of the registration relies on reference points manually selected, because the common field of view can be quite far from each other in the acquisition. So first a affine registration is applied to bring close the region of interest between the two stacks to match.
  <br> *Note that if your stacks did not move a lot then you could calculate the transformation without using the reference points. There's an option in the alignement calculation panel for this.*
  ![](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/plugin_fixedpoints.png)
  You have to manually placed a few reference points (4-5 should be enough). Try to spread them in the image (in x,y and z) on landmarks to recognize them in other images.
  To add a new reference point, click on the "plus" sign in the left panel. To select one, click on the arrow icon (or press 3), then on the point. You can move the point in x and y. To move it in z, press `u` for up and `d` for down.
  When all points are placed, save them. The **points have to be saved** to be correctly loaded by the alignement calculation step.
  Then click on `Fixed points done` to continue to the next step.

  Then you can choose one of the images you want to align with the reference image. Its chanel that is common to the fixed image should be the same chanel, selected in the first step (the `reference chanel`). Select the file of the moving image to align by clicking on `select file`. This will open the new image and go to the step of placing the moving points in this image.
  When you will have process all the moving images, you can click on `All done` to finish the plugin by creating the [resulting stack](#create-resulting-image).
  ![moving image step](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/plugin_movingimg.png)

  You now have to locate where the region of interest (the fixed image) is in your new image and find the landmarks referenced in the fixed image are in this new image. This allows the plugin to put together the region of interest in the two images in a first step, before to fine-tune the registration.
  For each point placed in the fixed image, place the corresponding point in the moving image. By default, the moving points are placed close to the fixed points.
  * Each point must have the same label (number) as its corresponding fixed points to associate them correctly. You can change a point label by selecting it and putting the new value in `param` and clicking on `update`.
  * When a point is selected, you can drag it to its desired location. To move it in the Z direction, you can press `u` to move it to the next Z (up direction) and `d` (down) to the previous Z. The viewed slice will also move, following the point new position, when you do so.
  * You can click on `side_by_side_view` to see the two images (fixed and moving) with their placed points at the same time.
  * You can click on `two_windows_view` to see the fixed image and points in a separate Napari window. This allows to have visualize separatly the fixed and moving images and points, and thus to see different z-slices or zoom for each image. The new window will be closed automatically by the plugin if you unselect this option or when you click on `Moving done`.
  ![two window](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/twowin.png)
  When all the moving points have been correctly placed, click on `Save points` to save this positions and let it be usable by the alignement step. The points **have to be saved** in the point file to be correctly loaded in the alignement step.

  This step is the core of the plugin. The transformation necessary to change the moving image to match with the fixed image on the `reference chanel` is calculated based on [itk-elastix](https://pypi.org/project/itk-elastix/) python module. It is decomposed in two steps.
  1. First a global **affine registration** is performed, based on the correspondance between the reference and moving points (`do rigid` option). This allows to locate the fixed image postion within the moving image and apply a first **shearing, scaling, rotation and translation** to super-impose the region of interest.
  2. The second step fine-tunes the registration. It doesn't use the reference points (except if rigid transformation was not selected) anymore but calculate the matching based on the images local intensities. **Non-rigid transformation** based on B-spline is performed at this step, thus allowing to compensate for **local deformations** in the moving image (`do bspline` option).
  The option `use reference points` determines if the previously placed reference points should be used or if the registration is only based on intensities matching. It's possible to use only the intensities if the two images are not so far away from each other. The reference points will be used only in the first pass (either rigid or bspline) when both are selected. If only one is selected, the points will be used on the selected transformation.
  The option `strong_weight_points` allows to give more importance to reference points than to intensities matching when calculating the registration. The weights will be 0.2 for the intensity metric and 0.8 for points metric. Note that if both rigid and bspline transformations are selected, the second transformation (bspline) do not use the points.
  ![apply alignement step](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/interm.png)
  You can click on `show advanced parameters` to tune the parameters of the non rigid transformation. After calculating the registration, the plugin will add a new layer, which is the moving image after alignement, so you can check the sucess of the regristration. `show intermediate_layer` will also add the moving image aligned after the first step only (the points matching with affine registration).
  ![calculate alignement step](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/align.png)

  Once the calculated registration is satisfying, you can apply it to all the chanels of your moving image, or only to a few. By default, all chanels are selected in the `Apply alignement` panel, but you can unselect the chanels that you don't want to align in the parameter `align chanels`.
  When you click on `Align images`, the plugin will apply the transformation on the selected chanels of the moving image and save each of them in the `aligned` folder as individual `.tif` files.
  ![apply alignement step](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/goalign.png)

  This step allows to save a single 3D multi-chanels stack with all the aligned chanels.
  The common chanel present in all the images can be averaged together after alignement to obtain a much less noisy image. By default, the aligned `reference chanel` of all the images are averaged together to create the final image first chanel. However, it is possible to unselect some images in the first panel (`average chanels` parameter) if you do not wish to use all the images or do an average.
  ![create result image](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/create.png)
  Then each aligned chanel of all the images that were not the reference chanel are stacked together in the final resulting image. Here also, if you don't want to keep all the other chanels in the resulting image, you can unselect the one that you don't want stacked, in the `add_chanels` parameter.
  All the aligned chanels have been previously saved in the `aligned` folder. If `delete_files` is checked (default) all these interemediate files will be deleted and only the final resulting stack will be saved in that folder.
  You will end-up with a final 3D multi-chanels stack, saved as a `.tif` file in the `aligned` folder, with the same name as your fixed image. It can have a lot of chanels if you stacked together multiple images.
  In napari, you can separate the chanels by right clicking on the layer and select `Split stack`.
  In Fiji, you can make the stack as a composite to see the chanels with different colors.
  ![final image](https://gitlab.pasteur.fr/gletort/multireg/raw/main/imgs/reslayer.png)

  Distributed under the terms of the [BSD-3] license,
  "multireg" is free and open source software

  This [napari] plugin was generated with [Cookiecutter] using [@napari]'s [cookiecutter-napari-plugin] template.

  If you encounter any problems, please [file an issue] along with a detailed description.
  [napari]: https://github.com/napari/napari
  [Cookiecutter]: https://github.com/audreyr/cookiecutter
  [@napari]: https://github.com/napari
  [MIT]: http://opensource.org/licenses/MIT
  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause
  [GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
  [GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
  [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
  [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
  [cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin
  [napari]: https://github.com/napari/napari
  [tox]: https://tox.readthedocs.io/en/latest/
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/


pkgId: b8eea4433669a5e9468366d7bf70c95d281990cf977d2e126349995d675eacc0
name: python-multiserialviewer-help
arch: noarch
version: 24.12.2
epoch: 0
release: 1
summary: Development documents and examples for multiserialviewer
url: https://github.com/shaag7967/multiserialviewer
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-multiserialviewer-24.12.2-1.src.rpm
location_href: Packages/python-multiserialviewer-help-24.12.2-1.noarch.rpm
checksum_type: sha256
description:
  Shows multiple serial text streams in a single window with individual highlighting options

  <img src="https://github.com/shaag7967/multiserialviewer/blob/main/doc/img/multiserialviewer.png?raw=true" width="70%" alt="example with two serial connections">



  Imagine you have several embedded devices / MCUs all printing out debug information over a UART. You don't want to use a terminal program (e.g. HTerm) for every COM port manually. You want to easily open all COM ports at once and clear all received data with a single click. Would be nice, if important text messages could be highlighted with different colors, so you don't have to read everything your devices are telling you.


  You can install this tool using the package installer for Python (pip). See [multiserialviewer](https://pypi.org/project/multiserialviewer/).

      pip install multiserialviewer


  After installation using pip, you can start it by running

      multiserialviewer
  in a console (or by directly clicking '\Scripts\multiserialviewer.exe' in your python install directory).


  Click in the top left corner on "Create SerialViewer" and enter your connection details. After you created all SerialViewers you need, start receiving your text data by clicking on "Start".

  <img src="https://github.com/shaag7967/multiserialviewer/blob/main/doc/img/create_serial_viewer.png?raw=true" width="70%" alt="create serial viewer connection">

  If one of your serial ports can not be opened, you will see an error message in the corresponding SerialView window. In this case all other connections/SerialViewer will be closed again.


  If you want to highlight specific text, you can define text patterns using regular expression syntax. If you just want to highlight certain words, just enter them as normal text under "Text Highlighter Settings".

  <img src="https://github.com/shaag7967/multiserialviewer/blob/main/doc/img/highlighter_settings.png?raw=true" width="60%" alt="highlighter settings">



  When closing this tool, your settings (connections, window sizes/positions and highlighter) are stored in ini/text files. You will find them in your users config folder. On windows this could be e.g. `C:\Users\youruser\AppData\Local\MultiSerialViewer`.

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


pkgId: e75d1f3315c1d1ec66cd070b7e04571a14360fa2fad3f245fb69e24921dfdaa3
name: python-mumaxxr-help
arch: noarch
version: 0.0.24
epoch: 0
release: 1
summary: Development documents and examples for mumaxxr
url: https://github.com/timvgl/mumaxXR/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mumaxxr-0.0.24-1.src.rpm
location_href: Packages/python-mumaxxr-help-0.0.24-1.noarch.rpm
checksum_type: sha256
description:
  mumaxXR contains an engine for xarray to read output directories of mumax directly, lazily into xarray.
  Therefore, the class OvfEngine needs to be imported from mumaxXR. Simply pass the directory, or an ovf file (e.g. m000000.ovf) as the filename_or_obj argument to the method.
  If only the directory is specified, the engine tries to find magnetization ovf files. If no magnetization ovf files are found the engine tries to load displacement ovf files.
  If neither magnetization nor displacement ovf files are found the engine just loads the first appearing type of ovf files.
  The engine has to be passed to xarray as engine=OvfEngine. Set chunks='auto' in order to parallelize loading of the ovf-files. If you want to set chunks to something else, keep in mind,
  that each ovf file has to be accessed multiple times, if the chunks for the dimensions x, y, z and comp are not set the default values.

  .. code-block:: python

      from mumaxXR import OvfEngine
      dataset = xr.open_dataset(example_mumax_output_dir, chunks='auto', engine=OvfEngine)

  If multiple kinds of ovf files have been stored in the same time steps, another argument 'wavetype' can be passed to open_dataset, containing a list of the other short names, e.g.,

  .. code-block:: python

      dataset = xr.open_dataset(path_to_example_mumax_output_dir, chunks='auto', engine=OvfEngine, wavetype=['m', 'u'])

  Keep in mind that the names passed to wavetype have to be exactly like the prefix of ovf files.

  If multiple simulation directories are supposed to be concatenated, multiple mumax simulation directories can be passed to the engine.
  If the number of ovf-files in the directories is not the same, the data is going to be interpolated lineariliy towards the time scaling, of the major mumax-directory.
  Please notice that this only makes sense, if the simulations did not crash or were interrupted in another way.
  This is meant for concatenating simulations of parameter sweeps.
  For 1D concatenation simply pass the parameter values inside a list to the engine.

  .. code-block:: python

      dataset = xr.open_dataset(example_mumax_output_dir_0, chunks='auto', engine=OvfEngine, dirListToConcat=[path_to_example_mumax_output_dir_1, path_to_example_mumax_output_dir_2], sweepName='name_of_changed_parameter', sweepParam=[value_0_of_parameter, value_1_of_parameter, value_2_of_parameter])

  For ND concatenation pass a list of names to sweepNames and a list of tuples to sweepParams

  .. code-block:: python

      dataset = xr.open_dataset(example_mumax_output_dir_1, chunks='auto', engine=OvfEngine, dirListToConcat=[path_to_example_mumax_output_dir_2, path_to_example_mumax_output_dir_3, path_to_example_mumax_output_dir_4], sweepName=['name_of_changed_parameter_1', 'name_of_changed_parameter_2'], sweepParam=[(value_1_1_of_parameter, value_2_1_of_parameter), (value_1_2_of_parameter, value_2_1_of_parameter), (value_1_1_of_parameter, value_2_2_of_parameter), (value_1_2_of_parameter, value_2_2_of_parameter)])

  If you want the ovf-files to be deleted after reading, set removeOvfFiles=True. This only works, if the ovf-files don't have to be accessed multiple times.
  If you want to use ovf-files periodically, set useEachNthOvfFile=N. N has to be larger than one. Otherwise it is ignored. Using this flag, only each nth ovf file is used for the dataset.
  The singleLoad option allows you to not load all of the ovf-files but only one specific one.

  Of course the wavetype option and the mumax directory concatenation can be used simultaneously.


pkgId: 4c10357f3703f43b616ff3bb20cebf8468f2503d93897b4f357b66cad7fcd9d9
name: python-musiclists-baronsmv-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for musiclists-baronsmv
url: https://github.com/baronsmv/musiclists
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-musiclists-baronsmv-0.1.1-1.src.rpm
location_href: Packages/python-musiclists-baronsmv-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A command-line tool for downloading, filtering, and transforming top album and
  track lists from music review websites.

  The tool helps you easily aggregate and explore curated album rankings across
  different platforms, making it ideal for music enthusiasts and data-driven
  listeners.



  - Download lists of the top albums and tracks from multiple platforms such as
    [AlbumOfTheYear.org](https://www.albumoftheyear.org/) and
    [ProgArchives.com](https://www.progarchives.com/).
  - Find local albums and tracks in directories and add them to a list.
  - Manipulate individually the lists via filtering, sorting, and limiting of
    entries.
  - Operate between lists as sets (union, intersection, difference).
  - Export to a text file.
  - Convert local albums lists (including transformed ones) to playlists.



  - `bs4`, to navigate and parse HTML tags and values.
  - `click` and `click_help_colors`, to implement the CLI.
  - `m3u8` to write data into a playlist.
  - `mutagen`, to extract metadata from track files.
  - `polars`, to storage and manipulate data.



  ```
  Usage: musiclists [OPTIONS] COMMAND [ARGS]...

  Commands:
    download    Download lists of albums and tracks from music databases.
    duplicates  Manage duplicated entries between lists.
    export      Export lists to other formats.
    files       Get and manage albums and tracks data from files.
    transform   Transform, merge and compare lists.
  ```



  ```
  Usage: musiclists download [OPTIONS] COMMAND [ARGS]...

  Commands:
    aoty  Download a list of top albums and tracks from AlbumOfTheYear.org.
    prog  Download a list of top albums and tracks from ProgArchives.com.
  ```



  ```
  Usage: musiclists transform [albums|tracks] [OPTIONS] COMMAND [ARGS]...

  Commands:
    diff       Find the difference between lists.
    filter     Filter a list.
    intersect  Join lists, only returning entries that are in both lists.
    union      Merge downloaded lists into one, returning any entry of each.
  ```





  ```
  Usage: musiclists download [aoty|prog] [OPTIONS]

  Options:
    -t, --types                     Types of albums to download.
    -c, --ceil / -f, --floor        Round up (ceil) or down (floor) the score.
    -s, --min-score INTEGER         Minimum score threshold for including
                                    albums.
    -S, --max-score INTEGER         Maximum score threshold for including
                                    albums.
  ```



  ```
  Usage: musiclists duplicates find [OPTIONS] [SEARCH]...

  Options:
    -c, --columns                   Columns to consider for the process.
    -d, --data-1                    Source for the data 1.
    -D, --data-2                    Source for the data 2.
    -H, --highest / -A, --all-matches
                                    Returns only the highest match of each
                                    entry, or every match.
    -s, --min-rate FLOAT            Minimum rate of similarity for including
                                    matches.
    -r, --max-results INTEGER       Limit of results to return.
  ```



  ```
  Usage: musiclists export [albums|tracks] [OPTIONS]

  Options:
    -m, --markdown / --no-markdown  Output as MarkDown.
    -d, --data                      Source for the data.
    -n, --name TEXT                 Use a personalized name instead of an auto-
                                    generated one.
    -s, --min-score INTEGER         Minimum score threshold for including
                                    tracks.
    -S, --max-score INTEGER         Maximum score threshold for including
                                    tracks.
    --min-album-score FLOAT         Minimum score threshold for including
                                    albums.
    --max-album-score FLOAT         Maximum score threshold for including
                                    albums.
    -r, --min-ratings INTEGER       Minimum ratings for including entries.
    -R, --max-ratings INTEGER       Maximum ratings for including entries.
    -c, --columns                   Columns to include.
    -C, --sort-by                   Columns to sort by.
    -a, --limit-album INTEGER       Limit of albums returned per album column.
    -A, --limit-artist INTEGER      Limit of tracks returned per artist column.
    -y, --limit-year INTEGER        Limit of tracks returned per year column.
  ```



  ```
  Usage: musiclists transform [albums|tracks] [diff|intersect|union] [OPTIONS]

  Options:
    -d, --data-1                    Source for the data 1.
    -D, --data-2                    Source for the data 2.
    -n, --name TEXT                 Use a personalized name instead of an auto-
                                    generated one.
    -c, --columns                   Columns to consider for the process.
    -k, --key                       Key for the process.
    -d, --dedup / --no-dedup        Deduplicate the output based on its
                                    deduplicates file.
    -K, --dedup-key                 Key for the dedup process.
  ```



  If you like this project or it's helpful to you in any way, consider
  supporting and donating to the websites that made it possible, helping them
  keep running:

  - [Help Support Album of the Year](https://www.albumoftheyear.org/donate/)
  - [Help Support Prog Archives](https://www.paypal.com/donate/?hosted_button_id=DRNRB8RG8NUN2)


pkgId: 668dbcf713c42a62489002bb5188ef379cf7e2d4a22a4c5073ea573229b36008
name: python-musicscore-help
arch: noarch
version: 2.3.1
epoch: 0
release: 1
summary: Development documents and examples for musicscore
url: https://github.com/alexgorji/musicscore.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-musicscore-2.3.1-1.src.rpm
location_href: Packages/python-musicscore-help-2.3.1-1.noarch.rpm
checksum_type: sha256
description:
  Tested with python 3.9, 3.10 and 3.11
  **musicscore** is a python library for generating musicxml data in an intuitive and easy but nevertheless comprehensive way. The generated
  files can be imported in several music notation programs and be processed further if necessary. The preferred software is Finale which
  seems at the moment to have the best implementation of musicxml format files and supports version 4.0.
  For documentation see: `<https://musicscore.readthedocs.io>`_
  The project can be found on GitHub under: `<https://github.com/alexgorji/musicscore>`_
  **musicscore** can be installed via pip:
      (.venv) $ pip install musicscore
  **musicxml** can also be found in a separate repository under: `<https://github.com/alexgorji/musicxml>` and be installed via pip:
      (.venv) $ pip install musicxml


pkgId: d87989c0229df19ab7b6a42856ebe2e0f7c2227ecd3465c69949c472b41f0059
name: python-musicscript-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for musicscript
url: https://pypi.org/project/musicscript/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-musicscript-0.1.2-1.src.rpm
location_href: Packages/python-musicscript-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Downloads songs from Youtube Playlist or Soundcloud and turns them into an Album with Artist metadata.

  Add album to your Apple Music App or Android to listen offline.



  - [yt-dlp](https://github.com/yt-dlp/yt-dlp) - used to download songs from youtube / soundcloud / spotify
  - [ffmpeg](https://ffmpeg.org/download.html) - using for adding metadata to music files



  Install from pypi:

  ```sh
  pip install musicscript
  ```

  Run `musicscript` in terminal:

  ```sh

  musicscript





  ```



  > [!NOTE]
  >
  > ### Installing UV
  >
  > Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) python package manager written in rust
  >
  > ```sh
  > curl -LsSf https://astral.sh/uv/install.sh | sh
  > ```
  >
  > After install uv you can clone this project with:
  >
  > ```sh
  > git clone https://github.com/mmsaki/music-script.git
  > ```

  Run inside project

  ```sh
  cd music-script;

  uv sync;

  uv run musicscript;







  ```



  TODO!

  Enjoy offline streaming!


pkgId: 89e3c4a8aff5a4158dbae10cc7f9a3b0c9b2bcd5bdd0f14bddcdd3acbdfd3736
name: python-mustrd-help
arch: noarch
version: 0.2.6.2
epoch: 0
release: 1
summary: Development documents and examples for mustrd
url: https://github.com/Semantic-partners/mustrd
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mustrd-0.2.6.2-1.src.rpm
location_href: Packages/python-mustrd-help-0.2.6.2-1.noarch.rpm
checksum_type: sha256
description:
  [<img src="https://github.com/Semantic-partners/mustrd/raw/python-coverage-comment-action-data/badge.svg?sanitize=true" alt="coverage badge">](https://github.com/Semantic-partners/mustrd/tree/python-coverage-comment-action-data)



  How do you know your SPARQL, whether it's in a pipeline, or a query, is doing what you intend?

  As much as we love RDF and SPARQL and Semantic Tech in general, we found a small gap in tooling to give us that certainty.

  We missed the powerful testing frameworks that have evolved in imperative languages that help ensure you've written code that does what you think it should.

  We wanted to be able to

  * setup data scenarios and ensure queries worked as expected
  * setup edge cases for queries and ensure they still work
  * isolate small sparql enrichment / transformation steps and know we're only INSERTing what we intend

  Enter MustRD.



  MustRD is a Spec-By-Example ontology, with a reference python implementation, inspired by the likes of Cucumber.

  It's designed to be triplestore/SPARQL engine agnostic (aren't open standards *wonderful*!).


  MustRD is nothing to do with SHACL, or an alternative to it. In fact, we use SHACL for some of our features.

  SHACL provides validation around data.

  MustRD provides validation around data transformations.


  You define your specs in ttl, or trig files.
  We use the SBE approach of *Given*, *When*, *Then* to define starting dataset, an action, and a set of expectations. We build up a set of data.
  Then, depending on whether your SPARQL is a CONSTRUCT, SELECT or a INSERT/DELETE, we run it, and compare results against a set of expectations (*Then*) that are defined in the same way as a *Given* .
  Alternatively, you could define your *Then*

  * as an explicit ASK, or
  * select; or
  * in a higher-order expectation language like you will be used to in various platforms, a set of expectations.




  Soon. It's a work in progress, and we're building the things *we* need for the projects we work on at multiple clients, with multiple vendor stacks.
  We already think it's useful, but it might not meet *your* needs, out of the box.

  We invite you to try it, see where it doesn't fit, and raise an issue, or even better, a PR! If you need something custom, please check out our consultancy rates, and we might be able to prioritise a new feature for you.


  We're a specialist consultancy in Semantic Tech, we're putting this out in case it's useful, but if you need more support, kindly contact our business team on info@semanticpartners.com, or mustrd@semanticpartners.com


pkgId: 498648edd77a5202003c66d90d1d9026eb8a89a5b6d7a70c35c52f79fece872d
name: python-muutils-help
arch: noarch
version: 0.6.18
epoch: 0
release: 1
summary: Development documents and examples for muutils
url: https://pypi.org/project/muutils/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-muutils-0.6.18-1.src.rpm
location_href: Packages/python-muutils-help-0.6.18-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/muutils)](https://pypi.org/project/muutils/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/muutils)
  [![docs](https://img.shields.io/badge/docs-latest-blue)](https://miv.name/muutils)

  [![Checks](https://github.com/mivanit/muutils/actions/workflows/checks.yml/badge.svg)](https://github.com/mivanit/muutils/actions/workflows/checks.yml)
  [![Checks](https://github.com/mivanit/muutils/actions/workflows/make-docs.yml/badge.svg)](https://github.com/mivanit/muutils/actions/workflows/make-docs.yml)
  [![Coverage](docs/coverage/coverage.svg)](docs/coverage/html/)

  ![GitHub commits](https://img.shields.io/github/commit-activity/t/mivanit/muutils)
  ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/mivanit/muutils)
  ![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/mivanit/muutils)
  ![code size, bytes](https://img.shields.io/github/languages/code-size/mivanit/muutils)
  <!-- ![Lines of code](https://img.shields.io/tokei/lines/github.com/mivanit/muutils) -->

  `muutils`, stylized as "$\mu$utils" or "μutils", is a collection of miscellaneous python utilities, meant to be small and with no dependencies outside of standard python.



  PyPi: [muutils](https://pypi.org/project/muutils/)

  ```
  pip install muutils
  ```

  Note that for using `mlutils`, `tensor_utils`, `nbutils.configure_notebook`, or the array serialization features of `json_serialize`, you will need to install with optional `array` dependencies:
  ```
  pip install muutils[array]
  ```



  [**hosted html docs:**](https://miv.name/muutils) https://miv.name/muutils

  - [single-page html docs](https://miv.name/muutils/combined/muutils.html) [(absolute source link)](https://github.com/mivanit/muutils/tree/main/docs/combined/muutils.html)
  - [single-page markdown docs](https://miv.name/muutils/combined/muutils.md) [(absolute source link)](https://github.com/mivanit/muutils/tree/main/docs/combined/muutils.md)
  - Test coverage: [![Test Coverage](https://miv.name/muutils/coverage/coverage.svg)](https://miv.name/muutils/coverage/html/) [webpage](https://miv.name/muutils/coverage/html/) [(absolute source link)](https://github.com/mivanit/muutils/tree/main/docs/coverage/html/) [(plain text)](https://github.com/mivanit/muutils/tree/main/docs/coverage/coverage.txt)





  an extension of `collections.Counter` that provides "smart" computation of stats (mean, variance, median, other percentiles) from the counter object without using `Counter.elements()`



  has utilities for working with dictionaries, like:

    - converting dotlist-dictionaries to nested dictionaries and back:
        ```python
        >>> dotlist_to_nested_dict({'a.b.c': 1, 'a.b.d': 2, 'a.e': 3})
        {'a': {'b': {'c': 1, 'd': 2}, 'e': 3}}
        >>> nested_dict_to_dotlist({'a': {'b': {'c': 1, 'd': 2}, 'e': 3}})
        {'a.b.c': 1, 'a.b.d': 2, 'a.e': 3}
        ```
    - `DefaulterDict` which works like a `defaultdict` but can generate the default value based on the key
    - `condense_tensor_dict` takes a dict of dotlist-tensors and gives a more human-readable summary:
        ```python
        >>> model = MyGPT()
        >>> print(condense_tensor_dict(model.named_parameters(), 'yaml'))
        ```
        ```yaml
        embed:
            W_E: (50257, 768)
        pos_embed:
            W_pos: (1024, 768)
        blocks:
          '[0-11]':
            attn:
            	'[W_Q, W_K, W_V]': (12, 768, 64)
            W_O: (12, 64, 768)
            	'[b_Q, b_K, b_V]': (12, 64)
            b_O: (768,)
  	  <...>
        ```



  Anonymous gettitem, so you can do things like

  ```python
  >>> k = Kappa(lambda x: x**2)
  >>> k[2]
  4
  ```



  utility for getting a bunch of system information. useful for logging.



  contains a few utilities:
      - `stable_hash()` uses `hashlib.sha256` to compute a hash of an object that is stable across runs of python
      - `list_join` and `list_split` which behave like `str.join` and `str.split` but for lists
      - `sanitize_fname` and `dict_to_filename` for simplifying the creation of unique filename
      - `shorten_numerical_to_str()` and `str_to_numeric` turns numbers like `123456789` into `"123M"` and back
      - `freeze`, which prevents an object from being modified. Also see [gelidum](https://github.com/diegojromerolopez/gelidum/)




  contains utilities for working with jupyter notebooks, such as:

  - quickly converting notebooks to python scripts (and running those scripts) for testing in CI
  - configuring notebooks, to make it easier to switch between figure output formats, locations, and more
  - shorthand for displaying mermaid diagrams and TeX



  a tool for serializing and loading arbitrary python objects into json. plays nicely with [`ZANJ`](https://github.com/mivanit/ZANJ/)




  contains minor utilities for working with pytorch tensors and numpy arrays, mostly for making type conversions easier



  groups elements from a sequence according to a given equivalence relation, without assuming that the equivalence relation obeys the transitive property





  an extremely simple utility for reading/writing `jsonl` files



  is a human-readable and simple format for ML models, datasets, and arbitrary objects. It's build around having a zip file with `json` and `npy` files, and has been spun off into its [own project](https://github.com/mivanit/ZANJ/).

  There are a couple work-in-progress utilities in [`_wip`](https://github.com/mivanit/muutils/tree/main/muutils/_wip/) that aren't ready for anything, but nothing in this repo is suitable for production. Use at your own risk!


pkgId: 9663834ccb39c745110bc7591cc9133fe10dfc40fe8899a28ef9b0ba8531ff01
name: python-muzlin-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for muzlin
url: https://github.com/KulikDM/muzlin
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-muzlin-0.0.5-1.src.rpm
location_href: Packages/python-muzlin-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
   What is it?

  Muzlin merges classical ML with advanced generative AI to efficiently
  filter text in the context of NLP and LLMs. It answers key questions in
  semantic-based workflows, such as:
  -  Does a RAG/GraphRAG have the right context to answer a question?
  -  Is the topk retrieved context too dense/sparse?
  -  Does the generated response hallucinate or deviate from the provided
     context?
  -  Should new extracted text be added to an existing RAG?
  -  Can we detect inliers and outliers in collections of text embeddings
     (e.g. context, user question and answers, synthetic generated data,
     etc...)?
  **Note:** While production-ready, Muzlin is still evolving and subject
  to significant changes!

   Quickstart


        pip install muzlin

        import numpy as np
        from muzlin.encoders import HuggingFaceEncoder # Ensure torch and transformers are installed
        encoder = HuggingFaceEncoder()
        vectors = encoder(texts)  # texts is a list of strings
        vectors = np.array(vectors)
        np.save('vectors', vectors)

        from muzlin.anomaly import OutlierDetector
        from pyod.models.pca import PCA
        vectors = np.load('vectors.npy')  # Load pre-saved vectors
        od = PCA(contamination=0.02)
        clf = OutlierDetector(mlflow=False, detector=od) # Saves joblib moddel
        clf.fit(vectors)

        from muzlin.anomaly import OutlierDetector
        from muzlin.encoders import HuggingFaceEncoder
        import numpy as np
        clf = OutlierDetector(model='outlier_detector.pkl')  # Load the model
        encoder = HuggingFaceEncoder()
        vector = encoder(['Who was the first man to walk on the moon?'])
        vector = np.array(vector).reshape(1, -1)
        label = clf.predict(vector)

   Integrations

  Muzlin integrates with a wide array of libraries for anomaly detection,
  vector encoding, and graph-based setups.
  +-----------------------------------+-------------------------+----------------------+
  | **Anomaly Detection**             | **Encoders**            | **Vector Index**     |
  +===================================+=========================+======================+
  | -  Scikit-Learn                   | -  HuggingFace          | -  LangChain         |
  | -  PyOD (vector)                  | -  OpenAI               | -  LlamaIndex        |
  | -  PyGOD (graph)                  | -  Cohere               |                      |
  | -  PyThresh (thresholding)        | -  Azure                |                      |
  |                                   | -  Google               |                      |
  |                                   | -  Amazon Bedrock       |                      |
  |                                   | -  Fastembed            |                      |
  |                                   | -  Mistral              |                      |
  |                                   | -  VoyageAI             |                      |
  +-----------------------------------+-------------------------+----------------------+

rpm_license:
  MIT License  Copyright (c) 2024 Daniel Kulik  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: 0f5f6cbd49f19c6a72cb25c19c06ec61974e79da76896795268e88d94c5be8fa
name: python-mvesuvio-help
arch: noarch
version: 0.0.0.dev310
epoch: 0
release: 1
summary: Development documents and examples for mvesuvio
url: https://pypi.org/project/mvesuvio/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mvesuvio-0.0.0.dev310-1.src.rpm
location_href: Packages/python-mvesuvio-help-0.0.0.dev310-1.noarch.rpm
checksum_type: sha256
description:
  [![Coverage Status](https://coveralls.io/repos/github/mantidproject/vesuvio/badge.svg?branch=main)](https://coveralls.io/github/mantidproject/vesuvio?branch=main)

  This repository contains:
  - `mvesuvio` package containing the Optimized NCP analysis procedures, published nightly.
  - Vesuvio calibration script




  Currently this method is tested up until Mantid 6.8.

  The easiest way to install the package is to install it through pip.
  To pip install mvesuvio, follow these [instructions](https://docs.mantidproject.org/nightly/concepts/PipInstall.html) and replace `<insert_package_name>` with `mvesuvio`.

  Then open mantid workbench and in the editor run the following script:

  ```
  import mvesuvio as mv
  mv.set_config()
  ```

  You will see that the output shows two directories: one for the inputs file and another for the instrument parameters (IP) file.

  Both of these directories sit inside a default location of a `.mvesuvio` folder.

  The `.` in front of the directory name means this folder might be hidden by your OS, so you might have to turn on the option of showing hidden folders.

  You should place of your IP files inside this IP directory, you will notice that I have placed some example files in there already.

  The other directory in the output of the config command tells you which inputs file is being used for running the analysis.

  You should go to the directory of the inputs file and copy-and-paste this file into any directory inside your desktop where you want to run the analysis for a given sample.

  And that's the end of the installation and setup!



  The easiest way to run the analysis scripts is to start with an inputs file and run it from inside mantid workbench.

  Open mantid workbench and navigate to the directory of the inputs file you copy-and-pasted in the last section.

  **Warning**: Do not run the analysis routine on the default location for the inputs file. This will clutter the default `.mvesuvio` folder and may cause problems later down the line.

  Now you can alter the inputs of the file as you see fit. When you are finished, press run. This will run the routine and create a new directory for the output files inside the parent directory of the inputs file.

  To run a new sample, simply copy-and-paste one of the inputs file into any directory you see fit, change the inputs and press run.


  We also provide an alternative conda installation for users wanting to use mantid workbench inside a conda environment.



  To use the `mvesuvio` package you will need to use the `conda` package manager (or preferably  `mamba`, a much faster implementation of `conda`).

  This is also the recommended best practice way of using the mantid packages.

  To download and install mamba:
  - https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html



  Firstly create a conda environment where `mvesuvio` is going to be installed:
  - `mamba create -n <environment_name>`

  Next activate the environment you created:
  - `mamba activate <environment_name>`

  Install mantid workbench (the version is pinned to 6.8 for now):
  - `mamba install mantidworkbench=6.8`

  Finally, install `mvesuvio` through the mantid channel:
  - `mamba install -c mantid/label/nightly mvesuvio`

  Start workbench using the command line:
  - `workbench`


  If using a conda installation, the Command Line Interface (CLI) of the mvesuvio package becomes an attractive feature.

  This allows for setting the inputs file or the IP folder through terminal commands and run the analysis in the terminal (without
  the need for opening mantid workbench).

  You can use `mvesuvio` via the command line. There are two commands available: `config` and `run`.



  The `config` command has two optional arguments:
  - `--set-inputs` - Sets the location of the inputs python file.
  - `--set-ipfolder` - Sets the directory in which `mvesuvio` will look for instrument parameter files.

  If any of these arguments are not provided a default location will be selected. These will be output on the running of `mvesuvo config`

  Usage examples:
  - `mvesuvio config --set-ipfolder C:\IPFolder` - Set instrument parameters folder.
  - `mvesuvio config --set-inputs C:\Vesuvio\experiment\inputs.py` - Set inputs file.



  The `run` command has one optional argument:
  - `--yes` - If provided, this argument automatically inputs `Y` when prompted for user input.

  Usage example:
  - `mvesuvio run --yes` - Run the vesuvio analysis, automatically providing `Y` when prompted.
  - `mvesuvio run`- Run the vesuvio analysis, will wait for user input when prompted.



  If you wish to write a small script using the mvesuvio package and have it run inside workbench,
  `mvesuvio` can be directly imported into the workbench.

  In the workbench script editor you must first import mvesuvio:

  - `import mvesuvio as mv`

  After this you can set the config if desired, as above in the command line example. All arguments are optional.

  - `mv.set_config(inputs_file='C:\Vesuvio\experiment\inputs.py', ip_folder='C:\IPFolder')`

  Following the setting of the config, you can use workbench to open and edit the analysis input file created in the relevant experiment directory.
  Once the inputs have been ammended and the file saved, run the analysis:

  - `mv.run(yes_to_all=True)`


pkgId: 2a8debca22f23776f4c6200e38478485b311f1496a96e3398698b5c77dce7ae4
name: python-mwispy-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for mwispy
url: https://github.com/shbzhang/mwispy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mwispy-1.0.6-1.src.rpm
location_href: Packages/python-mwispy-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  ``mwispy`` derives from the [Milky Way Imaging Scroll Painting (MWISP) project](https://ui.adsabs.harvard.edu/abs/2019ApJS..240....9S).

  > The MWISP project is an unbiased Galactic plane CO survey for mapping region of l=-10° to +250° and |b|<=5.°2 with the 13.7 m telescope of the Purple Mountain Observatory.

  The project produces tens of thousands of datacubes (cells) in FITS format, and their corresponding documents.

  ``mwispy`` contains a set of tools to reduce data of MWISP project.

  ``mwispy`` also contains the ``DataCube`` class (a subclass of [SpectralCube](https://spectral-cube.readthedocs.io/en/latest/)) to reduce datacube of the project.



  Obtain the latest PyPI release with:
  ```sh
  pip install mwispy
  ```

  Upgrade with:
  ```sh
  pip install --upgrade mwispy
  ```



  ``mwispy`` package could be simply imported with:
  ```python
  import mwispy
  ```

  Or import all functions with:
  ```python
  from mwispy import *
  ```



  To mosaic cells to a larger datacube:
  ```python
  from mwispy import mosaic
  mosaic(30, 40, -5, +5, -200, +200, sb='U', path='./', output='G30')
  ```
  * _The function produces a set of mosaicked FITS files, including the datacube, noise, and coverage;_
  * _See more keywords available for ``mosaic`` in its help._



  To calculate the moment of a datacube:
  ```python
  from mwispy import cubemoment
  cubemoment('datacube.fits', crange=[-15, 15], direction='v')
  ```
  * _``crange`` is the velocity range in the unit of km/s._
  * _``cubemoment`` contains a ``goodlooking`` mode which will filter the noise and make the result looking better._
  * _See more keywords available for ``cubemoment`` in its help._

  To derive a longitude-velocity (LV) map:
  ```python
  from mwispy import cubemoment
  cubemoment('datacube.fits', crange=[-1.5, 2.5], direction='b')
  ```
  * _set ``direction`` to `'l'` to derive a BV map._



  To extract position-velocity map from a datacube:

  ```python
  from mwispy import pvslice
  pvslice('datacube.fits', path_coord=[[80,81,82], [-1,1,2]], width=5, step=0.5)
  ```
  * _The function produces three files: the slice map, the path, and the outline of belt._
  * _See more keywords available for ``pvslice`` in its help._



  To tile 2-d images derived from separately mosaicked datacube.
  ```python
  from mwispy import tile
  from glob import glob
  tile(glob('*_U_m0.fits'), output='tile_m0.fits')
  tile(glob('*_U_lvmap.fits'), output='tile_lvmap.fits')
  ```



  To convert velocity to/from channel:
  ```python
  from mwispy import v2c, c2v
  from astropy.io import fits
  hdr = fits.getheader('datacube.fits')
  chan = v2c(hdr, [-10, 10])
  vaxis = c2v(hdr, range(hdr['NAXIS']))
  ```

  To convert a cell name to/from the coordiante:
  ```python
  from mwispy import cell2lb, lb2cell
  l, b = cell2lb('0345+015')
  cell = lb2cell(31.5, -3.5)
  ```



  The ``DataCube`` class provides an alternative way to analyze datacube.

  ``DataCube`` inherits most methods from the ``SpectralCube`` class, and adds several new methods to analyze and visualize datacubes. Analysis like moment could also be done with these methods, but using the above funcions is more efficient.


  ```python
  from mwispy import DataCube
  from astropy.coordinates import SkyCoord
  import astropy.units as u

  cube = DataCube.openMWISP('datacube.fits')
  ```



  This could be done using inherited methods
  ```python

  subcube = cube.spectral_slab(-15*u.km/u.s, 15*u.km/u.s)
  m0 = subcube.moment(order=0)
  m0.write('datacube_m0.fits')


  subcube = cube.subcube(ylo=-1.5*u.deg, yhi=1.5*u.deg)
  lv = subcube.moment(order=0, axis=1)
  lv.write('datacube_lvmap.fits')
  ```


  The rms image will be used for average spectra, or signal detection.
  ```python
  cube = cube.with_rms('datacube_rms.fits')

  cube.rms
  ```


  Mask voxel in the datacube above a value or user defined function.

  Especially useful when calculating some properties with different velocity range at different spatial position.
  ```python

  llo = lambda b,v: b+86*u.deg
  mask = cube.x_mask(llo)
  maskedCube = cube.with_mask(mask)


  blo = lambda l,v: l-86*u.deg
  mask = cube.y_mask(blo)
  maskedCube = cube.with_mask(mask)


  vflo = lambda l,b: ((l/u.deg-84.5)**2*1.5-12.5)*u.km/u.s
  vfhi = 10*u.km/u.s
  mask = cube.z_mask(vflo) & ~cube.z_mask(vfhi)
  maskedCube = cube.with_mask(mask)


  cube = cube.with_rms('datacube_rms.fits')
  mask = cube.v_mask(userms=True, threshold=3, consecutive=3)
  peakv = cube.with_mask(mask)
  ```


  Similar as function ``c2v``.
  ```python

  vaxis = cube.velocity()

  velocity = cube.velocity(channel = [30, 100, 220], vunit = 'km/s')
  ```


  Similar as function ``v2c``.
  ```python

  caxis = cube.channel()

  channel = cube.channel(velocity = [-15, 5, 20], vunit = 'km/s')
  ```


  Similar as function ``pvslice``. The method returns a HDUList contian the slice map, and the path.
  ```python
  path = SkyCoord([80,81,82], [-1,1,2], frame='galactic', unit='deg')
  pvhdu = cube.pvslice(path, width=5, step=0.5)
  pvhdu.write('pvslice.fits')
  ```


  ```python

  fittedCube = cube.with_window(-60, -40, -20, 20, modex = [-200, 200], vunit='km/s')


  fittedCube.baseline(deg=1)


  rms = fittedCube.get_rms()
  ```


  ```python

  avsp1 = cube.average()

  avsp2 = cube.with_rms('datacube_rms.fits').average()


  import matplotlib.pyplot as plt
  plt.step(cube.velocity(), avsp1._data, label='Equal weighting')
  plt.step(cube.velocity(), avsp2._data, label='RMS weighting')
  plt.show()
  ```


  Smooth and rebin the velocity.
  ```python

  rebinnedCube = cube.rebinvelocity(-10, 10, 21, vunit='km/s', largecube=True)


  resampledCube = cube.resample(referenceheader, vunit='km/s')

  resampledCube = cube.resample(201, 100, 0.0, 1.0, vunit='km/s')
  ```



  This method is similar as the ``SpectralCube.plot_channel_maps``,
  but it adjusts figure size automatically, and provide more keyword options.
  ```python

  cube = cube.rebinvelocity(-10, 10, 21, vunit='km/s', largecube=True)


  fig, ax = cube.channelmap(nrows=4, ncols=6, vunit='km/s', figureheight=8, \
  	imshow_kws = dict(vmin=-0.1, vmax=5, cmap='rainbow'),\
  	contour_kws = dict(levels=[1,2,3,4,5,6]),\
  	text_kws = dict(x=0.1, y=0.1, size=5),\
  	tick_kws = dict(size=10, direction='in'),\
  	colorbar_kws = None)


  ax[-1,0].set_xlabel('glon')
  ax[-1,0].set_ylabel('glat')
  ax[-1,0].coords[0].set_major_formatter('d.d')
  ax[-1,0].coords[1].set_major_formatter('d.d')
  plt.show()
  ```


  Plot spectra in grid like ``Gildas``
  ```python

  cube = cube[:, 10:20, 15:25]
  fig, ax = cube.gridmap()
  plt.show()
  ```


  Each pixel in the map represents the velocity of the spectral peak along the line of sight.
  Masking noise before doing this shows better result.
  ```python

  cube = cube.with_rms('datacube_rms.fits')
  mask = cube.v_mask(userms=True, threshold=3, consecutive=3)
  peakv = cube.with_mask(mask).peakvelocity()


  ax = plt.subplot(projection=peakv.wcs)
  ax.imshow(peakv.data)
  plt.show()
  ```


pkgId: ba834425e1ae44eba5fc6dfa3a40925edbb293438a906e8519297b987c326e2f
name: python-mxcubeweb-help
arch: noarch
version: 4.243.0
epoch: 0
release: 1
summary: Development documents and examples for mxcubeweb
url: https://github.com/mxcube/mxcubeweb
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mxcubeweb-4.243.0-1.src.rpm
location_href: Packages/python-mxcubeweb-help-4.243.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build and test](https://github.com/mxcube/mxcubeweb/actions/workflows/build_and_test.yml/badge.svg)](https://github.com/mxcube/mxcubeweb/actions/workflows/build_and_test.yml)
  ![PyPI](https://img.shields.io/pypi/v/mxcubeweb)

  <p align="center"><img src="https://mxcube.github.io/mxcube/img/mxcube_logo20.png" width="125"/></p>



  MXCuBE-Web is the latest generation of the data acquisition software MXCuBE (Macromolecular Xtallography Customized Beamline Environment). The project started in 2005 at [ESRF](https://www.esrf.eu), and has since then been adopted by other institutes in Europe. In 2010, a collaboration agreement has been signed for the development of MXCuBE with the following partners:

  - [ESRF](https://www.esrf.fr/)
  - [Soleil](https://www.synchrotron-soleil.fr/)
  - [MAX IV](https://www.maxiv.lu.se/)
  - [HZB](https://www.helmholtz-berlin.de/)
  - [EMBL](https://www.embl.org/)
  - [Global Phasing Ltd.](https://www.globalphasing.com/)
  - [ALBA](https://www.cells.es/)
  - [DESY](https://www.desy.de/)
  - [LNLS](https://lnls.cnpem.br/)
  - [Elettra](https://www.elettra.eu/)
  - [NSRRC](https://www.nsrrc.org.tw/)
  - [ANSTO](https://www.ansto.gov.au/facilities/australian-synchrotron)

  MXCuBE-Web is developed as a web application and runs in any recent browser.
  The application is built using standard web technologies
  and does not require any third-party plugins to be installed in order to function.
  Being a web application, it is naturally divided into server and client parts.
  The communication between the client and server are made using HTTP/HTTPS and web-sockets.
  It is strongly recommended to use HTTPS, SSL/TLS encrypted HTTP.
  The traffic passes through the conventional HTTP/HTTPS ports,
  minimizing the need for special firewall or proxy settings to get the application to work.

  <img align="center" src="https://mxcube3.esrf.fr/img/client-server.png" width=300>

  The underlying beamline control layer
  is implemented using the library [`mxcubecore`](https://github.com/mxcube/mxcubecore)
  previously known as [`HardwareRepository`](https://github.com/mxcube/HardwareRepository).
  The `mxcubecore` library is compatible with
  both the MXCuBE-Web and the [MXCuBE-Qt](https://github.com/mxcube/mxcubeqt) applications.

  |                                                       Data collection                                                       |                                                       Sample grid                                                       |
  | :-------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------: |
  | ![datacollection-view](https://user-images.githubusercontent.com/4331447/42496925-d983bf3e-8427-11e8-890e-898dda649101.png) | ![samplegrid-view](https://user-images.githubusercontent.com/4331447/42496937-e8547b34-8427-11e8-9447-645e6d7f1dc5.png) |

  Latest information about the MXCuBE project can be found on the
  [MXCuBE project webpage](https://mxcube.github.io/mxcube/).



  The backend is built on the Python [Flask](https://flask.palletsprojects.com/) web framework,
  a library called [SocketIO](https://socket.io/) is further used to provide
  a bidirectional communication channel between backend and client.
  The backend exposes a REST API to the client.

  The UI is implemented in HTML, CSS and JavaScript, mainly with the React, Redux, Boostrap, and FabricJS libraries.



  - [Contributing guidelines](https://github.com/mxcube/mxcubeweb/blob/master/CONTRIBUTING.md)
  - [Developer documentation](https://mxcubeweb.readthedocs.io/)
  - [Development install instructions](https://mxcubeweb.readthedocs.io/en/latest/dev/environment.html#install-with-conda)



  - [User Manual MXCuBE Web](https://www.esrf.fr/mxcube3)
  - [Feature overview](https://github.com/mxcube/mxcubeqt/blob/master/docs/source/feature_overview.rst)
  - If you cite MXCuBE, please use the references:
    > Oscarsson, M. et al. 2019. “MXCuBE2: The Dawn of MXCuBE Collaboration.” Journal of Synchrotron Radiation 26 (Pt 2): 393–405.
    >
    > Gabadinho, J. et al. (2010). MxCuBE: a synchrotron beamline control environment customized for macromolecular crystallography experiments. J. Synchrotron Rad. 17, 700-707


pkgId: dc2f917e1b9624834faa8b3e6df2a9e6e76785910e537fd3378b6732a083218d
name: python-my-datalib-sirine-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for my-datalib-sirine
url: https://pypi.org/project/my-datalib-sirine/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-my-datalib-sirine-2.0.0-1.src.rpm
location_href: Packages/python-my-datalib-sirine-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Voici un exemple d'utilisation de la bibliothèque :
     import pandas as pd
     from datalib.manipulation import read_csv, write_csv, fill_missing_values
     from datalib.data_statistics import calculate_mean, calculate_statistics
     from datalib.visualization import plot_histogram
     from datalib.analysis import linear_regression
     
     file_path = 'path_to_your_data.csv'
     data = read_csv(file_path)
     
     data_filled = fill_missing_values(data)
     
     mean_value = calculate_mean(data_filled['column_name'])
     print(f"La moyenne de la colonne est : {mean_value}")
     
     calculate_statistics(data_filled)
     
     plot_histogram(data_filled['column_name'], title="Histogramme de la colonne_name")
     
     X = data_filled[['feature1']]
     y = data_filled['target']
     model = linear_regression(X, y)
     print(f"Coefficients de la régression linéaire : {model.coef_}")


pkgId: 308b0b209b8d967422258e06c0bff3fd0042c3b3a24ce7a5b1a23d1808e89376
name: python-my-exporter-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for my-exporter
url: https://pypi.org/project/my-exporter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-my-exporter-0.4.1-1.src.rpm
location_href: Packages/python-my-exporter-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  **A Python tool to export the contents of a folder into a single text file while respecting `.gitignore` and optional include patterns, maintaining the hierarchical structure, and optionally handling Jupyter notebook outputs.**



  - [My-Exporter](#my-exporter)
    - [Table of Contents](#table-of-contents)
    - [Features](#features)
    - [Installation](#installation)
    - [Usage](#usage)
      - [Command-Line Interface](#command-line-interface)
      - [Programmatic Usage](#programmatic-usage)
    - [Configuration](#configuration)
    - [Jupyter Notebook Outputs](#jupyter-notebook-outputs)
    - [Converting Notebooks to Python](#converting-notebooks-to-python)
    - [Testing](#testing)
    - [Contributing](#contributing)
    - [License](#license)
    - [Contact](#contact)



  - **Respect `.gitignore` Patterns:** Automatically excludes files and directories based on your `.gitignore` file.
  - **Include Patterns:** Optionally specify an include file to define patterns of files that should always be included.
  - **Hierarchical Structure:** Maintains the folder hierarchy in the exported output by using relative file paths as headers.
  - **Customizable Output:** Specify the root directory, output file name, ignore file, and include file.
  - **Handles Non-Text Files:** Gracefully handles non-text or unreadable files by indicating their presence without content.
  - **Jupyter Notebooks:** By default, strips output cells from `.ipynb` files. You can choose to include them, or convert notebooks entirely to `.py` format while omitting all outputs.



  You can install `my-exporter` via [PyPI](https://pypi.org/) using `pip`:

  ```bash
  pip install my-exporter
  ```

  Alternatively, you can install it directly from the source:

  ```bash
  git clone https://github.com/RK0429/my-exporter.git
  cd my-exporter
  pip install .
  ```





  After installation, the `my-exporter` CLI tool is available.

  **Basic Usage:**

  ```bash
  my-exporter --root-dir path/to/project --output-file exported.txt
  ```

  **Options:**

  - `--root-dir`: Specifies the root directory to start exporting from. Defaults to the current directory (`.`).
  - `--output-file`: Defines the name of the output text file. Defaults to `output.txt`.
  - `--ignore-file`: Specifies a custom ignore file (e.g., `.gitignore`). Defaults to `.gitignore`.
  - `--include-file`: Specifies a file containing patterns of files to include, even if they might otherwise be ignored.
  - `--include-nb-outputs`: If provided, Jupyter notebook output cells are included in the exported content. By default, they are stripped.
  - `--export-nb-as-py`: If provided, Jupyter notebooks (`.ipynb`) are converted into Python files (`.py`-like format) with all outputs omitted.

  **Examples:**

  1. **Basic export:**

     ```bash
     my-exporter --root-dir ./my_project --output-file project_contents.txt
     ```

  2. **Using a custom ignore file:**

     ```bash
     my-exporter --root-dir ./my_project --ignore-file .myignore
     ```

  3. **Using an include file to ensure certain files are always included:**

     ```bash
     my-exporter --root-dir ./my_project --include-file include_patterns.txt
     ```

  4. **Including Jupyter notebook outputs:**

     ```bash
     my-exporter --root-dir ./my_project --include-nb-outputs
     ```

  5. **Converting Jupyter notebooks to Python files (excluding outputs):**

     ```bash
     my-exporter --root-dir ./my_project --export-nb-as-py
     ```



  You can also use `my-exporter` as a library within your Python projects.

  **Example:**

  ```python
  from my_exporter import export_folder_contents

  export_folder_contents(
      root_dir='path/to/project',
      output_file='exported_contents.txt',
      ignore_file='.gitignore',            # Optional
      include_file='include_patterns.txt', # Optional
      exclude_notebook_outputs=False,      # Set to False to include notebook outputs
      convert_notebook_to_py=False         # Set to True to convert notebooks to .py format
  )
  ```



  - **`.gitignore` Support:** The tool uses your `.gitignore` file to determine which files and directories to exclude. Ensure your `.gitignore` is properly configured in the root directory you are exporting.
  - **Custom Ignore Files:** If you prefer to use a different ignore file, specify it using the `--ignore-file` option.
  - **Include Patterns:** You can specify an `--include-file` containing patterns of files that should always be included in the export. These patterns can override `.gitignore` exclusions if desired.



  By default, `my-exporter` removes output cells from Jupyter notebooks (`.ipynb`) to keep the exported file clean and focused on code and markdown cells. If you want to include the output cells, use the `--include-nb-outputs` option or set `exclude_notebook_outputs=False` programmatically.



  If you use `--export-nb-as-py`, notebooks are converted into a `.py`-style format:

  - **Code cells** are included as plain Python code.
  - **Markdown cells** are included as commented-out text.
  - **No output cells** are included, regardless of the `--include-nb-outputs` setting.

  This option is useful if you want a clean, output-free representation of your notebooks as Python scripts.



  This project uses [pytest](https://pytest.org/) for testing.

  To run tests:

  ```bash
  pytest
  ```

  Make sure `pytest` is installed, or install it using:

  ```bash
  pip install pytest
  ```



  Contributions are welcome! Please follow these steps:

  1. **Fork the Repository:** Click the "Fork" button on the repository page.
  2. **Create a Feature Branch:**

     ```bash
     git checkout -b feature/my-new-feature
     ```

  3. **Commit Your Changes:**

     ```bash
     git commit -m "Add some feature"
     ```

  4. **Push to the Branch:**

     ```bash
     git push origin feature/my-new-feature
     ```

  5. **Open a Pull Request:** Describe your changes and submit the pull request.

  Please update tests as appropriate and adhere to the [PEP 8](https://pep8.org/) style guide.



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



  **Your Name**
  Email: [s.woods.m.29@gmail.com](mailto:s.woods.m.29@gmail.com)
  GitHub: [https://github.com/RK0429](https://github.com/RK0429)


pkgId: f5a8140bd74614b19988f65da5d68c580650886e7acc1d4372136d4518487a7e
name: python-my-graph-algorithms-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for my-graph-algorithms
url: https://pypi.org/project/my-graph-algorithms/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-my-graph-algorithms-0.1.2-1.src.rpm
location_href: Packages/python-my-graph-algorithms-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for graph algorithms, including a Floyd-Warshall implementation.



  Install the package using pip:

  ```bash
  pip install my-graph-algorithms




  ```python
  from graphs.floyd_warshall_bidirectional import floyd_warshall_bidirectional


  graph = [[0, 3, float('inf')], [float('inf'), 0, 1], [float('inf'), float('inf'), 0]]
  result = floyd_warshall_bidirectional(graph)
  print(result)


pkgId: 5363a5c0743bb4d82d3d2578dc109a1248366042f5ee80185f7ba2a19f7b6bb4
name: python-mycoffee-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for mycoffee
url: https://github.com/sepandhaghighi/mycoffee
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mycoffee-1.0-1.src.rpm
location_href: Packages/python-mycoffee-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://github.com/sepandhaghighi/mycoffee/raw/main/otherfiles/logo.png" width="500">
  <h1>MyCoffee: Brew Perfect Coffee Right from Your Terminal</h1>
  <br/>
  <a href="https://www.python.org/"><img src="https://img.shields.io/badge/built%20with-Python3-green.svg" alt="built with Python3"></a>
  <a href="https://github.com/sepandhaghighi/mycoffee"><img alt="GitHub repo size" src="https://img.shields.io/github/repo-size/sepandhaghighi/mycoffee"></a>
  <a href="https://badge.fury.io/py/mycoffee"><img src="https://badge.fury.io/py/mycoffee.svg" alt="PyPI version"></a>
  <a href="https://codecov.io/gh/sepandhaghighi/mycoffee" ><img src="https://codecov.io/gh/sepandhaghighi/mycoffee/graph/badge.svg?token=ZelznFDSPA"></a>
  </div>



  <p align="justify">
  <strong>MyCoffee</strong> is a command-line tool for coffee enthusiasts who love brewing with precision. It helps you calculate the perfect coffee-to-water ratio for various brewing methods, ensuring you brew your ideal cup every time-right from your terminal.
  </p>

  <table>
  	<tr>
  		<td align="center">PyPI Counter</td>
  		<td align="center"><a href="http://pepy.tech/project/mycoffee"><img src="http://pepy.tech/badge/mycoffee"></a></td>
  	</tr>
  	<tr>
  		<td align="center">Github Stars</td>
  		<td align="center"><a href="https://github.com/sepandhaghighi/mycoffee"><img src="https://img.shields.io/github/stars/sepandhaghighi/mycoffee.svg?style=social&label=Stars"></a></td>
  	</tr>
  </table>



  <table>
  	<tr>
  		<td align="center">Branch</td>
  		<td align="center">main</td>
  		<td align="center">dev</td>
  	</tr>
  	<tr>
  		<td align="center">CI</td>
  		<td align="center"><img src="https://github.com/sepandhaghighi/mycoffee/actions/workflows/test.yml/badge.svg?branch=main"></td>
  		<td align="center"><img src="https://github.com/sepandhaghighi/mycoffee/actions/workflows/test.yml/badge.svg?branch=dev"></td>
  	</tr>
  </table>


  <table>
  	<tr>
  		<td align="center">Code Quality</td>
  		<td align="center"><a href="https://www.codefactor.io/repository/github/sepandhaghighi/mycoffee"><img src="https://www.codefactor.io/repository/github/sepandhaghighi/mycoffee/badge" alt="CodeFactor"></a></td>
  		<td align="center"><a href="https://codebeat.co/projects/github-com-sepandhaghighi-mycoffee-main"><img alt="codebeat badge" src="https://codebeat.co/badges/8cb2671b-7640-4ac7-bb3e-823bb26a2db2"></a></td>
  		<td align="center"><a href="https://app.codacy.com/gh/sepandhaghighi/mycoffee/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade"><img src="https://app.codacy.com/project/badge/Grade/ac0a8041879042d4a7925272ea3f7ba5"></a></td>
  	</tr>
  </table>





  - Download [Version 1.0](https://github.com/sepandhaghighi/mycoffee/archive/v1.0.zip) or [Latest Source](https://github.com/sepandhaghighi/mycoffee/archive/dev.zip)
  - `pip install .`



  - Check [Python Packaging User Guide](https://packaging.python.org/installing/)
  - `pip install mycoffee==1.0`




  ℹ️ You can use `mycoffee` or `python -m mycoffee` to run this program



  ```shell
  > mycoffee --version

  1.0
  ```



  ```shell
  > mycoffee --method=v60
   __  __  _  _   ___  _____  ____  ____  ____  ____
  (  \/  )( \/ ) / __)(  _  )( ___)( ___)( ___)( ___)
   )    (  \  / ( (__  )(_)(  )__)  )__)  )__)  )__)
  (_/\/\_) (__)  \___)(_____)(__)  (__)  (____)(____)



  Method: `v60`

  Cups: 1

  Coffee: 15 g

  Water: 250 g

  Ratio: 3/50

  Info: V60 method
  ```

  * [Methods List](https://github.com/sepandhaghighi/mycoffee/blob/main/METHODS.md)
  * `mycoffee --methods-list`



  ℹ️ You can run `mycoffee --coffee-units-list` to view the supported coffee units

  ℹ️ You can run `mycoffee --water-units-list` to view the supported water units

  ```shell
  > mycoffee --method=chemex --water=20 --cups=3 --coffee-ratio=2 --water-ratio=37 --coffee-unit=g --water-unit=g

   __  __  _  _   ___  _____  ____  ____  ____  ____
  (  \/  )( \/ ) / __)(  _  )( ___)( ___)( ___)( ___)
   )    (  \  / ( (__  )(_)(  )__)  )__)  )__)  )__)
  (_/\/\_) (__)  \___)(_____)(__)  (__)  (____)(____)



  Method: `chemex`

  Cups: 3

  Coffee: 3.243 g

  Water: 20 g

  Ratio: 2/37

  Info: Chemex method
  ```



  <table>
    <thead>
      <tr>
        <th align="center">Parameter</th>
        <th align="center">Description</th>
        <th align="center">Type</th>
        <th align="center">Default</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td align="center"><code>--method</code></td>
        <td align="center">Specifies the coffee brewing method</td>
        <td align="center">String</td>
        <td align="center"><code>custom</code></td>
      </tr>
      <tr>
        <td align="center"><code>--water</code></td>
        <td align="center">Sets the amount of water in each cup</td>
        <td align="center">Float</td>
        <td align="center"><code>240</code></td>
      </tr>
      <tr>
        <td align="center"><code>--cups</code></td>
        <td align="center">Indicates the number of cups</td>
        <td align="center">Integer</td>
        <td align="center"><code>1</code></td>
      </tr>
      <tr>
        <td align="center"><code>--coffee-ratio</code></td>
        <td align="center">Coefficient for the coffee component in the ratio</td>
        <td align="center">Float</td>
        <td align="center"><code>1</code></td>
      </tr>
      <tr>
        <td align="center"><code>--water-ratio</code></td>
        <td align="center">Coefficient for the water component in the ratio</td>
        <td align="center">Float</td>
        <td align="center"><code>17</code></td>
      </tr>
      <tr>
        <td align="center"><code>--info</code></td>
        <td align="center">Provides information about the brewing method</td>
        <td align="center">String</td>
        <td align="center"><code>Custom brewing method</code></td>
      </tr>
      <tr>
        <td align="center"><code>--digits</code></td>
        <td align="center">Number of digits up to which the result is rounded</td>
        <td align="center">Integer</td>
        <td align="center"><code>3</code></td>
      </tr>
      <tr>
        <td align="center"><code>--coffee-unit</code></td>
        <td align="center">Coffee unit</td>
        <td align="center">String</td>
        <td align="center"><code>g</code></td>
      </tr>
      <tr>
        <td align="center"><code>--water-unit</code></td>
        <td align="center">Water unit</td>
        <td align="center">String</td>
        <td align="center"><code>g</code></td>
      </tr>
    </tbody>
  </table>





  Just fill an issue and describe it. We'll check it ASAP!

  - Please complete the issue template




  <blockquote>1- <a href="https://honestcoffeeguide.com/coffee-to-water-ratio-calculator/">Coffee to water ratio calculator</a></blockquote>
  <blockquote>2- <a href="https://www.origincoffee.co.uk/blogs/journal/brewing-at-home-v60">V60 Brew Guide</a></blockquote>
  <blockquote>3- <a href="https://unionroasted.com/blogs/brewing-guides/chemex-pour-over">How to Brew Coffee with a Chemex</a></blockquote>
  <blockquote>4- <a href="https://www.illy.com/en-us/coffee/coffee-preparation/how-to-use-a-french-press">Using French press for perfect coffee</a></blockquote>
  <blockquote>5- <a href="https://www.haymancoffee.com/blogs/coffee-blog/how-to-brew-the-perfect-cup-of-siphon-coffee">How to Brew the Perfect Cup of Siphon Coffee</a></blockquote>
  <blockquote>6- <a href="https://home.lamarzoccousa.com/using-espresso-brew-ratios/">Using Espresso Brew Ratios</a></blockquote>
  <blockquote>7- <a href="https://www.nicolebattefeld.com/post/best-recipes-2022">My Best Coffee Recipes of 2022</a></blockquote>
  <blockquote>8- <a href="https://wonderstate.com/pages/auto-drip">Auto Drip Brewing Guide</a></blockquote>
  <blockquote>9- <a href="https://counterculturecoffee.com/blogs/counter-culture-coffee/guide-to-cold-brew">Guide To Cold Brew</a></blockquote>
  <blockquote>10- <a href="https://www.thespruceeats.com/cold-brew-concentrate-recipe-5197494">Cold Brew Concentrate Recipe</a></blockquote>
  <blockquote>11- <a href="https://bakedbrewedbeautiful.com/how-to-make-coffee-in-moka-pot/">How to Make Coffee in a Moka Pot</a></blockquote>
  <blockquote>12- <a href="https://www.drinktrade.com/blogs/education/how-to-make-turkish-coffee">How to Make Turkish Coffee at Home</a></blockquote>
  <blockquote>13- <a href="https://www.horshamcoffeeroaster.co.uk/pages/how-to-cup-coffee">How to Cup Coffee</a></blockquote>
  <blockquote>14- <a href="https://aeroprecipe.com/recipes/tetsu-kasuya-aeropress-recipe">Tetsu Kasuya AeroPress Recipe</a></blockquote>
  <blockquote>15- <a href="https://aeroprecipe.com/recipes/all-about-the-intervals">All about the intervals</a></blockquote>
  <blockquote>16- <a href="https://squaremileblog.com/brew-guide-clever-dripper/">Clever Dripper; Square Mile Coffee</a></blockquote>
  <blockquote>17- <a href="https://www.seattlecoffeegear.com/pages/product-resource/aero-press-product-resources">AeroPress Product User Manuals</a></blockquote>
  <blockquote>18- <a href="https://www.rapidtables.com/convert/weight/index.html">RapidTables - Weight Converter</a></blockquote>
  <blockquote>19- <a href="https://honestcoffeeguide.com/whole-bean-to-ground-coffee-ratio/">Whole bean to ground coffee calculator</a></blockquote>
  <blockquote>20- <a href="https://www.howmany.wiki/wv/">Weight to Volume Converter for Recipes</a></blockquote>
  <blockquote>21- <a href="https://chamberlaincoffee.com/blogs/inspiration/how-much-coffee-per-cup-this-is-how-you-get-it-right">How Much Coffee per Cup?</a></blockquote>
  <blockquote>22- <a href="https://www.calculator.net/weight-calculator.html">Weight Calculator</a></blockquote>
  <blockquote>23- <a href="https://www.inchcalculator.com/convert/volume/">Volume Conversion Calculator - Inch Calculator</a></blockquote>



  <h3>Star This Repo</h3>

  Give a ⭐️ if this project helped you!

  <h3>Donate to Our Project</h3>

  <h4>Bitcoin</h4>
  1KtNLEEeUbTEK9PdN6Ya3ZAKXaqoKUuxCy
  <h4>Ethereum</h4>
  0xcD4Db18B6664A9662123D4307B074aE968535388
  <h4>Litecoin</h4>
  Ldnz5gMcEeV8BAdsyf8FstWDC6uyYR6pgZ
  <h4>Doge</h4>
  DDUnKpFQbBqLpFVZ9DfuVysBdr249HxVDh
  <h4>Tron</h4>
  TCZxzPZLcJHr2qR3uPUB1tXB6L3FDSSAx7
  <h4>Ripple</h4>
  rN7ZuRG7HDGHR5nof8nu5LrsbmSB61V1qq
  <h4>Binance Coin</h4>
  bnb1zglwcf0ac3d0s2f6ck5kgwvcru4tlctt4p5qef
  <h4>Tether</h4>
  0xcD4Db18B6664A9662123D4307B074aE968535388
  <h4>Dash</h4>
  Xd3Yn2qZJ7VE8nbKw2fS98aLxR5M6WUU3s
  <h4>Stellar</h4>
  GALPOLPISRHIYHLQER2TLJRGUSZH52RYDK6C3HIU4PSMNAV65Q36EGNL
  <h4>Zilliqa</h4>
  zil1knmz8zj88cf0exr2ry7nav9elehxfcgqu3c5e5
  <h4>Coffeete</h4>
  <a href="http://www.coffeete.ir/opensource">
  <img src="http://www.coffeete.ir/images/buttons/lemonchiffon.png" style="width:260px;" />
  </a>



  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
  and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).




  - 3 new water units
  	1. Pint (`pt`)
  	2. Quart (`qt`)
  	3. Fluid Ounce (`fl oz`)

  - `README.md` updated


  - 4 new water units
  	1. Tablespoon (`tbsp`)
  	2. Teaspoon (`tsp`)
  	3. Dessertspoon (`dsp`)
  	4. Cup (`cup`)


  - 1 new coffee unit
  	1. Cup (`cup`)
  - 6 new water units
  	1. Milliliter (`ml`)
  	2. Liter (`l`)
  	3. Ounce (`oz`)
  	4. Pound (`lb`)
  	5. Milligram (`mg`)
  	6. Kilogram (`kg`)
  - `convert_water` function
  - `show_water_units_list` function
  - `--water-unit` argument

  - Test system modified
  - `README.md` updated


  - 4 new coffee units
  	1. Coffee beans (`cb`)
  	2. Tablespoon (`tbsp`)
  	3. Teaspoon (`tsp`)
  	4. Dessertspoon (`dsp`)
  - `convert_coffee` function

  - GitHub actions are limited to the `dev` and `main` branches


  - `show_coffee_units_list` function
  - `--coffee-unit` argument

  - Test system modified
  - Cups bug fixed
  - `calc_coffee` function updated
  - `README.md` updated
  - `Python 3.13` added to `test.yml`


  - Ratio upper limit
  - Ratio lower limit
  - `check_ratio_limits` function

  - Test system modified
  - `print_message` function renamed to `print_result`


  - 4 new methods
  	1. AeroPress standard
  	2. AeroPress concentrate
  	3. AeroPress inverted
  	4. Steep-and-release
  - `--digits` argument

  - `README.md` updated
  - Test system modified
  - `filter_params` function updated


  - Logo
  - 4 new methods
  	1. Ristretto
  	2. Lungo
  	3. Turkish
  	4. Cupping


  - 5 new methods
  	1. Pour-over
  	2. Auto drip
  	3. Cold brew
  	4. Cold brew concentrate
  	5. Moka pot
  - `is_int` function
  - `filter_params` function

  - `README.md` updated
  - `--coffee-ratio` type changed from `int` to `float`
  - `--water-ratio` type changed from `int` to `float`
  - `coffee_calc` function renamed to `calc_coffee`
  - `print_message` function updated
  - Test system modified


  - 6 new methods
  	1. V60
  	2. Espresso
  	3. Chemex
  	4. French-press
  	5. Siphon
  	6. Custom

  [Unreleased]: https://github.com/sepandhaghighi/mycoffee/compare/v1.0...dev
  [1.0]: https://github.com/sepandhaghighi/mycoffee/compare/v0.9...v1.0
  [0.9]: https://github.com/sepandhaghighi/mycoffee/compare/v0.8...v0.9
  [0.8]: https://github.com/sepandhaghighi/mycoffee/compare/v0.7...v0.8
  [0.7]: https://github.com/sepandhaghighi/mycoffee/compare/v0.6...v0.7
  [0.6]: https://github.com/sepandhaghighi/mycoffee/compare/v0.5...v0.6
  [0.5]: https://github.com/sepandhaghighi/mycoffee/compare/v0.4...v0.5
  [0.4]: https://github.com/sepandhaghighi/mycoffee/compare/v0.3...v0.4
  [0.3]: https://github.com/sepandhaghighi/mycoffee/compare/v0.2...v0.3
  [0.2]: https://github.com/sepandhaghighi/mycoffee/compare/v0.1...v0.2
  [0.1]: https://github.com/sepandhaghighi/mycoffee/compare/c2d0bb4...v0.1


pkgId: 5f72d4bc93e694ff1027963ab922e9c4dd57162880bf03c96778b1d6d4acc380
name: python-mycotools-help
arch: noarch
version: 0.32.10
epoch: 0
release: 1
summary: Development documents and examples for mycotools
description: Comparative genomics automation and standardization software
url: https://github.com/xonq/mycotools
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mycotools-0.32.10-1.src.rpm
location_href: Packages/python-mycotools-help-0.32.10-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright 2023 Zachary Konkel  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 4089b6cce204cbfdc0afaa21378fc85fdee9b9ca208c9541fbedb30efe7d3bfc
name: python-mydatanaut-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for mydatanaut
url: https://github.com/attheodo/mydatanaut
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mydatanaut-0.1.0-1.src.rpm
location_href: Packages/python-mydatanaut-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  `mydatanaut` library provides a convenient way for accessing myData REST API from applications written in the Python language.


  This library was authored primarily to aid the relay of invoices generated by Stripe to AADE/myData in a production django application. Although the current code is being used in production it **should not be considered mature, safe and feature-proof** for your production environment.

  You should treat this library as a basis for contributing improvements such as implementation of new features, bug fixes, test cases and refactorings vs having to implement the API from scratch on your own. This library will be maintained/improved only to the extend the original author sees fit to serve the purposes of other software.

  ⭐️ Contributions are welcome!


  ```
  pip install --upgrade mydatanaut
  ```


  Please see [examples](https://github.com/attheodo/mydatanaut/tree/main/example)


  - Official myDATA webpage: [AADE myDATA](https://www.aade.gr/mydata)
  - Official myDATA documentation: [AADE myDATA REST API v1.0.9](https://www.aade.gr/sites/default/files/2024-07/myDATA%20API%20Documentation%20v1.0.9_official_erp.pdf)

  In order to use this package, you will need a `user id` and a `subscription key`. You can get these credentials by signing up to mydata rest api.

  - Development/Sandbox: [MyData Development API](https://mydata-dev-register.azurewebsites.net/)
  - Production: [MyData](https://www.aade.gr/mydata)



  Progress in developing this library would have been extremely slow and frustrating if not for the PHP package [aade-mydata](https://github.com/firebed/aade-mydata) put together by [Okan Giritli](https://github.com/firebed).


  This library is licenses under the [MIT License](License.md)
  Copyright 2024 © Thanos "attheodo" Theodoridis

rpm_license:
  MIT License  Copyright (c) 2024 Thanos Theodoridis  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: bc2fc7585c78c51fd45ed8c3a71079b2cf4109b5327b140aaa2fa5280112fdfe
name: python-mypy-boto3-account-help
arch: noarch
version: 1.35.83
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-account
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-account-1.35.83-1.src.rpm
location_href: Packages/python-mypy-boto3-account-help-1.35.83-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-account"></a>



  [![PyPI - mypy-boto3-account](https://img.shields.io/pypi/v/mypy-boto3-account.svg?color=blue)](https://pypi.org/project/mypy-boto3-account/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-account.svg?color=blue)](https://pypi.org/project/mypy-boto3-account/)
  [![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/mypy-boto3-account)](https://pypistats.org/packages/mypy-boto3-account)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 Account 1.35.83](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-account docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_account/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-account](#mypy-boto3-account)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.83' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `Account` service.
  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 `Modify` and select `boto3 common` and `Account`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `Account` service.

  ```bash

  python -m pip install 'boto3-stubs[account]'



  python -m pip install 'boto3-stubs-lite[account]'


  python -m pip install mypy-boto3-account
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-account
  ```

  <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[account]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[account]'
  ```

  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[account]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[account]'
  ```

  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[account]'
  ```

  - 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[account]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[account]'
  ```

  - 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[account]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[account]'
  ```

  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[account]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[account]'
  ```

  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
  `mypy-boto3-account` 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>



  <a id="client-annotations"></a>



  `AccountClient` provides annotations for `boto3.client("account")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_account import AccountClient

  client: AccountClient = Session().client("account")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_account.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_account import AccountClient
  from mypy_boto3_account.paginator import ListRegionsPaginator

  client: AccountClient = Session().client("account")



  list_regions_paginator: ListRegionsPaginator = client.get_paginator("list_regions")
  ```

  <a id="literals"></a>



  `mypy_boto3_account.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `Account` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_account/literals/).

  ```python
  from mypy_boto3_account.literals import AlternateContactTypeType


  def check_value(value: AlternateContactTypeType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_account.type_defs` module contains structures and shapes assembled
  to typed dictionaries and unions for additional type checking.

  Full list of `Account` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_account/type_defs/).

  ```python
  from mypy_boto3_account.type_defs import AcceptPrimaryEmailUpdateRequestRequestTypeDef


  def get_value() -> AcceptPrimaryEmailUpdateRequestRequestTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-account` 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/mypy_boto3_account/)

  <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: 4009e822deb5121067d659b07f09ad8a5ce774a027a2d4bb699d92fb4e8568a7
name: python-mypy-boto3-amplify-help
arch: noarch
version: 1.35.84
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-amplify
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-amplify-1.35.84-1.src.rpm
location_href: Packages/python-mypy-boto3-amplify-help-1.35.84-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-amplify"></a>



  [![PyPI - mypy-boto3-amplify](https://img.shields.io/pypi/v/mypy-boto3-amplify.svg?color=blue)](https://pypi.org/project/mypy-boto3-amplify/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-amplify.svg?color=blue)](https://pypi.org/project/mypy-boto3-amplify/)
  [![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/mypy-boto3-amplify)](https://pypistats.org/packages/mypy-boto3-amplify)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 Amplify 1.35.84](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-amplify docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amplify/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-amplify](#mypy-boto3-amplify)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.84' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `Amplify` service.
  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 `Modify` and select `boto3 common` and `Amplify`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `Amplify` service.

  ```bash

  python -m pip install 'boto3-stubs[amplify]'



  python -m pip install 'boto3-stubs-lite[amplify]'


  python -m pip install mypy-boto3-amplify
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-amplify
  ```

  <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[amplify]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  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[amplify]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  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[amplify]'
  ```

  - 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[amplify]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  - 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[amplify]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  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[amplify]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[amplify]'
  ```

  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
  `mypy-boto3-amplify` 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>



  <a id="client-annotations"></a>



  `AmplifyClient` provides annotations for `boto3.client("amplify")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_amplify import AmplifyClient

  client: AmplifyClient = Session().client("amplify")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_amplify.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_amplify import AmplifyClient
  from mypy_boto3_amplify.paginator import (
      ListAppsPaginator,
      ListBranchesPaginator,
      ListDomainAssociationsPaginator,
      ListJobsPaginator,
  )

  client: AmplifyClient = Session().client("amplify")



  list_apps_paginator: ListAppsPaginator = client.get_paginator("list_apps")
  list_branches_paginator: ListBranchesPaginator = client.get_paginator("list_branches")
  list_domain_associations_paginator: ListDomainAssociationsPaginator = client.get_paginator(
      "list_domain_associations"
  )
  list_jobs_paginator: ListJobsPaginator = client.get_paginator("list_jobs")
  ```

  <a id="literals"></a>



  `mypy_boto3_amplify.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `Amplify` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amplify/literals/).

  ```python
  from mypy_boto3_amplify.literals import CacheConfigTypeType


  def check_value(value: CacheConfigTypeType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_amplify.type_defs` module contains structures and shapes assembled
  to typed dictionaries and unions for additional type checking.

  Full list of `Amplify` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_amplify/type_defs/).

  ```python
  from mypy_boto3_amplify.type_defs import AutoBranchCreationConfigOutputTypeDef


  def get_value() -> AutoBranchCreationConfigOutputTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-amplify` 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/mypy_boto3_amplify/)

  <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: 04d1d9beca39d724c3066294a5213b317d41b7d7fd95d2f38ea5dfbbf886442f
name: python-mypy-boto3-appstream-help
arch: noarch
version: 1.35.85
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-appstream
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-appstream-1.35.85-1.src.rpm
location_href: Packages/python-mypy-boto3-appstream-help-1.35.85-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-appstream"></a>



  [![PyPI - mypy-boto3-appstream](https://img.shields.io/pypi/v/mypy-boto3-appstream.svg?color=blue)](https://pypi.org/project/mypy-boto3-appstream/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-appstream.svg?color=blue)](https://pypi.org/project/mypy-boto3-appstream/)
  [![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/mypy-boto3-appstream)](https://pypistats.org/packages/mypy-boto3-appstream)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 AppStream 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.6.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-appstream docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appstream/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-appstream](#mypy-boto3-appstream)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Waiters annotations](#waiters-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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 (legacy boto3-stubs)` AWS SDK.
  3. Add `AppStream` service.
  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 `Modify` and select `boto3 common` and `AppStream`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `AppStream` service.

  ```bash

  python -m pip install 'boto3-stubs[appstream]'



  python -m pip install 'boto3-stubs-lite[appstream]'


  python -m pip install mypy-boto3-appstream
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-appstream
  ```

  <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[appstream]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[appstream]'
  ```

  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[appstream]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[appstream]'
  ```

  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[appstream]'
  ```

  - 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[appstream]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[appstream]'
  ```

  - 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[appstream]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[appstream]'
  ```

  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[appstream]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[appstream]'
  ```

  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
  `mypy-boto3-appstream` 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>



  <a id="client-annotations"></a>



  `AppStreamClient` provides annotations for `boto3.client("appstream")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_appstream import AppStreamClient

  client: AppStreamClient = Session().client("appstream")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_appstream.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_appstream import AppStreamClient
  from mypy_boto3_appstream.paginator import (
      DescribeDirectoryConfigsPaginator,
      DescribeFleetsPaginator,
      DescribeImageBuildersPaginator,
      DescribeImagesPaginator,
      DescribeSessionsPaginator,
      DescribeStacksPaginator,
      DescribeUserStackAssociationsPaginator,
      DescribeUsersPaginator,
      ListAssociatedFleetsPaginator,
      ListAssociatedStacksPaginator,
  )

  client: AppStreamClient = Session().client("appstream")



  describe_directory_configs_paginator: DescribeDirectoryConfigsPaginator = client.get_paginator(
      "describe_directory_configs"
  )
  describe_fleets_paginator: DescribeFleetsPaginator = client.get_paginator("describe_fleets")
  describe_image_builders_paginator: DescribeImageBuildersPaginator = client.get_paginator(
      "describe_image_builders"
  )
  describe_images_paginator: DescribeImagesPaginator = client.get_paginator("describe_images")
  describe_sessions_paginator: DescribeSessionsPaginator = client.get_paginator("describe_sessions")
  describe_stacks_paginator: DescribeStacksPaginator = client.get_paginator("describe_stacks")
  describe_user_stack_associations_paginator: DescribeUserStackAssociationsPaginator = (
      client.get_paginator("describe_user_stack_associations")
  )
  describe_users_paginator: DescribeUsersPaginator = client.get_paginator("describe_users")
  list_associated_fleets_paginator: ListAssociatedFleetsPaginator = client.get_paginator(
      "list_associated_fleets"
  )
  list_associated_stacks_paginator: ListAssociatedStacksPaginator = client.get_paginator(
      "list_associated_stacks"
  )
  ```

  <a id="waiters-annotations"></a>



  `mypy_boto3_appstream.waiter` module contains type annotations for all waiters.

  ```python
  from boto3.session import Session

  from mypy_boto3_appstream import AppStreamClient
  from mypy_boto3_appstream.waiter import FleetStartedWaiter, FleetStoppedWaiter

  client: AppStreamClient = Session().client("appstream")



  fleet_started_waiter: FleetStartedWaiter = client.get_waiter("fleet_started")
  fleet_stopped_waiter: FleetStoppedWaiter = client.get_waiter("fleet_stopped")
  ```

  <a id="literals"></a>



  `mypy_boto3_appstream.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `AppStream` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appstream/literals/).

  ```python
  from mypy_boto3_appstream.literals import AccessEndpointTypeType


  def check_value(value: AccessEndpointTypeType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_appstream.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `AppStream` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_appstream/type_defs/).

  ```python
  from mypy_boto3_appstream.type_defs import AccessEndpointTypeDef


  def get_value() -> AccessEndpointTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-appstream` 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/mypy_boto3_appstream/)

  <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: 4c8201dba8c2ff265d7b9a9805b7ce82d3b5c37cd40cd5025eac2b598a82dea2
name: python-mypy-boto3-backup-help
arch: noarch
version: 1.35.83
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-backup
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-backup-1.35.83-1.src.rpm
location_href: Packages/python-mypy-boto3-backup-help-1.35.83-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-backup"></a>



  [![PyPI - mypy-boto3-backup](https://img.shields.io/pypi/v/mypy-boto3-backup.svg?color=blue)](https://pypi.org/project/mypy-boto3-backup/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-backup.svg?color=blue)](https://pypi.org/project/mypy-boto3-backup/)
  [![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/mypy-boto3-backup)](https://pypistats.org/packages/mypy-boto3-backup)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 Backup 1.35.83](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-backup docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_backup/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-backup](#mypy-boto3-backup)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.83' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `Backup` service.
  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 `Modify` and select `boto3 common` and `Backup`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `Backup` service.

  ```bash

  python -m pip install 'boto3-stubs[backup]'



  python -m pip install 'boto3-stubs-lite[backup]'


  python -m pip install mypy-boto3-backup
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-backup
  ```

  <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[backup]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backup]'
  ```

  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[backup]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backup]'
  ```

  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[backup]'
  ```

  - 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[backup]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backup]'
  ```

  - 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[backup]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backup]'
  ```

  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[backup]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backup]'
  ```

  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
  `mypy-boto3-backup` 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>



  <a id="client-annotations"></a>



  `BackupClient` provides annotations for `boto3.client("backup")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_backup import BackupClient

  client: BackupClient = Session().client("backup")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_backup.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_backup import BackupClient
  from mypy_boto3_backup.paginator import (
      ListBackupJobsPaginator,
      ListBackupPlanTemplatesPaginator,
      ListBackupPlanVersionsPaginator,
      ListBackupPlansPaginator,
      ListBackupSelectionsPaginator,
      ListBackupVaultsPaginator,
      ListCopyJobsPaginator,
      ListIndexedRecoveryPointsPaginator,
      ListLegalHoldsPaginator,
      ListProtectedResourcesByBackupVaultPaginator,
      ListProtectedResourcesPaginator,
      ListRecoveryPointsByBackupVaultPaginator,
      ListRecoveryPointsByLegalHoldPaginator,
      ListRecoveryPointsByResourcePaginator,
      ListRestoreJobsByProtectedResourcePaginator,
      ListRestoreJobsPaginator,
      ListRestoreTestingPlansPaginator,
      ListRestoreTestingSelectionsPaginator,
  )

  client: BackupClient = Session().client("backup")



  list_backup_jobs_paginator: ListBackupJobsPaginator = client.get_paginator("list_backup_jobs")
  list_backup_plan_templates_paginator: ListBackupPlanTemplatesPaginator = client.get_paginator(
      "list_backup_plan_templates"
  )
  list_backup_plan_versions_paginator: ListBackupPlanVersionsPaginator = client.get_paginator(
      "list_backup_plan_versions"
  )
  list_backup_plans_paginator: ListBackupPlansPaginator = client.get_paginator("list_backup_plans")
  list_backup_selections_paginator: ListBackupSelectionsPaginator = client.get_paginator(
      "list_backup_selections"
  )
  list_backup_vaults_paginator: ListBackupVaultsPaginator = client.get_paginator("list_backup_vaults")
  list_copy_jobs_paginator: ListCopyJobsPaginator = client.get_paginator("list_copy_jobs")
  list_indexed_recovery_points_paginator: ListIndexedRecoveryPointsPaginator = client.get_paginator(
      "list_indexed_recovery_points"
  )
  list_legal_holds_paginator: ListLegalHoldsPaginator = client.get_paginator("list_legal_holds")
  list_protected_resources_by_backup_vault_paginator: ListProtectedResourcesByBackupVaultPaginator = (
      client.get_paginator("list_protected_resources_by_backup_vault")
  )
  list_protected_resources_paginator: ListProtectedResourcesPaginator = client.get_paginator(
      "list_protected_resources"
  )
  list_recovery_points_by_backup_vault_paginator: ListRecoveryPointsByBackupVaultPaginator = (
      client.get_paginator("list_recovery_points_by_backup_vault")
  )
  list_recovery_points_by_legal_hold_paginator: ListRecoveryPointsByLegalHoldPaginator = (
      client.get_paginator("list_recovery_points_by_legal_hold")
  )
  list_recovery_points_by_resource_paginator: ListRecoveryPointsByResourcePaginator = (
      client.get_paginator("list_recovery_points_by_resource")
  )
  list_restore_jobs_by_protected_resource_paginator: ListRestoreJobsByProtectedResourcePaginator = (
      client.get_paginator("list_restore_jobs_by_protected_resource")
  )
  list_restore_jobs_paginator: ListRestoreJobsPaginator = client.get_paginator("list_restore_jobs")
  list_restore_testing_plans_paginator: ListRestoreTestingPlansPaginator = client.get_paginator(
      "list_restore_testing_plans"
  )
  list_restore_testing_selections_paginator: ListRestoreTestingSelectionsPaginator = (
      client.get_paginator("list_restore_testing_selections")
  )
  ```

  <a id="literals"></a>



  `mypy_boto3_backup.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `Backup` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_backup/literals/).

  ```python
  from mypy_boto3_backup.literals import AggregationPeriodType


  def check_value(value: AggregationPeriodType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_backup.type_defs` module contains structures and shapes assembled
  to typed dictionaries and unions for additional type checking.

  Full list of `Backup` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_backup/type_defs/).

  ```python
  from mypy_boto3_backup.type_defs import AdvancedBackupSettingOutputTypeDef


  def get_value() -> AdvancedBackupSettingOutputTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-backup` 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/mypy_boto3_backup/)

  <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: 552a50853c262d6ed7f631c87fba166c8e6f764336852b9d9ce368161a274203
name: python-mypy-boto3-backupsearch-help
arch: noarch
version: 1.35.83
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-backupsearch
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-backupsearch-1.35.83-1.src.rpm
location_href: Packages/python-mypy-boto3-backupsearch-help-1.35.83-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-backupsearch"></a>



  [![PyPI - mypy-boto3-backupsearch](https://img.shields.io/pypi/v/mypy-boto3-backupsearch.svg?color=blue)](https://pypi.org/project/mypy-boto3-backupsearch/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-backupsearch.svg?color=blue)](https://pypi.org/project/mypy-boto3-backupsearch/)
  [![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/mypy-boto3-backupsearch)](https://pypistats.org/packages/mypy-boto3-backupsearch)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3 BackupSearch 1.35.83](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-backupsearch docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_backupsearch/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-backupsearch](#mypy-boto3-backupsearch)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.83' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `BackupSearch` service.
  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 `Modify` and select `boto3 common` and `BackupSearch`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `BackupSearch` service.

  ```bash

  python -m pip install 'boto3-stubs[backupsearch]'



  python -m pip install 'boto3-stubs-lite[backupsearch]'


  python -m pip install mypy-boto3-backupsearch
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-backupsearch
  ```

  <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[backupsearch]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backupsearch]'
  ```

  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[backupsearch]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backupsearch]'
  ```

  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[backupsearch]'
  ```

  - 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[backupsearch]` with services you use in your
    environment:

  ```bash
  python -m pip install 'boto3-stubs[backupsearch]'
  ```

  - 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[backupsearch]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backupsearch]'
  ```

  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[backupsearch]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[backupsearch]'
  ```

  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
  `mypy-boto3-backupsearch` 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>



  <a id="client-annotations"></a>



  `BackupSearchClient` provides annotations for `boto3.client("backupsearch")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_backupsearch import BackupSearchClient

  client: BackupSearchClient = Session().client("backupsearch")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_backupsearch.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_backupsearch import BackupSearchClient
  from mypy_boto3_backupsearch.paginator import (
      ListSearchJobBackupsPaginator,
      ListSearchJobResultsPaginator,
      ListSearchJobsPaginator,
      ListSearchResultExportJobsPaginator,
  )

  client: BackupSearchClient = Session().client("backupsearch")



  list_search_job_backups_paginator: ListSearchJobBackupsPaginator = client.get_paginator(
      "list_search_job_backups"
  )
  list_search_job_results_paginator: ListSearchJobResultsPaginator = client.get_paginator(
      "list_search_job_results"
  )
  list_search_jobs_paginator: ListSearchJobsPaginator = client.get_paginator("list_search_jobs")
  list_search_result_export_jobs_paginator: ListSearchResultExportJobsPaginator = (
      client.get_paginator("list_search_result_export_jobs")
  )
  ```

  <a id="literals"></a>



  `mypy_boto3_backupsearch.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  Full list of `BackupSearch` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_backupsearch/literals/).

  ```python
  from mypy_boto3_backupsearch.literals import ExportJobStatusType


  def check_value(value: ExportJobStatusType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_backupsearch.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `BackupSearch` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_backupsearch/type_defs/).

  ```python
  from mypy_boto3_backupsearch.type_defs import BackupCreationTimeFilterOutputTypeDef


  def get_value() -> BackupCreationTimeFilterOutputTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-backupsearch` 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/mypy_boto3_backupsearch/)

  <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: 1a1ae27b5ef4a6713e3f48aa8263694402ff2b89dcad5b2aac962b470670a0a2
name: python-mypy-boto3-batch-help
arch: noarch
version: 1.35.83
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-batch
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-batch-1.35.83-1.src.rpm
location_href: Packages/python-mypy-boto3-batch-help-1.35.83-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-batch"></a>



  [![PyPI - mypy-boto3-batch](https://img.shields.io/pypi/v/mypy-boto3-batch.svg?color=blue)](https://pypi.org/project/mypy-boto3-batch/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-batch.svg?color=blue)](https://pypi.org/project/mypy-boto3-batch/)
  [![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/mypy-boto3-batch)](https://pypistats.org/packages/mypy-boto3-batch)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 Batch 1.35.83](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-batch docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_batch/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-batch](#mypy-boto3-batch)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.83' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `Batch` service.
  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 `Modify` and select `boto3 common` and `Batch`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `Batch` service.

  ```bash

  python -m pip install 'boto3-stubs[batch]'



  python -m pip install 'boto3-stubs-lite[batch]'


  python -m pip install mypy-boto3-batch
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-batch
  ```

  <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[batch]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[batch]'
  ```

  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[batch]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[batch]'
  ```

  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[batch]'
  ```

  - 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[batch]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[batch]'
  ```

  - 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[batch]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[batch]'
  ```

  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[batch]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[batch]'
  ```

  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
  `mypy-boto3-batch` 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>



  <a id="client-annotations"></a>



  `BatchClient` provides annotations for `boto3.client("batch")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_batch import BatchClient

  client: BatchClient = Session().client("batch")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_batch.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_batch import BatchClient
  from mypy_boto3_batch.paginator import (
      DescribeComputeEnvironmentsPaginator,
      DescribeJobDefinitionsPaginator,
      DescribeJobQueuesPaginator,
      ListJobsPaginator,
      ListSchedulingPoliciesPaginator,
  )

  client: BatchClient = Session().client("batch")



  describe_compute_environments_paginator: DescribeComputeEnvironmentsPaginator = (
      client.get_paginator("describe_compute_environments")
  )
  describe_job_definitions_paginator: DescribeJobDefinitionsPaginator = client.get_paginator(
      "describe_job_definitions"
  )
  describe_job_queues_paginator: DescribeJobQueuesPaginator = client.get_paginator(
      "describe_job_queues"
  )
  list_jobs_paginator: ListJobsPaginator = client.get_paginator("list_jobs")
  list_scheduling_policies_paginator: ListSchedulingPoliciesPaginator = client.get_paginator(
      "list_scheduling_policies"
  )
  ```

  <a id="literals"></a>



  `mypy_boto3_batch.literals` module contains literals extracted from shapes that
  can be used in user code for type checking.

  Full list of `Batch` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_batch/literals/).

  ```python
  from mypy_boto3_batch.literals import ArrayJobDependencyType


  def check_value(value: ArrayJobDependencyType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_batch.type_defs` module contains structures and shapes assembled to
  typed dictionaries and unions for additional type checking.

  Full list of `Batch` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_batch/type_defs/).

  ```python
  from mypy_boto3_batch.type_defs import ArrayPropertiesDetailTypeDef


  def get_value() -> ArrayPropertiesDetailTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-batch` 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/mypy_boto3_batch/)

  <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: c204a3abf7ec5d3e03c06f081d4dad918717a523865c20631156f5b3379f0585
name: python-mypy-boto3-budgets-help
arch: noarch
version: 1.35.84
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-budgets
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-budgets-1.35.84-1.src.rpm
location_href: Packages/python-mypy-boto3-budgets-help-1.35.84-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-budgets"></a>



  [![PyPI - mypy-boto3-budgets](https://img.shields.io/pypi/v/mypy-boto3-budgets.svg?color=blue)](https://pypi.org/project/mypy-boto3-budgets/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-budgets.svg?color=blue)](https://pypi.org/project/mypy-boto3-budgets/)
  [![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/mypy-boto3-budgets)](https://pypistats.org/packages/mypy-boto3-budgets)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 Budgets 1.35.84](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-budgets docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_budgets/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-budgets](#mypy-boto3-budgets)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.84' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `Budgets` service.
  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 `Modify` and select `boto3 common` and `Budgets`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `Budgets` service.

  ```bash

  python -m pip install 'boto3-stubs[budgets]'



  python -m pip install 'boto3-stubs-lite[budgets]'


  python -m pip install mypy-boto3-budgets
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-budgets
  ```

  <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[budgets]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[budgets]'
  ```

  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[budgets]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[budgets]'
  ```

  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[budgets]'
  ```

  - 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[budgets]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[budgets]'
  ```

  - 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[budgets]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[budgets]'
  ```

  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[budgets]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[budgets]'
  ```

  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
  `mypy-boto3-budgets` 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>



  <a id="client-annotations"></a>



  `BudgetsClient` provides annotations for `boto3.client("budgets")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_budgets import BudgetsClient

  client: BudgetsClient = Session().client("budgets")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_budgets.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_budgets import BudgetsClient
  from mypy_boto3_budgets.paginator import (
      DescribeBudgetActionHistoriesPaginator,
      DescribeBudgetActionsForAccountPaginator,
      DescribeBudgetActionsForBudgetPaginator,
      DescribeBudgetNotificationsForAccountPaginator,
      DescribeBudgetPerformanceHistoryPaginator,
      DescribeBudgetsPaginator,
      DescribeNotificationsForBudgetPaginator,
      DescribeSubscribersForNotificationPaginator,
  )

  client: BudgetsClient = Session().client("budgets")



  describe_budget_action_histories_paginator: DescribeBudgetActionHistoriesPaginator = (
      client.get_paginator("describe_budget_action_histories")
  )
  describe_budget_actions_for_account_paginator: DescribeBudgetActionsForAccountPaginator = (
      client.get_paginator("describe_budget_actions_for_account")
  )
  describe_budget_actions_for_budget_paginator: DescribeBudgetActionsForBudgetPaginator = (
      client.get_paginator("describe_budget_actions_for_budget")
  )
  describe_budget_notifications_for_account_paginator: DescribeBudgetNotificationsForAccountPaginator = client.get_paginator(
      "describe_budget_notifications_for_account"
  )
  describe_budget_performance_history_paginator: DescribeBudgetPerformanceHistoryPaginator = (
      client.get_paginator("describe_budget_performance_history")
  )
  describe_budgets_paginator: DescribeBudgetsPaginator = client.get_paginator("describe_budgets")
  describe_notifications_for_budget_paginator: DescribeNotificationsForBudgetPaginator = (
      client.get_paginator("describe_notifications_for_budget")
  )
  describe_subscribers_for_notification_paginator: DescribeSubscribersForNotificationPaginator = (
      client.get_paginator("describe_subscribers_for_notification")
  )
  ```

  <a id="literals"></a>



  `mypy_boto3_budgets.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `Budgets` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_budgets/literals/).

  ```python
  from mypy_boto3_budgets.literals import ActionStatusType


  def check_value(value: ActionStatusType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_budgets.type_defs` module contains structures and shapes assembled
  to typed dictionaries and unions for additional type checking.

  Full list of `Budgets` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_budgets/type_defs/).

  ```python
  from mypy_boto3_budgets.type_defs import ActionThresholdTypeDef


  def get_value() -> ActionThresholdTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-budgets` 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/mypy_boto3_budgets/)

  <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: aa3132661a9c8d799033d7ee2909b4cd9aefd52c81669ecab2a2ea3d4caf25e6
name: python-mypy-boto3-cleanroomsml-help
arch: noarch
version: 1.35.83
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-cleanroomsml
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-cleanroomsml-1.35.83-1.src.rpm
location_href: Packages/python-mypy-boto3-cleanroomsml-help-1.35.83-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-cleanroomsml"></a>



  [![PyPI - mypy-boto3-cleanroomsml](https://img.shields.io/pypi/v/mypy-boto3-cleanroomsml.svg?color=blue)](https://pypi.org/project/mypy-boto3-cleanroomsml/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-cleanroomsml.svg?color=blue)](https://pypi.org/project/mypy-boto3-cleanroomsml/)
  [![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/mypy-boto3-cleanroomsml)](https://pypistats.org/packages/mypy-boto3-cleanroomsml)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3 CleanRoomsML 1.35.83](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-cleanroomsml docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cleanroomsml/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-cleanroomsml](#mypy-boto3-cleanroomsml)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.83' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `CleanRoomsML` service.
  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 `Modify` and select `boto3 common` and `CleanRoomsML`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `CleanRoomsML` service.

  ```bash

  python -m pip install 'boto3-stubs[cleanroomsml]'



  python -m pip install 'boto3-stubs-lite[cleanroomsml]'


  python -m pip install mypy-boto3-cleanroomsml
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-cleanroomsml
  ```

  <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[cleanroomsml]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cleanroomsml]'
  ```

  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[cleanroomsml]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cleanroomsml]'
  ```

  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[cleanroomsml]'
  ```

  - 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[cleanroomsml]` with services you use in your
    environment:

  ```bash
  python -m pip install 'boto3-stubs[cleanroomsml]'
  ```

  - 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[cleanroomsml]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cleanroomsml]'
  ```

  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[cleanroomsml]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cleanroomsml]'
  ```

  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
  `mypy-boto3-cleanroomsml` 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>



  <a id="client-annotations"></a>



  `CleanRoomsMLClient` provides annotations for `boto3.client("cleanroomsml")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_cleanroomsml import CleanRoomsMLClient

  client: CleanRoomsMLClient = Session().client("cleanroomsml")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_cleanroomsml.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_cleanroomsml import CleanRoomsMLClient
  from mypy_boto3_cleanroomsml.paginator import (
      ListAudienceExportJobsPaginator,
      ListAudienceGenerationJobsPaginator,
      ListAudienceModelsPaginator,
      ListCollaborationConfiguredModelAlgorithmAssociationsPaginator,
      ListCollaborationMLInputChannelsPaginator,
      ListCollaborationTrainedModelExportJobsPaginator,
      ListCollaborationTrainedModelInferenceJobsPaginator,
      ListCollaborationTrainedModelsPaginator,
      ListConfiguredAudienceModelsPaginator,
      ListConfiguredModelAlgorithmAssociationsPaginator,
      ListConfiguredModelAlgorithmsPaginator,
      ListMLInputChannelsPaginator,
      ListTrainedModelInferenceJobsPaginator,
      ListTrainedModelsPaginator,
      ListTrainingDatasetsPaginator,
  )

  client: CleanRoomsMLClient = Session().client("cleanroomsml")



  list_audience_export_jobs_paginator: ListAudienceExportJobsPaginator = client.get_paginator(
      "list_audience_export_jobs"
  )
  list_audience_generation_jobs_paginator: ListAudienceGenerationJobsPaginator = client.get_paginator(
      "list_audience_generation_jobs"
  )
  list_audience_models_paginator: ListAudienceModelsPaginator = client.get_paginator(
      "list_audience_models"
  )
  list_collaboration_configured_model_algorithm_associations_paginator: ListCollaborationConfiguredModelAlgorithmAssociationsPaginator = client.get_paginator(
      "list_collaboration_configured_model_algorithm_associations"
  )
  list_collaboration_ml_input_channels_paginator: ListCollaborationMLInputChannelsPaginator = (
      client.get_paginator("list_collaboration_ml_input_channels")
  )
  list_collaboration_trained_model_export_jobs_paginator: ListCollaborationTrainedModelExportJobsPaginator = client.get_paginator(
      "list_collaboration_trained_model_export_jobs"
  )
  list_collaboration_trained_model_inference_jobs_paginator: ListCollaborationTrainedModelInferenceJobsPaginator = client.get_paginator(
      "list_collaboration_trained_model_inference_jobs"
  )
  list_collaboration_trained_models_paginator: ListCollaborationTrainedModelsPaginator = (
      client.get_paginator("list_collaboration_trained_models")
  )
  list_configured_audience_models_paginator: ListConfiguredAudienceModelsPaginator = (
      client.get_paginator("list_configured_audience_models")
  )
  list_configured_model_algorithm_associations_paginator: ListConfiguredModelAlgorithmAssociationsPaginator = client.get_paginator(
      "list_configured_model_algorithm_associations"
  )
  list_configured_model_algorithms_paginator: ListConfiguredModelAlgorithmsPaginator = (
      client.get_paginator("list_configured_model_algorithms")
  )
  list_ml_input_channels_paginator: ListMLInputChannelsPaginator = client.get_paginator(
      "list_ml_input_channels"
  )
  list_trained_model_inference_jobs_paginator: ListTrainedModelInferenceJobsPaginator = (
      client.get_paginator("list_trained_model_inference_jobs")
  )
  list_trained_models_paginator: ListTrainedModelsPaginator = client.get_paginator(
      "list_trained_models"
  )
  list_training_datasets_paginator: ListTrainingDatasetsPaginator = client.get_paginator(
      "list_training_datasets"
  )
  ```

  <a id="literals"></a>



  `mypy_boto3_cleanroomsml.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  Full list of `CleanRoomsML` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cleanroomsml/literals/).

  ```python
  from mypy_boto3_cleanroomsml.literals import AudienceExportJobStatusType


  def check_value(value: AudienceExportJobStatusType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_cleanroomsml.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `CleanRoomsML` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cleanroomsml/type_defs/).

  ```python
  from mypy_boto3_cleanroomsml.type_defs import S3ConfigMapTypeDef


  def get_value() -> S3ConfigMapTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-cleanroomsml` 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/mypy_boto3_cleanroomsml/)

  <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: fe6aa6270ee81b3278bfa2e45e67d993242f3581a8a09069492f2264dbf88f41
name: python-mypy-boto3-cloud9-help
arch: noarch
version: 1.35.82
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-cloud9
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-cloud9-1.35.82-1.src.rpm
location_href: Packages/python-mypy-boto3-cloud9-help-1.35.82-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-cloud9"></a>



  [![PyPI - mypy-boto3-cloud9](https://img.shields.io/pypi/v/mypy-boto3-cloud9.svg?color=blue)](https://pypi.org/project/mypy-boto3-cloud9/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-cloud9.svg?color=blue)](https://pypi.org/project/mypy-boto3-cloud9/)
  [![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/mypy-boto3-cloud9)](https://pypistats.org/packages/mypy-boto3-cloud9)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 Cloud9 1.35.82](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
  [mypy-boto3-cloud9 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloud9/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-cloud9](#mypy-boto3-cloud9)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.82' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `Cloud9` service.
  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 `Modify` and select `boto3 common` and `Cloud9`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `Cloud9` service.

  ```bash

  python -m pip install 'boto3-stubs[cloud9]'



  python -m pip install 'boto3-stubs-lite[cloud9]'


  python -m pip install mypy-boto3-cloud9
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-cloud9
  ```

  <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[cloud9]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloud9]'
  ```

  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[cloud9]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloud9]'
  ```

  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[cloud9]'
  ```

  - 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[cloud9]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloud9]'
  ```

  - 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[cloud9]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloud9]'
  ```

  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[cloud9]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloud9]'
  ```

  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
  `mypy-boto3-cloud9` 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>



  <a id="client-annotations"></a>



  `Cloud9Client` provides annotations for `boto3.client("cloud9")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_cloud9 import Cloud9Client

  client: Cloud9Client = Session().client("cloud9")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_cloud9.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_cloud9 import Cloud9Client
  from mypy_boto3_cloud9.paginator import (
      DescribeEnvironmentMembershipsPaginator,
      ListEnvironmentsPaginator,
  )

  client: Cloud9Client = Session().client("cloud9")



  describe_environment_memberships_paginator: DescribeEnvironmentMembershipsPaginator = (
      client.get_paginator("describe_environment_memberships")
  )
  list_environments_paginator: ListEnvironmentsPaginator = client.get_paginator("list_environments")
  ```

  <a id="literals"></a>



  `mypy_boto3_cloud9.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `Cloud9` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloud9/literals/).

  ```python
  from mypy_boto3_cloud9.literals import ConnectionTypeType


  def check_value(value: ConnectionTypeType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_cloud9.type_defs` module contains structures and shapes assembled
  to typed dictionaries and unions for additional type checking.

  Full list of `Cloud9` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloud9/type_defs/).

  ```python
  from mypy_boto3_cloud9.type_defs import TagTypeDef


  def get_value() -> TagTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-cloud9` 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/mypy_boto3_cloud9/)

  <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: 4d65774525351e1ba1d344dcc84e0bed013d1e5030e5470c6f2b4a92b2dcdaea
name: python-mypy-boto3-cloudfront-help
arch: noarch
version: 1.35.83
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-cloudfront
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-cloudfront-1.35.83-1.src.rpm
location_href: Packages/python-mypy-boto3-cloudfront-help-1.35.83-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-cloudfront"></a>



  [![PyPI - mypy-boto3-cloudfront](https://img.shields.io/pypi/v/mypy-boto3-cloudfront.svg?color=blue)](https://pypi.org/project/mypy-boto3-cloudfront/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-cloudfront.svg?color=blue)](https://pypi.org/project/mypy-boto3-cloudfront/)
  [![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/mypy-boto3-cloudfront)](https://pypistats.org/packages/mypy-boto3-cloudfront)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3 CloudFront 1.35.83](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-cloudfront docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudfront/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-cloudfront](#mypy-boto3-cloudfront)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Waiters annotations](#waiters-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.83' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `CloudFront` service.
  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 `Modify` and select `boto3 common` and `CloudFront`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `CloudFront` service.

  ```bash

  python -m pip install 'boto3-stubs[cloudfront]'



  python -m pip install 'boto3-stubs-lite[cloudfront]'


  python -m pip install mypy-boto3-cloudfront
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-cloudfront
  ```

  <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[cloudfront]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudfront]'
  ```

  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[cloudfront]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudfront]'
  ```

  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[cloudfront]'
  ```

  - 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[cloudfront]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudfront]'
  ```

  - 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[cloudfront]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudfront]'
  ```

  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[cloudfront]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudfront]'
  ```

  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
  `mypy-boto3-cloudfront` 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>



  <a id="client-annotations"></a>



  `CloudFrontClient` provides annotations for `boto3.client("cloudfront")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_cloudfront import CloudFrontClient

  client: CloudFrontClient = Session().client("cloudfront")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_cloudfront.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_cloudfront import CloudFrontClient
  from mypy_boto3_cloudfront.paginator import (
      ListCloudFrontOriginAccessIdentitiesPaginator,
      ListDistributionsPaginator,
      ListInvalidationsPaginator,
      ListKeyValueStoresPaginator,
      ListPublicKeysPaginator,
      ListStreamingDistributionsPaginator,
  )

  client: CloudFrontClient = Session().client("cloudfront")



  list_cloud_front_origin_access_identities_paginator: ListCloudFrontOriginAccessIdentitiesPaginator = client.get_paginator(
      "list_cloud_front_origin_access_identities"
  )
  list_distributions_paginator: ListDistributionsPaginator = client.get_paginator(
      "list_distributions"
  )
  list_invalidations_paginator: ListInvalidationsPaginator = client.get_paginator(
      "list_invalidations"
  )
  list_key_value_stores_paginator: ListKeyValueStoresPaginator = client.get_paginator(
      "list_key_value_stores"
  )
  list_public_keys_paginator: ListPublicKeysPaginator = client.get_paginator("list_public_keys")
  list_streaming_distributions_paginator: ListStreamingDistributionsPaginator = client.get_paginator(
      "list_streaming_distributions"
  )
  ```

  <a id="waiters-annotations"></a>



  `mypy_boto3_cloudfront.waiter` module contains type annotations for all
  waiters.

  ```python
  from boto3.session import Session

  from mypy_boto3_cloudfront import CloudFrontClient
  from mypy_boto3_cloudfront.waiter import (
      DistributionDeployedWaiter,
      InvalidationCompletedWaiter,
      StreamingDistributionDeployedWaiter,
  )

  client: CloudFrontClient = Session().client("cloudfront")



  distribution_deployed_waiter: DistributionDeployedWaiter = client.get_waiter(
      "distribution_deployed"
  )
  invalidation_completed_waiter: InvalidationCompletedWaiter = client.get_waiter(
      "invalidation_completed"
  )
  streaming_distribution_deployed_waiter: StreamingDistributionDeployedWaiter = client.get_waiter(
      "streaming_distribution_deployed"
  )
  ```

  <a id="literals"></a>



  `mypy_boto3_cloudfront.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `CloudFront` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudfront/literals/).

  ```python
  from mypy_boto3_cloudfront.literals import CachePolicyCookieBehaviorType


  def check_value(value: CachePolicyCookieBehaviorType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_cloudfront.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `CloudFront` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudfront/type_defs/).

  ```python
  from mypy_boto3_cloudfront.type_defs import AliasICPRecordalTypeDef


  def get_value() -> AliasICPRecordalTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-cloudfront` 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/mypy_boto3_cloudfront/)

  <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: c47467466dc0d6d388b1a05fb7310119777e6287ea842c9b027dadd43c3948a2
name: python-mypy-boto3-cloudhsmv2-help
arch: noarch
version: 1.35.81
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-cloudhsmv2
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-cloudhsmv2-1.35.81-1.src.rpm
location_href: Packages/python-mypy-boto3-cloudhsmv2-help-1.35.81-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-cloudhsmv2"></a>



  [![PyPI - mypy-boto3-cloudhsmv2](https://img.shields.io/pypi/v/mypy-boto3-cloudhsmv2.svg?color=blue)](https://pypi.org/project/mypy-boto3-cloudhsmv2/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-cloudhsmv2.svg?color=blue)](https://pypi.org/project/mypy-boto3-cloudhsmv2/)
  [![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/mypy-boto3-cloudhsmv2)](https://pypistats.org/packages/mypy-boto3-cloudhsmv2)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3 CloudHSMV2 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
  [mypy-boto3-cloudhsmv2 docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudhsmv2/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-cloudhsmv2](#mypy-boto3-cloudhsmv2)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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 `CloudHSMV2` service.
  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 `Modify` and select `boto3 common` and `CloudHSMV2`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `CloudHSMV2` service.

  ```bash

  python -m pip install 'boto3-stubs[cloudhsmv2]'



  python -m pip install 'boto3-stubs-lite[cloudhsmv2]'


  python -m pip install mypy-boto3-cloudhsmv2
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-cloudhsmv2
  ```

  <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[cloudhsmv2]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudhsmv2]'
  ```

  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[cloudhsmv2]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudhsmv2]'
  ```

  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[cloudhsmv2]'
  ```

  - 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[cloudhsmv2]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudhsmv2]'
  ```

  - 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[cloudhsmv2]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudhsmv2]'
  ```

  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[cloudhsmv2]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[cloudhsmv2]'
  ```

  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
  `mypy-boto3-cloudhsmv2` 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>



  <a id="client-annotations"></a>



  `CloudHSMV2Client` provides annotations for `boto3.client("cloudhsmv2")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_cloudhsmv2 import CloudHSMV2Client

  client: CloudHSMV2Client = Session().client("cloudhsmv2")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_cloudhsmv2.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_cloudhsmv2 import CloudHSMV2Client
  from mypy_boto3_cloudhsmv2.paginator import (
      DescribeBackupsPaginator,
      DescribeClustersPaginator,
      ListTagsPaginator,
  )

  client: CloudHSMV2Client = Session().client("cloudhsmv2")



  describe_backups_paginator: DescribeBackupsPaginator = client.get_paginator("describe_backups")
  describe_clusters_paginator: DescribeClustersPaginator = client.get_paginator("describe_clusters")
  list_tags_paginator: ListTagsPaginator = client.get_paginator("list_tags")
  ```

  <a id="literals"></a>



  `mypy_boto3_cloudhsmv2.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `CloudHSMV2` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudhsmv2/literals/).

  ```python
  from mypy_boto3_cloudhsmv2.literals import BackupPolicyType


  def check_value(value: BackupPolicyType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_cloudhsmv2.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `CloudHSMV2` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_cloudhsmv2/type_defs/).

  ```python
  from mypy_boto3_cloudhsmv2.type_defs import BackupRetentionPolicyTypeDef


  def get_value() -> BackupRetentionPolicyTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-cloudhsmv2` 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/mypy_boto3_cloudhsmv2/)

  <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: 89e136e0aef795e81cbf79cfa113fa741fb22240b145886e1be26be5e4c307d7
name: python-mypy-boto3-codepipeline-help
arch: noarch
version: 1.35.83
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-codepipeline
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-codepipeline-1.35.83-1.src.rpm
location_href: Packages/python-mypy-boto3-codepipeline-help-1.35.83-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-codepipeline"></a>



  [![PyPI - mypy-boto3-codepipeline](https://img.shields.io/pypi/v/mypy-boto3-codepipeline.svg?color=blue)](https://pypi.org/project/mypy-boto3-codepipeline/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-codepipeline.svg?color=blue)](https://pypi.org/project/mypy-boto3-codepipeline/)
  [![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/mypy-boto3-codepipeline)](https://pypistats.org/packages/mypy-boto3-codepipeline)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3 CodePipeline 1.35.83](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-codepipeline docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codepipeline/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-codepipeline](#mypy-boto3-codepipeline)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.83' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `CodePipeline` service.
  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 `Modify` and select `boto3 common` and `CodePipeline`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `CodePipeline` service.

  ```bash

  python -m pip install 'boto3-stubs[codepipeline]'



  python -m pip install 'boto3-stubs-lite[codepipeline]'


  python -m pip install mypy-boto3-codepipeline
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-codepipeline
  ```

  <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[codepipeline]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[codepipeline]'
  ```

  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[codepipeline]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[codepipeline]'
  ```

  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[codepipeline]'
  ```

  - 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[codepipeline]` with services you use in your
    environment:

  ```bash
  python -m pip install 'boto3-stubs[codepipeline]'
  ```

  - 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[codepipeline]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[codepipeline]'
  ```

  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[codepipeline]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[codepipeline]'
  ```

  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
  `mypy-boto3-codepipeline` 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>



  <a id="client-annotations"></a>



  `CodePipelineClient` provides annotations for `boto3.client("codepipeline")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_codepipeline import CodePipelineClient

  client: CodePipelineClient = Session().client("codepipeline")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_codepipeline.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_codepipeline import CodePipelineClient
  from mypy_boto3_codepipeline.paginator import (
      ListActionExecutionsPaginator,
      ListActionTypesPaginator,
      ListPipelineExecutionsPaginator,
      ListPipelinesPaginator,
      ListRuleExecutionsPaginator,
      ListTagsForResourcePaginator,
      ListWebhooksPaginator,
  )

  client: CodePipelineClient = Session().client("codepipeline")



  list_action_executions_paginator: ListActionExecutionsPaginator = client.get_paginator(
      "list_action_executions"
  )
  list_action_types_paginator: ListActionTypesPaginator = client.get_paginator("list_action_types")
  list_pipeline_executions_paginator: ListPipelineExecutionsPaginator = client.get_paginator(
      "list_pipeline_executions"
  )
  list_pipelines_paginator: ListPipelinesPaginator = client.get_paginator("list_pipelines")
  list_rule_executions_paginator: ListRuleExecutionsPaginator = client.get_paginator(
      "list_rule_executions"
  )
  list_tags_for_resource_paginator: ListTagsForResourcePaginator = client.get_paginator(
      "list_tags_for_resource"
  )
  list_webhooks_paginator: ListWebhooksPaginator = client.get_paginator("list_webhooks")
  ```

  <a id="literals"></a>



  `mypy_boto3_codepipeline.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  Full list of `CodePipeline` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codepipeline/literals/).

  ```python
  from mypy_boto3_codepipeline.literals import ActionCategoryType


  def check_value(value: ActionCategoryType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_codepipeline.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `CodePipeline` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_codepipeline/type_defs/).

  ```python
  from mypy_boto3_codepipeline.type_defs import AWSSessionCredentialsTypeDef


  def get_value() -> AWSSessionCredentialsTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-codepipeline` 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/mypy_boto3_codepipeline/)

  <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: 2b8a401030e7e1f4fffe808d75d099eaabb7af717d99321e06a4677e759372c5
name: python-mypy-boto3-connect-help
arch: noarch
version: 1.35.84
epoch: 0
release: 1
summary: Development documents and examples for mypy-boto3-connect
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mypy-boto3-connect-1.35.84-1.src.rpm
location_href: Packages/python-mypy-boto3-connect-help-1.35.84-1.noarch.rpm
checksum_type: sha256
description:
  <a id="mypy-boto3-connect"></a>



  [![PyPI - mypy-boto3-connect](https://img.shields.io/pypi/v/mypy-boto3-connect.svg?color=blue)](https://pypi.org/project/mypy-boto3-connect/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mypy-boto3-connect.svg?color=blue)](https://pypi.org/project/mypy-boto3-connect/)
  [![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/mypy-boto3-connect)](https://pypistats.org/packages/mypy-boto3-connect)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 Connect 1.35.84](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.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [boto3-stubs](https://pypi.org/project/boto3-stubs/) page and in
  [mypy-boto3-connect docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connect/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [mypy-boto3-connect](#mypy-boto3-connect)
    - [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)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [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.84' mypy_boto3_builder`
  2. Select `boto3 (legacy boto3-stubs)` AWS SDK.
  3. Add `Connect` service.
  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 `Modify` and select `boto3 common` and `Connect`.

  <a id="from-pypi-with-pip"></a>



  Install `boto3-stubs` for `Connect` service.

  ```bash

  python -m pip install 'boto3-stubs[connect]'



  python -m pip install 'boto3-stubs-lite[connect]'


  python -m pip install mypy-boto3-connect
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y mypy-boto3-connect
  ```

  <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[connect]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[connect]'
  ```

  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[connect]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[connect]'
  ```

  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[connect]'
  ```

  - 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[connect]` with services you use in your environment:

  ```bash
  python -m pip install 'boto3-stubs[connect]'
  ```

  - 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[connect]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[connect]'
  ```

  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[connect]` in your environment:

  ```bash
  python -m pip install 'boto3-stubs[connect]'
  ```

  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
  `mypy-boto3-connect` 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>



  <a id="client-annotations"></a>



  `ConnectClient` provides annotations for `boto3.client("connect")`.

  ```python
  from boto3.session import Session

  from mypy_boto3_connect import ConnectClient

  client: ConnectClient = Session().client("connect")


  ```

  <a id="paginators-annotations"></a>



  `mypy_boto3_connect.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from mypy_boto3_connect import ConnectClient
  from mypy_boto3_connect.paginator import (
      GetMetricDataPaginator,
      ListAgentStatusesPaginator,
      ListApprovedOriginsPaginator,
      ListAuthenticationProfilesPaginator,
      ListBotsPaginator,
      ListContactEvaluationsPaginator,
      ListContactFlowModulesPaginator,
      ListContactFlowVersionsPaginator,
      ListContactFlowsPaginator,
      ListContactReferencesPaginator,
      ListDefaultVocabulariesPaginator,
      ListEvaluationFormVersionsPaginator,
      ListEvaluationFormsPaginator,
      ListFlowAssociationsPaginator,
      ListHoursOfOperationOverridesPaginator,
      ListHoursOfOperationsPaginator,
      ListInstanceAttributesPaginator,
      ListInstanceStorageConfigsPaginator,
      ListInstancesPaginator,
      ListIntegrationAssociationsPaginator,
      ListLambdaFunctionsPaginator,
      ListLexBotsPaginator,
      ListPhoneNumbersPaginator,
      ListPhoneNumbersV2Paginator,
      ListPredefinedAttributesPaginator,
      ListPromptsPaginator,
      ListQueueQuickConnectsPaginator,
      ListQueuesPaginator,
      ListQuickConnectsPaginator,
      ListRoutingProfileQueuesPaginator,
      ListRoutingProfilesPaginator,
      ListRulesPaginator,
      ListSecurityKeysPaginator,
      ListSecurityProfileApplicationsPaginator,
      ListSecurityProfilePermissionsPaginator,
      ListSecurityProfilesPaginator,
      ListTaskTemplatesPaginator,
      ListTrafficDistributionGroupUsersPaginator,
      ListTrafficDistributionGroupsPaginator,
      ListUseCasesPaginator,
      ListUserHierarchyGroupsPaginator,
      ListUserProficienciesPaginator,
      ListUsersPaginator,
      ListViewVersionsPaginator,
      ListViewsPaginator,
      SearchAgentStatusesPaginator,
      SearchAvailablePhoneNumbersPaginator,
      SearchContactFlowModulesPaginator,
      SearchContactFlowsPaginator,
      SearchContactsPaginator,
      SearchHoursOfOperationOverridesPaginator,
      SearchHoursOfOperationsPaginator,
      SearchPredefinedAttributesPaginator,
      SearchPromptsPaginator,
      SearchQueuesPaginator,
      SearchQuickConnectsPaginator,
      SearchResourceTagsPaginator,
      SearchRoutingProfilesPaginator,
      SearchSecurityProfilesPaginator,
      SearchUserHierarchyGroupsPaginator,
      SearchUsersPaginator,
      SearchVocabulariesPaginator,
  )

  client: ConnectClient = Session().client("connect")



  get_metric_data_paginator: GetMetricDataPaginator = client.get_paginator("get_metric_data")
  list_agent_statuses_paginator: ListAgentStatusesPaginator = client.get_paginator(
      "list_agent_statuses"
  )
  list_approved_origins_paginator: ListApprovedOriginsPaginator = client.get_paginator(
      "list_approved_origins"
  )
  list_authentication_profiles_paginator: ListAuthenticationProfilesPaginator = client.get_paginator(
      "list_authentication_profiles"
  )
  list_bots_paginator: ListBotsPaginator = client.get_paginator("list_bots")
  list_contact_evaluations_paginator: ListContactEvaluationsPaginator = client.get_paginator(
      "list_contact_evaluations"
  )
  list_contact_flow_modules_paginator: ListContactFlowModulesPaginator = client.get_paginator(
      "list_contact_flow_modules"
  )
  list_contact_flow_versions_paginator: ListContactFlowVersionsPaginator = client.get_paginator(
      "list_contact_flow_versions"
  )
  list_contact_flows_paginator: ListContactFlowsPaginator = client.get_paginator("list_contact_flows")
  list_contact_references_paginator: ListContactReferencesPaginator = client.get_paginator(
      "list_contact_references"
  )
  list_default_vocabularies_paginator: ListDefaultVocabulariesPaginator = client.get_paginator(
      "list_default_vocabularies"
  )
  list_evaluation_form_versions_paginator: ListEvaluationFormVersionsPaginator = client.get_paginator(
      "list_evaluation_form_versions"
  )
  list_evaluation_forms_paginator: ListEvaluationFormsPaginator = client.get_paginator(
      "list_evaluation_forms"
  )
  list_flow_associations_paginator: ListFlowAssociationsPaginator = client.get_paginator(
      "list_flow_associations"
  )
  list_hours_of_operation_overrides_paginator: ListHoursOfOperationOverridesPaginator = (
      client.get_paginator("list_hours_of_operation_overrides")
  )
  list_hours_of_operations_paginator: ListHoursOfOperationsPaginator = client.get_paginator(
      "list_hours_of_operations"
  )
  list_instance_attributes_paginator: ListInstanceAttributesPaginator = client.get_paginator(
      "list_instance_attributes"
  )
  list_instance_storage_configs_paginator: ListInstanceStorageConfigsPaginator = client.get_paginator(
      "list_instance_storage_configs"
  )
  list_instances_paginator: ListInstancesPaginator = client.get_paginator("list_instances")
  list_integration_associations_paginator: ListIntegrationAssociationsPaginator = (
      client.get_paginator("list_integration_associations")
  )
  list_lambda_functions_paginator: ListLambdaFunctionsPaginator = client.get_paginator(
      "list_lambda_functions"
  )
  list_lex_bots_paginator: ListLexBotsPaginator = client.get_paginator("list_lex_bots")
  list_phone_numbers_paginator: ListPhoneNumbersPaginator = client.get_paginator("list_phone_numbers")
  list_phone_numbers_v2_paginator: ListPhoneNumbersV2Paginator = client.get_paginator(
      "list_phone_numbers_v2"
  )
  list_predefined_attributes_paginator: ListPredefinedAttributesPaginator = client.get_paginator(
      "list_predefined_attributes"
  )
  list_prompts_paginator: ListPromptsPaginator = client.get_paginator("list_prompts")
  list_queue_quick_connects_paginator: ListQueueQuickConnectsPaginator = client.get_paginator(
      "list_queue_quick_connects"
  )
  list_queues_paginator: ListQueuesPaginator = client.get_paginator("list_queues")
  list_quick_connects_paginator: ListQuickConnectsPaginator = client.get_paginator(
      "list_quick_connects"
  )
  list_routing_profile_queues_paginator: ListRoutingProfileQueuesPaginator = client.get_paginator(
      "list_routing_profile_queues"
  )
  list_routing_profiles_paginator: ListRoutingProfilesPaginator = client.get_paginator(
      "list_routing_profiles"
  )
  list_rules_paginator: ListRulesPaginator = client.get_paginator("list_rules")
  list_security_keys_paginator: ListSecurityKeysPaginator = client.get_paginator("list_security_keys")
  list_security_profile_applications_paginator: ListSecurityProfileApplicationsPaginator = (
      client.get_paginator("list_security_profile_applications")
  )
  list_security_profile_permissions_paginator: ListSecurityProfilePermissionsPaginator = (
      client.get_paginator("list_security_profile_permissions")
  )
  list_security_profiles_paginator: ListSecurityProfilesPaginator = client.get_paginator(
      "list_security_profiles"
  )
  list_task_templates_paginator: ListTaskTemplatesPaginator = client.get_paginator(
      "list_task_templates"
  )
  list_traffic_distribution_group_users_paginator: ListTrafficDistributionGroupUsersPaginator = (
      client.get_paginator("list_traffic_distribution_group_users")
  )
  list_traffic_distribution_groups_paginator: ListTrafficDistributionGroupsPaginator = (
      client.get_paginator("list_traffic_distribution_groups")
  )
  list_use_cases_paginator: ListUseCasesPaginator = client.get_paginator("list_use_cases")
  list_user_hierarchy_groups_paginator: ListUserHierarchyGroupsPaginator = client.get_paginator(
      "list_user_hierarchy_groups"
  )
  list_user_proficiencies_paginator: ListUserProficienciesPaginator = client.get_paginator(
      "list_user_proficiencies"
  )
  list_users_paginator: ListUsersPaginator = client.get_paginator("list_users")
  list_view_versions_paginator: ListViewVersionsPaginator = client.get_paginator("list_view_versions")
  list_views_paginator: ListViewsPaginator = client.get_paginator("list_views")
  search_agent_statuses_paginator: SearchAgentStatusesPaginator = client.get_paginator(
      "search_agent_statuses"
  )
  search_available_phone_numbers_paginator: SearchAvailablePhoneNumbersPaginator = (
      client.get_paginator("search_available_phone_numbers")
  )
  search_contact_flow_modules_paginator: SearchContactFlowModulesPaginator = client.get_paginator(
      "search_contact_flow_modules"
  )
  search_contact_flows_paginator: SearchContactFlowsPaginator = client.get_paginator(
      "search_contact_flows"
  )
  search_contacts_paginator: SearchContactsPaginator = client.get_paginator("search_contacts")
  search_hours_of_operation_overrides_paginator: SearchHoursOfOperationOverridesPaginator = (
      client.get_paginator("search_hours_of_operation_overrides")
  )
  search_hours_of_operations_paginator: SearchHoursOfOperationsPaginator = client.get_paginator(
      "search_hours_of_operations"
  )
  search_predefined_attributes_paginator: SearchPredefinedAttributesPaginator = client.get_paginator(
      "search_predefined_attributes"
  )
  search_prompts_paginator: SearchPromptsPaginator = client.get_paginator("search_prompts")
  search_queues_paginator: SearchQueuesPaginator = client.get_paginator("search_queues")
  search_quick_connects_paginator: SearchQuickConnectsPaginator = client.get_paginator(
      "search_quick_connects"
  )
  search_resource_tags_paginator: SearchResourceTagsPaginator = client.get_paginator(
      "search_resource_tags"
  )
  search_routing_profiles_paginator: SearchRoutingProfilesPaginator = client.get_paginator(
      "search_routing_profiles"
  )
  search_security_profiles_paginator: SearchSecurityProfilesPaginator = client.get_paginator(
      "search_security_profiles"
  )
  search_user_hierarchy_groups_paginator: SearchUserHierarchyGroupsPaginator = client.get_paginator(
      "search_user_hierarchy_groups"
  )
  search_users_paginator: SearchUsersPaginator = client.get_paginator("search_users")
  search_vocabularies_paginator: SearchVocabulariesPaginator = client.get_paginator(
      "search_vocabularies"
  )
  ```

  <a id="literals"></a>



  `mypy_boto3_connect.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `Connect` Literals can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connect/literals/).

  ```python
  from mypy_boto3_connect.literals import ActionTypeType


  def check_value(value: ActionTypeType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `mypy_boto3_connect.type_defs` module contains structures and shapes assembled
  to typed dictionaries and unions for additional type checking.

  Full list of `Connect` TypeDefs can be found in
  [docs](https://youtype.github.io/boto3_stubs_docs/mypy_boto3_connect/type_defs/).

  ```python
  from mypy_boto3_connect.type_defs import ActionSummaryTypeDef


  def get_value() -> ActionSummaryTypeDef:
      return {...}
  ```

  <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>



  `mypy-boto3-connect` 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/mypy_boto3_connect/)

  <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.


