# packages

pkgId: 3b22ff8b6aefbde0d23eb6c68bd24ecbade771e0f3633140fb16f2d543288cb9
name: python-prokabaddiAPI-help
arch: noarch
version: 0.0.21
epoch: 0
release: 1
summary: Development documents and examples for prokabaddiAPI
url: https://pypi.org/project/prokabaddiAPI/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prokabaddiAPI-0.0.21-1.src.rpm
location_href: Packages/python-prokabaddiAPI-help-0.0.21-1.noarch.rpm
checksum_type: sha256
description:
  This is a powerful tool designed to extract comprehensive data about players and teams from the official Pro prokabaddiAPI website. This library is engineered to provide detailed insights into prokabaddiAPI, including player statistics, team performance metrics, and match results. It offers a streamlined and efficient way to gather and analyze prokabaddiAPI data, which is crucial for sports analytics and machine learning applications.



  The data is scraped using selenium from - https://www.prokabaddi.com/







  1. Data Collection and Aggregation: The library automates the process of gathering detailed information from the Pro prokabaddiAPI website. This includes player profiles, team statistics, match summaries, and historical data. By centralizing this information, users can access a wealth of data with minimal effort.



  2. Machine Learning: The library facilitates the development of predictive models and algorithms by providing a rich dataset for training. Machine learning practitioners can use the data to build models that predict match outcomes, player performance, and team success rates. This can lead to the creation of advanced analytics tools that offer insights into game strategies and player efficiency.



  3. Data Science: For data scientists, this library is a valuable resource for exploratory data analysis (EDA) and statistical analysis. It enables the extraction of data for visualizations, trend analysis, and performance metrics, which can be used to derive actionable insights and identify patterns in prokabaddiAPI matches and player performance.



  4. Sports Analytics: Analysts can leverage the scraped data to perform in-depth evaluations of team and player performance. This includes analyzing player form, team dynamics, and historical performance trends. The library supports the development of dashboards and reports that assist coaches, team managers, and fans in understanding the nuances of the game.







  prokabaddiAPI, traditionally popular in South Asia, is experiencing significant growth and evolving as a global sport. The Pro prokabaddiAPI League (PKL) has played a pivotal role in popularizing the sport by introducing a professional format and attracting international audiences. As prokabaddiAPI evolves, the need for data-driven insights becomes more critical.



  The prokabaddiAPI Data Scraper library contributes to this evolution by:



  - Enhancing Competitiveness: By providing detailed player and team data, the library helps teams and coaches refine their strategies and improve performance. In a sport where strategic decisions are crucial, access to precise and comprehensive data can provide a competitive edge.



  - Promoting Fan Engagement: Fans are increasingly interested in detailed statistics and analytics. This library allows for the creation of engaging content, such as performance summaries and detailed reports, which can enhance the viewing experience and attract new fans.



  - Supporting Research and Development: Researchers studying sports analytics and the impact of various factors on performance can use the data provided by the library to conduct studies and publish findings. This contributes to the academic and practical understanding of prokabaddiAPI.



  Overall, the prokabaddiAPI Data Scraper Python library is a valuable asset for anyone involved in the prokabaddiAPI ecosystem, from sports analysts and data scientists to coaches and fans. By facilitating detailed data collection and analysis, it supports the ongoing evolution of prokabaddiAPI and its integration into the broader sports analytics landscape.





  Your system should have firebox browser









  ```

  pip install prokabaddiAPI

  ```











  ```

  import prokabaddiAPI

  prokabaddiAPI.get_all_team_url()

  ```



  Output format



  ```

  [

      {'TeamName': 'Bengaluru Bulls', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/bengaluru-bulls-profile-1'},

      {'TeamName': 'Bengal Warriors', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/bengal-warriors-profile-4'},

      {'TeamName': 'Dabang Delhi Kc', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/dabang-delhi-kc-profile-2'},

      {'TeamName': 'Haryana Steelers', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/haryana-steelers-profile-28'},

      {'TeamName': 'Jaipur Pink Panthers', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/jaipur-pink-panthers-profile-3'},

      {'TeamName': 'Patna Pirates', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/patna-pirates-profile-6

      {'TeamName': 'Puneri Paltan', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/puneri-paltan-profile-7'},

      {'TeamName': 'Tamil Thalaivas', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/tamil-thalaivas-profile-29'},

      {'TeamName': 'Telugu Titans', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/telugu-titans-profile-8'},

      {'TeamName': 'U Mumba', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/u-mumba-profile-5'},

      {'TeamName': 'Up Yoddha', 'TeamURL': 'https://www.proprokabaddiAPI.com/teams/up-yoddha-profile-30'}

  ]

  ```







  ```

  import prokabaddiAPI

  prokabaddiAPI.get_all_player_url()

  ```



  Output format



  ```

  [

      {

          'name': 'Samuel  Wafula',

          'category': 'All-Rounder',

          'profileURL': 'https://www.proprokabaddiAPI.com/players/samuel-wafula-profile-4926'

      },

      {

          'name': 'Nitin  Panwar',

          'category': 'All-Rounder',

          'profileURL': 'https://www.proprokabaddiAPI.com/players/nitin-panwar-profile-3039'

      }

      ....

  ]

  ```







  ```

  import prokabaddiAPI

  prokabaddiAPI.get_team_stats_from_url("https://www.proprokabaddiAPI.com/teams/bengaluru-bulls-profile-1")

  ```



  Output format



  ```



  [

      [

          {'season': 'Season 10'},

          {'Matches Played': '21'},

          {'Total Raids': '912'},

          {'Total Tackles': '491'},

          {'Wins': '7'},

          {'Draws': '2'},

          {'Losses': '12'},

          {'Successful Raids': '287'},

          {'Unsuccessful Raids': '250'},

          {'Empty Raids': '375'},

          {'Successful Tackles': '211'},

          {'Unsuccessful Tackles': '280'},

          {'players':

              [

                  {

                      'name': 'Vikash  Kandola',

                      'category': 'Raider',

                      'profileURL': 'https://www.proprokabaddiAPI.com/players/vikash-kandola-profile-366'

                  },

                  {

                      'name': 'Monu',

                      'category': 'Raider',

                      'profileURL': 'https://www.proprokabaddiAPI.com/players/monu-profile-3082'

                  },

                  .....

              ],

          }

      ],

      .....

  ]

  ```







  ```

  import prokabaddiAPI

  prokabaddiAPI.get_player_stats_from_url("https://www.proprokabaddiAPI.com/players/maninder-singh-profile-143")

  ```



  Output format



  ```

  [

      {

          'teamName': 'Bengal Warriors'

      },

      [

          {

              'season': 'Season 10'

          },

          {

              'Matches Played': '21'

          },

          {

              'Total Points Earned': '198'

          },

          {

              'Raid Points Per Match': '9.38'

          },

          {

              'Total Raids': '322'

          },

          {

              'No. Of Super Raids': '5'

          },

          {

              'Super 10s': '9'

          },

          {

              'Total Raids Points': '197'

          },

          {

              'Average Raid Points/Match': '9.38'

          },

          {

              'No. Of Super Tackles': '0'

          },

          {

              'High 5s': '0'

          },

          {

              'Total Tackle Points': '1'

          },

          {

              'Average Successful Tackles/Match': '0.05'

          },

          {

              'Total Tackles': '9'

          },

          {

              'Not out %': '74.22%'

          },

          {

              'Successful Raids %': '48%'

          },

          {

              'Tackle Success Rate %': '11%'

          }

      ],

      ....

  ]

  ```











  *   [@abhineetraj1](https://github.com/abhineetraj1)


pkgId: 0f16d379eb9e684799c2ad8fc56f5ef75103537eaa579f793de0ea510d44c2ca
name: python-prometheus-aioexporter-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for prometheus-aioexporter
url: https://pypi.org/project/prometheus-aioexporter/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prometheus-aioexporter-3.0.0-1.src.rpm
location_href: Packages/python-prometheus-aioexporter-help-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  |Latest Version| |Build Status|
  ``prometheus-aioexporter`` is an aysncio-based library to simplify writing
  Prometheus_ exporters in Python.
  Exporters are usually implemented as small daemons that expose metrics
  in text format through a web endpoint (usually ``/metrics``).

rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.   This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.  0. Additional Definitions.  As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License.  "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.  An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.  A "Combined Work" is a work produced by combining or linking an Application with the Library.  The particular version of the Library with which the Combined Work was made is also called the "Linked Version".  The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.  The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.  1. Exception to Section 3 of the GNU GPL.  You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.  2. Conveying Modified Versions.  If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:  a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or  b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.  3. Object Code Incorporating Material from Library Header Files.  The object code form of an Application may incorporate material from a header file that is part of the Library.  You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:  a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.  b) Accompany the object code with a copy of the GNU GPL and this license document.  4. Combined Works.  You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:  a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.  b) Accompany the Combined Work with a copy of the GNU GPL and this license document.  c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.  d) Do one of the following:  0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.  1) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.  e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)  5. Combined Libraries.  You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.  b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  6. Revised Versions of the GNU Lesser General Public License.  The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.  If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.


pkgId: 4fdfce19677f91a7aeacee3c74f47f301410953e4d58ae1d6022eefb3a539617
name: python-prometheus-pve-exporter-help
arch: noarch
version: 3.4.7
epoch: 0
release: 1
summary: Development documents and examples for prometheus-pve-exporter
url: https://github.com/prometheus-pve/prometheus-pve-exporter
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prometheus-pve-exporter-3.4.7-1.src.rpm
location_href: Packages/python-prometheus-pve-exporter-help-3.4.7-1.noarch.rpm
checksum_type: sha256
description:
  |Build Status| |Package Version|
  This is an exporter that exposes information gathered from Proxmox VE
  node for use by the Prometheus monitoring system.


pkgId: e2e4c383e9bb68639630483195b654b3b5953aec22c453638e254441229399a2
name: python-prometheus-pve-sd-help
arch: noarch
version: 4.0.2
epoch: 0
release: 1
summary: Development documents and examples for prometheus-pve-sd
url: https://github.com/thegeeklab/prometheus-pve-sd/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prometheus-pve-sd-4.0.2-1.src.rpm
location_href: Packages/python-prometheus-pve-sd-help-4.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Prometheus Service Discovery for Proxmox VE

  [![Build Status](https://ci.thegeeklab.de/api/badges/thegeeklab/prometheus-pve-sd/status.svg)](https://ci.thegeeklab.de/repos/thegeeklab/prometheus-pve-sd)
  [![Docker Hub](https://img.shields.io/badge/dockerhub-latest-blue.svg?logo=docker&logoColor=white)](https://hub.docker.com/r/thegeeklab/prometheus-pve-sd)
  [![Quay.io](https://img.shields.io/badge/quay-latest-blue.svg?logo=docker&logoColor=white)](https://quay.io/repository/thegeeklab/prometheus-pve-sd)
  [![Python Version](https://img.shields.io/pypi/pyversions/prometheus-pve-sd.svg)](https://pypi.org/project/prometheus-pve-sd/)
  [![PyPI Status](https://img.shields.io/pypi/status/prometheus-pve-sd.svg)](https://pypi.org/project/prometheus-pve-sd/)
  [![PyPI Release](https://img.shields.io/pypi/v/prometheus-pve-sd.svg)](https://pypi.org/project/prometheus-pve-sd/)
  [![GitHub contributors](https://img.shields.io/github/contributors/thegeeklab/prometheus-pve-sd)](https://github.com/thegeeklab/prometheus-pve-sd/graphs/contributors)
  [![Source: GitHub](https://img.shields.io/badge/source-github-blue.svg?logo=github&logoColor=white)](https://github.com/thegeeklab/prometheus-pve-sd)
  [![License: MIT](https://img.shields.io/github/license/thegeeklab/prometheus-pve-sd)](https://github.com/thegeeklab/prometheus-pve-sd/blob/main/LICENSE)

  This project provides a simple custom service discovery for [Prometheus](https://prometheus.io/). It is using the [Proxmox VE](https://www.proxmox.com/de/proxmox-ve) (PVE) API to fetch Hosts and it's meta information to generate a Prometheus compatible [file based](https://prometheus.io/docs/guides/file-sd/) service discovery. Releases are available as Python Packages on [GitHub](https://github.com/thegeeklab/prometheus-pve-sd/releases) or [PyPI](https://pypi.org/project/prometheus-pve-sd/) and as Docker Image on [Docker Hub](https://hub.docker.com/r/thegeeklab/prometheus-pve-sd).

  You can find the full documentation at [https://prometheus-pve-sd.geekdocs.de](https://prometheus-pve-sd.geekdocs.de).



  Special thanks to all [contributors](https://github.com/thegeeklab/prometheus-pve-sd/graphs/contributors). If you would like to contribute,
  please see the [instructions](https://github.com/thegeeklab/prometheus-pve-sd/blob/main/CONTRIBUTING.md).



  This project is licensed under the MIT License - see the [LICENSE](https://github.com/thegeeklab/prometheus-pve-sd/blob/main/LICENSE) file for details.


pkgId: ac921235e9799158a19ff17eb033c5340c592732662ad642263add23857c1c8f
name: python-prominence-help
arch: noarch
version: 0.21.0
epoch: 0
release: 1
summary: Development documents and examples for prominence
url: https://prominence-eosc.github.io/docs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prominence-0.21.0-1.src.rpm
location_href: Packages/python-prominence-help-0.21.0-1.noarch.rpm
checksum_type: sha256
description:
  ![License](https://img.shields.io/github/license/prominence-eosc/cli)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/prominence.svg)](https://pypi.python.org/pypi/ansicolortags/)

  The PROMINENCE CLI presents a simple batch-system style interface to PROMINENCE. Written in Python, it can be installed easily on any system using pip:
  ```
  pip install prominence
  ```
  To upgrade the CLI the `--upgrade` option needs to be added:
  ```
  pip install --upgrade prominence
  ```

  See https://prominence-eosc.github.io/docs/ for more information.


pkgId: 4d590fd5f40cd39f0f4b98078d6de1bc3ac288d9c379b611d571bee286783901
name: python-prommis-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for prommis
url: https://pypi.org/project/prommis/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prommis-0.5.0-1.src.rpm
location_href: Packages/python-prommis-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  Process Optimization and Modeling for Minerals Sustainability



  Unless otherwise noted, these commands assume that the working directory is the root of the local clone of this repository (i.e. the directory containing this README file).



  ```sh
  conda create --name prommis-dev --yes python=3.11
  conda activate prommis-dev
  git clone https://github.com/prommis/prommis && cd prommis
  pip install -r requirements-dev.txt
  ```



  Before running any of these commands, ensure the `prommis-dev` Conda environment has been activated:

  ```sh
  conda activate prommis-dev
  ```



  ```sh
  isort src/prommis
  ```



  ```sh
  black .
  ```



  ```sh
  pylint prommis
  ```



  ```sh
  typos
  ```

  Note: if the `typos` executable is not found, it can be installed by running `conda install --yes -c conda-forge typos` after activating the `prommis-dev` Conda environment.



  ```sh
  pytest                          # run the complete test suite
  pytest -k test_my_flowsheet.py  # run only test defined in the file named test_my_flowsheet.py
  ```



  From the `docs/` subdirectory:

  ```sh
  jupyter-book build .
  ```



  From the `docs/` subdirectory:

  ```sh
  pytest --nbmake -m "solution" .
  ```


pkgId: 0dd57c10a7b2e22a4130cf66f2f7d606f446b7dbed088ced9e1bc32b78d0b5d3
name: python-prompt-declaration-language-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for prompt-declaration-language
url: https://ibm.github.io/prompt-declaration-language/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prompt-declaration-language-0.1.1-1.src.rpm
location_href: Packages/python-prompt-declaration-language-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/IBM/prompt-declaration-language/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/IBM/prompt-declaration-language/actions?query=workflow%3Abuild+branch%3Amain)
  [![night tests](https://github.com/IBM/prompt-declaration-language/actions/workflows/run-examples.yml/badge.svg?branch=main)](https://github.com/IBM/prompt-declaration-language/actions?query=workflow%3Arun-examples+branch%3Amain)
  [![documentation](https://github.com/IBM/prompt-declaration-language/actions/workflows/mkdocs-gh-pages.yml/badge.svg?branch=main)](https://github.com/IBM/prompt-declaration-language/actions?query=workflow%3Amkdocs-gh-pages+branch%3Amain)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/prompt-declaration-language?color=success)](https://pypi.python.org/pypi/prompt-declaration-language/)
  [![Quay Publish](https://github.com/IBM/prompt-declaration-language/actions/workflows/publish-quay.yaml/badge.svg)](https://github.com/IBM/prompt-declaration-language/actions/workflows/publish-quay.yaml)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/PyCQA/pylint)
  [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/9672/badge)](https://bestpractices.coreinfrastructure.org/projects/9672)



  PDL is a declarative language designed for developers to create reliable, composable LLM prompts and integrate them into software systems. It provides a structured way to specify prompt templates, enforce validation, and compose LLM calls with traditional rule-based systems.

  <img src="docs/assets/animated_chatbot.gif" width=750px alt="Animated GIF of PDL chatbot."/>



  Minimum installation.

  ```bash
  pip install prompt-declaration-language
  ```
  See [here](https://ibm.github.io/prompt-declaration-language/tutorial/#using-ollama-models) for
  instructions on how to install an Ollama model locally.

  You can create a PDL file (YAML format):

  ```yaml
  description: Simple LLM interaction
  text:
  - "write a hello world example\n"
  - model: ollama/granite-code:8b
    parameters:
      stop_sequences: '!'
      temperature: 0
  ```

  and run it:

  ```bash
  pdl <path/to/example.pdl>
  ```



  - **LLM Integration**: Compatible with any LLM, including IBM watsonx
  - **Prompt Engineering**:
    - Template system for single/multi-shot prompting
    - Composition of multiple LLM calls
    - Integration with tools (code execution & APIs)
  - **Development Tools**:
    - Type checking for model I/O
    - Python SDK
    - Chat API support
    - Live document visualization for debugging
  - **Control Flow**: Variables, conditionals, loops, and functions
  - **I/O Operations**: File/stdin reading, JSON parsing
  - **API Integration**: Native REST API support (Python)



  - [Documenation](https://ibm.github.io/prompt-declaration-language/)
  - [API References](https://ibm.github.io/prompt-declaration-language/api_reference/)
  - [Tutorial](https://ibm.github.io/prompt-declaration-language/tutorial/)



  <img src="docs/assets/pdl_quick_reference.png" alt="PDL Quick Reference"/>






  Requires Python 3.11+ (Windows users should use WSL)

  ```bash

  pip install prompt-declaration-language


  pip install 'prompt-declaration-language[examples]'
  ```



  You can run PDL with LLM models in local using [Ollama](https://ollama.com), or other cloud service.

  If you use WatsonX:
  ```bash
  export WATSONX_URL="https://{region}.ml.cloud.ibm.com"
  export WATSONX_APIKEY="your-api-key"
  export WATSONX_PROJECT_ID="your-project-id"
  ```

  If you use [Replicate](https://replicate.com/):
  ```bash
  export REPLICATE_API_TOKEN="your-token"
  ```



  VSCode setup for syntax highlighting and validation:

  ```json
  // .vscode/settings.json
  {
      "yaml.schemas": {
          "https://ibm.github.io/prompt-declaration-language/dist/pdl-schema.json": "*.pdl"
      },
      "files.associations": {
          "*.pdl": "yaml",
      }
  }
  ```





  In this example we use external content _data.yaml_ and watsonx as an LLM provider.

  ```yaml
  description: Template with variables
  defs:
    USER_INPUT:
      read: ../examples/code/data.yaml
      parser: yaml
  text:
  - model: watsonx/ibm/granite-34b-code-instruct
    input: |
      Process this input: ${USER_INPUT}
      Format the output as JSON.
  ```



  ```yaml
  description: Code execution example
  text:
  - "\nFind a random number between 1 and 20\n"
  - def: N
    lang: python
    code: |
      import random
      result = random.randint(1, 20)
  - "\nthe result is (${ N })\n"
  ```



  chat interactions:

  ```yaml
  description: chatbot
  text:
  - read:
    def: user_input
    message: "hi? [/bye to exit]\n"
    contribute: [context]
  - repeat:
      text:
      - model: ollama/granite-code:8b
      - read:
        def: user_input
        message: "> "
        contribute: [context]
    until: ${ user_input == '/bye'}
  ```




  ```bash
  pdl --log <my-logfile> <my-example.pdl>
  ```



  ```bash
  pdl --trace <file.json> <my-example.pdl>
  ```

  Upload trace files to the [Live Document Viewer](https://ibm.github.io/prompt-declaration-language/viewer/) for visual debugging.




  See the [contribution guidelines](https://ibm.github.io/prompt-declaration-language/contrib) for details on:
  - Code style
  - Testing requirements
  - PR process
  - Issue reporting



  - [PDL Schema](https://github.com/IBM/prompt-declaration-language/blob/main/src/pdl/pdl-schema.json)
  - [arXiv Paper](http://arxiv.org/abs/2410.19135)


pkgId: d72d8d388a40af54d7108b4381a7a9a19ad0b40ff5ae7de852f22edb2ebff935
name: python-prompt-llm-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for prompt-llm
url: https://github.com/reego-software/prompt_llm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prompt-llm-0.1.4-1.src.rpm
location_href: Packages/python-prompt-llm-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  0.1.4

  - Prompt LLMs via cli



  1. Clone the repo

  2. Install
  - Local:
      - `pip install --editable .`
  - PyPi:
      - `pip install prompt_llm`

  3. Install auto-completion:
  - `prompt_llm --install-completion`
  - `source ~/.bashrc`


  - Supported configs: `--api-key`, `--model`, `--system`, `--temperature`


  - `prompt_llm config_add  --api-key "<api_key>" --system "<system_messgae>" --temperature <temperature>`


  - `prompt_llm config_save_to --profile="openai"`


  - `prompt_llm config_load_from --profile="openai"`


  - `prompt_llm config-rm temperature`


  - `prompt_llm config-ls`
  - `prompt_llm config-ls --profile="openai"`


  - `prompt_llm openai "Tell me something"`





  `python -m build`


  `python3 -m twine upload --repository pypi dist/* --verbose`


pkgId: e04a67e65bd180c79e7f8ee62c9dcda9e5bb893259e97d9927ecbe0901f01360
name: python-prompt-templates-help
arch: noarch
version: 0.0.11
epoch: 0
release: 1
summary: Development documents and examples for prompt-templates
url: https://github.com/MoritzLaurer/prompt_templates
rpm_license: Appache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prompt-templates-0.0.11-1.src.rpm
location_href: Packages/python-prompt-templates-help-0.0.11-1.noarch.rpm
checksum_type: sha256
description:
  Prompt templates have become key artifacts for researchers and practitioners working with AI. There is, however, no standardized way of sharing prompt templates. Prompts and prompt templates are shared on the Hugging Face Hub in [.txt files](https://huggingface.co/HuggingFaceFW/fineweb-edu-classifier/blob/main/utils/prompt.txt), in [HF datasets](https://huggingface.co/datasets/fka/awesome-chatgpt-prompts), as strings in [model cards](https://huggingface.co/OpenGVLab/InternVL2-8B#grounding-benchmarks), or on GitHub as [python strings](https://github.com/huggingface/cosmopedia/tree/main/prompts) embedded in scripts, in [JSON and YAML](https://github.com/hwchase17/langchain-hub/blob/master/prompts/README.md) files, or in [Jinja2](https://github.com/argilla-io/distilabel/tree/main/src/distilabel/steps/tasks/templates) files.





  - Provide functionality for working with prompt templates locally and sharing them on the Hugging Face Hub.
  - Propose a prompt template standard through .yaml and .json files that enables modular development of complex LLM systems and is interoperable with other libraries

  - Compete with full-featured prompting libraries like [LangChain](https://github.com/langchain-ai/langchain), [ell](https://docs.ell.so/reference/index.html), etc. The objective is, instead, a simple solution for working with prompt templates locally or on the HF Hub, which is interoperable with other libraries and which the community can build upon.




  A discussion of the standard prompt format, usage examples, the API reference etc. are available in the [docs](https://moritzlaurer.github.io/prompt_templates/).




  Let's use this [closed_system_prompts repo](https://huggingface.co/MoritzLaurer/closed_system_prompts) of official prompts from OpenAI and Anthropic. These prompt templates have either been leaked or were shared by these LLM providers, but were originally in a non-machine-readable, non-standardized format.




  ```bash
  pip install prompt-templates
  ```




  ```python
  from prompt_templates import list_prompt_templates
  files = list_prompt_templates("MoritzLaurer/closed_system_prompts")
  print(files)

  ```



  ```python
  from prompt_templates import PromptTemplateLoader
  prompt_template = PromptTemplateLoader.from_hub(
      repo_id="MoritzLaurer/closed_system_prompts",
      filename="claude-3-5-artifacts-leak-210624.yaml"
  )

  print(prompt_template.template)




  print(prompt_template.template_variables)

  print(prompt_template.metadata)

  ```



  By default, the populated prompt is returned in the OpenAI messages format, which is compatible with most open-source LLM clients.

  ```python
  messages = prompt_template.populate_template(
      user_message="Create a tic-tac-toe game for me in Python",
      current_date="Wednesday, 11 December 2024"
  )
  print(messages)

  ```



  ```python
  from openai import OpenAI
  import os
  client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
  response = client.chat.completions.create(
      model="gpt-4o-mini",
      messages=messages
  )
  print(response.choices[0].message.content[:100], "...")

  ```

  ```python
  from huggingface_hub import InferenceClient
  client = InferenceClient(api_key=os.environ.get("HF_TOKEN"))
  response = client.chat.completions.create(
      model="meta-llama/Llama-3.3-70B-Instruct",
      messages=messages.to_dict(),
      max_tokens=500
  )
  print(response.choices[0].message.content[:100], "...")

  ```

  If you use an LLM client that expects a format different to the OpenAI messages standard, you can easily reformat the prompt for this client.

  ```python
  from anthropic import Anthropic

  messages_anthropic = messages.format_for_client(client="anthropic")

  client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
  response = client.messages.create(
      model="claude-3-sonnet-20240229",
      system=messages_anthropic["system"],
      messages=messages_anthropic["messages"],
      max_tokens=1000
  )
  print(response.content[0].text[:100], "...")

  ```




  ```python
  from prompt_templates import ChatPromptTemplate
  messages_template = [
      {"role": "system", "content": "You are a coding assistant who explains concepts clearly and provides short examples."},
      {"role": "user", "content": "Explain what {{concept}} is in {{programming_language}}."}
  ]
  template_variables = ["concept", "programming_language"]
  metadata = {
      "name": "Code Teacher",
      "description": "A simple chat prompt for explaining programming concepts with examples",
      "tags": ["programming", "education"],
      "version": "0.0.1",
      "author": "Guido van Bossum"
  }
  prompt_template = ChatPromptTemplate(
      template=messages_template,
      template_variables=template_variables,
      metadata=metadata,
  )

  print(prompt_template)

  ```


  You can then store your prompt template locally or share it on the HF Hub.

  ```python

  prompt_template.save_to_local("./tests/test_data/code_teacher_test.yaml")

  prompt_template.save_to_hub(repo_id="MoritzLaurer/example_prompts_test", filename="code_teacher_test.yaml", create_repo=True)

  ```



  - [ ] many things ...


pkgId: 89ea5dcf4c732d574e3d936d81cfd461d04a057f9547764917e1c810b70e0ac2
name: python-prompt_collapse-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for prompt_collapse
url: https://github.com/kraglik/prompt_collapse
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prompt_collapse-0.1.1-1.src.rpm
location_href: Packages/python-prompt_collapse-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A prompt generation system that manages relationships between prompt components to maintain logical consistency. Integrates with ComfyUI as a custom node.



  PromptCollapse builds prompts by selecting components based on their inferred relationships.
  Each component has its own set of parameters that are only valid within the component execution context.
  Component might be purely abstract, meaning that it won't produce any prompt fragments at all, but would coordinate other components instead.



  A minimalistic example can be found in "components/sky.yaml".



  The system provides a custom node with the following inputs:

  - **Prompt**: Initial component tags (comma-separated)
  - **Components Directory Path**: Component library directory
  - **Reload on Generation**: Toggle component reloading
  - **Seed**: Random seed for component selection


pkgId: 4facd4c19b2ea336c87eaa4fb83052590aa581f7ec68134f39cd6374294ae237
name: python-prompter-r3ap3rpy-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for prompter-r3ap3rpy
url: https://pypi.org/project/prompter-r3ap3rpy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prompter-r3ap3rpy-0.0.4-1.src.rpm
location_href: Packages/python-prompter-r3ap3rpy-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  This is a small module that can be used to generate prompts for text-to-image generative AI.

  The package is available on [pypi](https://pypi.org/project/prompter-r3ap3rpy).

  In order to install the package you would use the following command.

  ``` bash
  pip install propmpter-r3ap3rpy
  ```

  Then all you have to do is import the module and use it as follows.

  ``` python
  from prompter import PromptGenerator
  p = PromptGenerator()
  p()
  'Madonna grilling at Jerusalem.'
  p()
  'Natalie Portman cycling at Mumbai.'
  p()
  'John von Neumann baseball at Tower of London.'
  ```

  You have the option to update the **data.json**.

  ``` python
  from prompter import PromptGenerator
  p = PromptGenerator()
  p.update("People","Dani Ernő")
  ```

  When updating the data the section is converted to lower-case and verified, also the value is checked whether it's in the section converted to lower-case before checking, if not it's added, otherwise an exception is thrown.

  You can also delete from the **data.json** entries. By default it will delete first occurence from each section, but you can pass the **all_occurence=True** to remove all occurences.

  ``` python
  from prompter import PromptGenerator
  p = PromptGenerator()
  p.delete("Dani Ernő") # deletes value from every sections
  p.delete("people","Pablo Picasso") # deletes value from given section
  ```

  You have the option to get basic stats from your database.

  ``` python
  from prompter import PromptGenerator
  p = PromptGenerator()
  p.stats





  ```

  The **details** attribute will print the content in a table format to your terminal.

  You have **restore_db()** which is a static method, it allows you to restore any backups in the **data** folder, the **backup_db()** which is an instance method allows you to backup the actual state of the database to a default or custom filename!

  In order to run the tests you can do the following.

  ``` bash
  git clone https://github.com/r3ap3rpy/prompter
  cd prompter
  pip install -r requirements.txt
  pytest -vvvvv
  ```


pkgId: 9ced4da9c10e91bd26311c1bf512fdfa68512bd877b03405b2a30ed3a4c69c31
name: python-promptic-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for promptic
url: https://pypi.org/project/promptic/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-promptic-2.2.0-1.src.rpm
location_href: Packages/python-promptic-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Python Versions](https://img.shields.io/pypi/pyversions/promptic)](https://pypi.org/project/promptic)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Tests](https://github.com/knowsuchagency/promptic/actions/workflows/tests.yml/badge.svg)](https://github.com/knowsuchagency/promptic/actions/workflows/tests.yml)



  Promptic aims to be the "[requests](https://requests.readthedocs.io/en/latest/)" of LLM development -- the most productive and pythonic way to build LLM applications. It leverages [LiteLLM][litellm], so you're never locked in to an LLM provider and can switch to the latest and greatest with a single line of code. Promptic gets out of your way so you can focus entirely on building features.

  > “Perfection is attained, not when there is nothing more to add, but when there is nothing more to take away.”



  - 🎯 Type-safe structured outputs with Pydantic
  - 🤖 Easy-to-build agents with function calling
  - 🔄 Streaming support for real-time responses
  - 💾 Built-in conversation memory
  - 🛠️ Error handling and retries
  - 🔌 Extensible state management



  ```bash
  pip install promptic
  ```





  Functions decorated with `@llm` use its docstring as a prompt template. When the function is called, promptic combines the docstring with the function's arguments to generate the prompt and returns the LLM's response.

  ```python
  from promptic import llm

  @llm
  def translate(text, language="Chinese"):
      """Translate '{text}' to {language}"""

  print(translate("Hello world!"))


  print(translate("Hello world!", language="Spanish"))


  @llm(
      model="claude-3-haiku-20240307",
      system="You are a customer service analyst. Provide clear sentiment analysis with key points."
  )
  def analyze_sentiment(text):
      """Analyze the sentiment of this customer feedback: {text}"""

  print(analyze_sentiment("The product was okay but shipping took forever"))




  ```



  You can use Pydantic models to ensure the LLM returns data in exactly the structure you expect. Simply define a Pydantic model and use it as the return type annotation on your decorated function. The LLM's response will be automatically validated against your model schema and returned as a Pydantic object.

  ```python
  from pydantic import BaseModel
  from promptic import llm

  class Forecast(BaseModel):
      location: str
      temperature: float
      units: str

  @llm
  def get_weather(location, units: str = "fahrenheit") -> Forecast:
      """What's the weather for {location} in {units}?"""

  print(get_weather("San Francisco", units="celsius"))

  ```

  Alternatively, you can use JSON Schema dictionaries for more low-level validation:

  ```python
  from promptic import llm

  schema = {
      "type": "object",
      "properties": {
          "name": {
              "type": "string",
              "pattern": "^[A-Z][a-z]+$",
              "minLength": 2,
              "maxLength": 20
          },
          "age": {
              "type": "integer",
              "minimum": 0,
              "maximum": 120
          },
          "email": {
              "type": "string",
              "format": "email"
          }
      },
      "required": ["name", "age"],
      "additionalProperties": False
  }

  @llm(json_schema=schema, system="You generate test data.")
  def get_user_info(name: str) -> dict:
      """Get information about {name}"""

  print(get_user_info("Alice"))

  ```



  Functions decorated with `@llm.tool` become tools that the LLM can invoke to perform actions or retrieve information. The LLM will automatically execute the appropriate tool calls, creating a seamless agent interaction.

  ```python
  from datetime import datetime

  from promptic import llm

  @llm(model="gpt-4o")
  def scheduler(command):
      """{command}"""

  @scheduler.tool
  def get_current_time():
      """Get the current time"""
      print("getting current time")
      return datetime.now().strftime("%I:%M %p")

  @scheduler.tool
  def add_reminder(task: str, time: str):
      """Add a reminder for a specific task and time"""
      print(f"adding reminder: {task} at {time}")
      return f"Reminder set: {task} at {time}"

  @scheduler.tool
  def check_calendar(date: str):
      """Check calendar for a specific date"""
      print(f"checking calendar for {date}")
      return f"Calendar checked for {date}: No conflicts found"

  cmd = """
  What time is it?
  Also, can you check my calendar for tomorrow
  and set a reminder for a team meeting at 2pm?
  """

  print(scheduler(cmd))




  ```



  The streaming feature allows real-time response generation, useful for long-form content or interactive applications:

  ```python
  from promptic import llm

  @llm(stream=True)
  def write_poem(topic):
      """Write a haiku about {topic}."""

  print("".join(write_poem("artificial intelligence")))



  ```



  Dry runs allow you to see which tools will be called and their arguments without invoking the decorated tool functions. You can also enable debug mode for more detailed logging.

  ```python
  from promptic import llm

  @llm(
      system="you are a posh smart home assistant named Jarvis",
      dry_run=True,
      debug=True,
  )
  def jarvis(command):
      """{command}"""

  @jarvis.tool
  def turn_light_on():
      """turn light on"""
      return True

  @jarvis.tool
  def get_current_weather(location: str, unit: str = "fahrenheit"):
      """Get the current weather in a given location"""
      return f"The weather in {location} is 45 degrees {unit}"

  print(jarvis("Please turn the light on and check the weather in San Francisco"))




  ```



  `promptic` pairs perfectly with [tenacity](https://github.com/jd/tenacity) for handling rate limits, temporary API failures, and more.

  ```python
  from tenacity import retry, wait_exponential, retry_if_exception_type
  from promptic import llm
  from litellm.exceptions import RateLimitError

  @retry(
      wait=wait_exponential(multiplier=1, min=4, max=10),
      retry=retry_if_exception_type(RateLimitError)
  )
  @llm
  def generate_summary(text):
      """Summarize this text in 2-3 sentences: {text}"""

  generate_summary("Long article text here...")
  ```



  By default, each function call is independent and stateless. Setting `memory=True` enables built-in conversation memory, allowing the LLM to maintain context across multiple interactions. Here's a practical example using Gradio to create a web-based chatbot interface:

  ```python
  import gradio as gr
  from promptic import llm

  @llm(memory=True, stream=True)
  def assistant(message):
      """{message}"""

  def predict(message, history):
      partial_message = ""
      for chunk in assistant(message):
          partial_message += str(chunk)
          yield partial_message

  with gr.ChatInterface(title="Promptic Chatbot Demo", fn=predict) as demo:
      
      demo.chatbot.clear(assistant.clear)

  demo.launch()
  ```

  For custom storage solutions, you can extend the `State` class to implement persistence in any database or storage system:

  ```python
  import json
  from promptic import State, llm

  class RedisState(State):
      def __init__(self, redis_client):
          super().__init__()
          self.redis = redis_client
          self.key = "chat_history"

      def add_message(self, message):
          self.redis.rpush(self.key, json.dumps(message))

      def get_messages(self, limit=None):
          messages = self.redis.lrange(self.key, 0, -1)
          return [json.loads(m) for m in messages][-limit:] if limit else messages

      def clear(self):
          self.redis.delete(self.key)


  @llm(state=RedisState(redis_client))
  def persistent_chat(message):
      """Chat: {message}"""
  ```



  Authentication can be handled in three ways:

  1. Directly via the `api_key` parameter:

  ```python
  from promptic import llm

  @llm(model="gpt-4o-mini", api_key="your-api-key-here")
  def my_function(text):
      """Process this text: {text}"""
  ```

  2. Through environment variables (recommended):

  ```bash

  export OPENAI_API_KEY=sk-...


  export ANTHROPIC_API_KEY=sk-ant-...


  export GEMINI_API_KEY=...


  export AZURE_API_KEY=...
  export AZURE_API_BASE=...
  export AZURE_API_VERSION=...
  ```

  3. By setting the API key programmatically via litellm:

  ```python
  from litellm import litellm

  litellm.api_key = "your-api-key-here"
  ```

  The supported environment variables correspond to the model provider:

  | Provider  | Environment Variable | Model Examples                                                            |
  | --------- | -------------------- | ------------------------------------------------------------------------- |
  | OpenAI    | `OPENAI_API_KEY`     | gpt-4o, gpt-3.5-turbo                                                     |
  | Anthropic | `ANTHROPIC_API_KEY`  | claude-3-haiku-20240307, claude-3-opus-20240229, claude-3-sonnet-20240229 |
  | Google    | `GEMINI_API_KEY`     | gemini/gemini-1.5-pro-latest                                              |





  The main decorator for creating LLM-powered functions. Can be used as `@llm` or `@llm()` with parameters.



  - `model` (str, optional): The LLM model to use. Defaults to "gpt-4o-mini".
  - `system` (str, optional): System prompt to set context for the LLM.
  - `dry_run` (bool, optional): If True, simulates tool calls without executing them. Defaults to False.
  - `debug` (bool, optional): If True, enables detailed logging. Defaults to False.
  - `memory` (bool, optional): If True, enables conversation memory using the default State implementation. Defaults to False.
  - `state` (State, optional): Custom State implementation for memory management. Overrides the `memory` parameter.
  - `json_schema` (dict, optional): JSON Schema dictionary for validating LLM outputs. Alternative to using Pydantic models.
  - `**litellm_kwargs`: Additional arguments passed directly to [litellm.completion](https://docs.litellm.ai/docs/completion/input).



  - `tool(fn)`: Decorator method to register a function as a tool that can be called by the LLM.
  - `clear()`: Clear all stored messages from memory. Raises ValueError if memory/state is not enabled.



  Base class for managing conversation memory and state. Can be extended to implement custom storage solutions.



  - `add_message(message: dict)`: Add a message to the conversation history.
  - `get_messages(prompt: str = None, limit: int = None) -> List[dict]`: Retrieve conversation history, optionally limited to the most recent messages and filtered by a prompt.
  - `clear()`: Clear all stored messages.



  ```python
  from pydantic import BaseModel
  from promptic import llm

  class Story(BaseModel):
      title: str
      content: str
      style: str
      word_count: int

  @llm(
      model="gpt-4o-mini",
      system="You are a creative writing assistant",
      memory=True,
      temperature=0.7,
      max_tokens=500,
  )
  def story_assistant(command: str) -> Story:
      """Process this writing request: {command}"""

  @story_assistant.tool
  def get_writing_style():
      """Get the current writing style preference"""
      return "whimsical and light-hearted"

  @story_assistant.tool
  def count_words(text: str) -> int:
      """Count words in the provided text"""
      return len(text.split())

  story = story_assistant("Write a short story about a magical library")
  print(f"Title: {story.title}")
  print(f"Style: {story.style}")
  print(f"Words: {story.word_count}")
  print(story.content)

  print(story_assistant("Write another story with the same style but about a time traveler"))
  ```



  `promptic` is a lightweight abstraction layer over [litellm][litellm] and its various LLM providers. As such, there are some provider-specific limitations that are beyond the scope of what the library addresses:

  - **Streaming**:
    - Gemini models do not support streaming when using tools/function calls

  These limitations reflect the underlying differences between LLM providers and their implementations. For provider-specific features or workarounds, you may need to interact with [litellm][litellm] or the provider's SDK directly.



  `promptic` is open-source software licensed under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).

  [litellm]: https://github.com/BerriAI/litellm


pkgId: cf175ef1cb6bc75fc4e73244e4c17cacd1a82f8bbf78a5ac7c4e9a2f2d7dd8c1
name: python-promptim-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for promptim
url: https://pypi.org/project/promptim/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-promptim-0.0.7-1.src.rpm
location_href: Packages/python-promptim-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  Promptim is an experimental **prompt** opt**im**ization library to help you systematically improve your AI systems.

  Promptim automates the process of improving prompts on specific tasks. You provide initial prompt, a dataset, and custom evaluators (and optional human feedback), and `promptim` runs an optimization loop to produce a refined prompt that aims to outperform the original.

  For setup and usage details, see the quick start guide below.

  ![Optimization](./static/optimizer.gif)



  Let's try prompt optimization on a simple tweet generation task.



  First install the CLI.

  ```shell
  pip install -U promptim
  ```

  And make sure you have a valid [LangSmith API Key](https://smith.langchain.com/) in your environment. For the quick start task, we will use Anthropic's Claude model for our optimizer and for the target system.

  ```shell
  LANGSMITH_API_KEY=CHANGEME
  ANTHROPIC_API_KEY=CHANGEME
  ```



  Next, create a task to optimize over. Run the following command to generate a template:

  ```shell
  promptim create task ./my-tweet-task \
      --name my-tweet-task \
      --prompt langchain-ai/tweet-generator-example-with-nothing:starter \
      --dataset https://smith.langchain.com/public/6ed521df-c0d8-42b7-a0db-48dd73a0c680/d \
      --description "Write informative tweets on any subject." \
      -y
  ```
  This command will generate starter code, complete with the task's:
  1. Name: Provide a useful name for the task (like "ticket classifier" or "report generator"). You may use the default here.
  2. Prompt: This is an identifier in the LangSmith prompt hub. Use the following public prompt to start.
  3. Dataset: This is the name (or public URL) for the dataset we are optimizing over. Optionally, it can have train/dev/test splits to report separate metrics throughout the training process.
  4. Description: This is a high-level description of the purpose for this prompt. The optimizer uses this to help focus its improvements.

  Once you've completed the template creation, you should have two files in the `my-tweet-task` directory:

  ```shell
  └── my-tweet-task
      ├── config.json
      └── task.py
  ```

  We can ignore the `config.json` file for now (we'll discuss that later). The last thing we need to do before training is create an evaluator.



  Next we need to quantify prompt performance on our task. What does "good" and "bad" look like? We do this using evaluators.

  Open the evaluator stub written in `my-tweet-task/task.py` and find the line that assigns a score to a prediction:

  ```python
      
      score = len(str(predicted.content)) < 180  # Replace with actual score
  ```

  We are going to make this evaluator penalize outputs with hashtags. Update that line to be:
  ```python
      score = int("#" not in result)
  ```

  Next, update the evaluator name. We do this using the `key` field in the evaluator response.
  ```python
      "key": "tweet_omits_hashtags",
  ```

  To help the optimizer know the ideal behavior, we can add additional instructions in the `comment` field in the response.

  Update the "comment" line to explicitly give pass/fail comments:
  ```python
          "comment": "Pass: tweet omits hashtags" if score == 1 else "Fail: omit all hashtags from generated tweets",
  ```

  And now we're ready to train! The final evaluator should look like:

  ```python
  def example_evaluator(run: Run, example: Example) -> dict:
      """An example evaluator. Larger numbers are better."""
      predicted: AIMessage = run.outputs["output"]

      result = str(predicted.content)
      score = int("#" not in result)
      return {
          "key": "tweet_omits_hashtags",
          "score": score,
          "comment": "Pass: tweet omits hashtags" if score == 1 else "Fail: omit all hashtags from generated tweets",
      }

  ```



  To start optimizing your prompt, run the `train` command:

  ```shell
  promptim train --task ./my-tweet-task/config.json
  ```

  You will see the progress in your terminal. once it's completed, the training job will print out the final "optimized" prompt in the terminal, as well as a link to the commit in the hub.



  Whenever you run `promptim train`, promptim first loads the prompt and dataset specified in your configuration. It then evaluates your prompt on the dev split (if present; full dataset otherwise) using the evaluator(s) configured above. This gives us baseline metrics to compare against throughout the optimization process.

  After computing a baseline, `promptim` begins optimizing the prompt by looping over minibatches of training examples. For each minibatch, `promptim` computes the metrics and then applies a **metaprompt** to suggest changes to the current prompt. It then applies that updated prompt to the next minibatch of training examples and repeats the process. It does this over the entire **train** split (if present; full dataset otherwise).

  After `promptim` has consumed the whole `train` split, it computes metrics again on the `dev` split. If the metrics show improvement (average score is greater), then the updated prompt is retained for the next round. If the metrics are the same or worse than the current best score, the prompt is discarded.

  This process is repeated `--num-epochs` times before the process terminates.





  To add human labeling using the annotation queue:

  1. Set up an annotation queue:
     When running the `train` command, use the `--annotation-queue` option to specify a queue name:
     ```
     promptim train --task ./my-tweet-task/config.json --annotation-queue my_queue
     ```

  2. During training, the system will pause after each batch and print out instructions on how to label the results. It will wait for human annotations.

  3. Access the annotation interface:
     - Open the LangSmith UI
     - Navigate to the specified queue (e.g., "my_queue")
     - Review and label as many examples as you'd like, adding notes and scores

  4. Resume:
     - Type 'c' in the terminal
     - The training loop will fetch your annotations and include them in the metaprompt's next optimizatin pass

  This human-in-the-loop approach allows you to guide the prompt optimization process by providing direct feedback on the model's outputs.





  The current CLI arguments are as follows. They are experimental and may change in the future:

  ```shell
  Usage: promptim [OPTIONS] COMMAND [ARGS]...

    Optimize prompts for AI tasks using automated evaluation and feedback.

    Promptim helps improve prompts for various AI tasks by running an
    optimization loop. You provide an initial prompt, a dataset, and custom
    evaluators. Promptim then iteratively refines the prompt to improve
    performance on your specific task.

    To get started, create a task configuration or use a pre-defined one, then
    run the 'train' command to begin optimization.

    Example:     promptim train --task ./my-task/config.json

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

  Commands:
    create  Commands for creating new tasks.
    train   Train and optimize prompts for different tasks.
  ```




  ```shell
  Usage: promptim create [OPTIONS] COMMAND [ARGS]...

    Commands for creating new tasks and examples.

  Options:
    --help  Show this message and exit.

  Commands:
    example  Clone a pre-made tweet generation task
    task     Walkthrough to create a new task directory from your own prompt and dataset
  ```

  `promptim create task`

  ```shell
  Usage: promptim create task [OPTIONS] PATH

    Create a new task directory with config.json and task file for a custom
    prompt and dataset.

  Options:
    --name TEXT         Name for the task. If not provided, the directory name
                        will be used as default. This name will be used in the
                        config.json file.
    --prompt TEXT       Name of the prompt in LangSmith to be optimized.
                        If not provided, you'll be prompted to select or create
                        one. This will be used as the initial prompt for
                        optimization.
    --description TEXT  Description of the task for the optimizer. This helps
                        guide the optimization process by providing context
                        about the task's objectives and constraints.
    --dataset TEXT      Name or public URL of the dataset in LangSmith to be used for
                        training and evaluation. If not provided, you'll be
                        prompted to select or create one. This dataset will be
                        used to test and improve the prompt.
    -y, --yes           Automatically answer yes to all CLI prompts. Use with
                        caution as it skips confirmation steps and uses defaults
                        where applicable.
    --help              Show this message and exit.
  ```




  ```shell
  Usage: promptim train [OPTIONS]

    Train and optimize prompts for different tasks.

  Options:
    --task TEXT              Task to optimize. Specify a pre-defined task name
                             or path to a custom config file. The task defines
                             the dataset, evaluators, and initial prompt to
                             optimize. Example:
                             'examples/tweet_writer/config.json' for a custom
                             task, or 'sentiment_analysis' for a pre-defined
                             task.
    --batch-size INTEGER     Number of examples to process in each optimization
                             iteration. Larger batches may improve stability but
                             are limited by the metaprompter's maximum context
                             window size.
    --train-size INTEGER     Maximum number of training examples to use per
                             epoch. Useful for limiting optimization time on
                             large datasets. If smaller than total available
                             data, a random subset will be used each epoch.
    --epochs INTEGER         Number of complete passes through the training
                             data. More epochs may improve results but increase
                             runtime.
    --debug                  Enable debug mode for verbose logging and
                             sequential processing.
    --annotation-queue TEXT  Name of the LangSmith annotation queue for manual
                             review of optimization results. The queue will be
                             cleared and updated on each batch.
    --no-commit              Prevent committing the optimized prompt to the
                             LangChain Hub. Use this for local experimentation.
    --help                   Show this message and exit.
  ```



  The schema for your `config.json` file can be found in [config-schema.json](./config-schema.json).

  It contains the following arguments:

  - `name` (string, required): The name of your task.
  - `dataset` (string, required): The name of the dataset in LangSmith to be used for training and evaluation.
  - `initial_prompt` (object, required): Configuration for the initial prompt to be optimized.
    - `identifier` (string, optional): Identifier for a prompt from the hub repository. Mutually exclusive with prompt_str.
    - `prompt_str` (string, optional): Raw prompt string to optimize locally. Mutually exclusive with identifier.
    - `model_config` (object, optional): Configuration dictionary specifying model parameters for optimization.
    - `which` (integer, default: 0): Index of the message to optimize within the prompt.
  - `description` (string, optional): A detailed explanation of the task's objectives and constraints.
  - `evaluator_descriptions` (object, optional): A mapping of evaluator names to their descriptions.
  - `optimizer` (object, optional): Configuration specifying model settings and hyperparameters. If not provided, default configuration will be used.
    - `model` (object, required): Model configuration dictionary specifying the model name, parameters, and other settings used by the optimizer.
  - `evaluators` (string, required): Import path to evaluator functions in format 'file_path:variable_name'. The functions should evaluate prompt quality. Example: `./task/evaluators.py:evaluators`
  - `system` (string, optional): Import path to system configuration in format 'file_path:variable_name'. Defines how prompts are executed. If not provided, a default system with just a prompt and LLM will be constructed. Example: `./task/my_system.py:chain`

  Below is an example `config.json` file:

  ```json
  {
    "name": "Tweet Generator",
    "dataset": "tweet_dataset",
    "initial_prompt": {
      "prompt_str": "Write a tweet about {topic} in the style of {author}",
      "which": 0
    },
    "description": "Generate engaging tweets on various topics in the style of different authors",
    "evaluator_descriptions": {
      "engagement_score": "Measures the potential engagement of the tweet",
      "style_match": "Evaluates how well the tweet matches the specified author's style"
    },
    "evaluators": "./tweet_evaluators.py:evaluators",
    "optimizer": {
      "model": {
        "name": "gpt-3.5-turbo",
        "temperature": 0.7
      }
    }
  }
  ```


pkgId: 3e232b6cd08527f36cd4a13acbf447cc21b6ad782ccbcf53da658c24692c1d55
name: python-prophetverse-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for prophetverse
url: https://pypi.org/project/prophetverse/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prophetverse-0.5.0-1.src.rpm
location_href: Packages/python-prophetverse-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="docs/static/logo-removebg.png" width="200">

  </p>

  [![PyPI version](https://badge.fury.io/py/prophetverse.svg)](https://badge.fury.io/py/prophetverse)
  [![codecov](https://codecov.io/gh/felipeangelimvieira/prophetverse/graph/badge.svg?token=O37PGJI3ZX)](https://codecov.io/gh/felipeangelimvieira/prophetverse)



  Prophetverse leverages the theory behind the Prophet model for time series forecasting and expands it into __a more general framework__, enabling custom priors, non-linear effects for exogenous variables and other likelihoods. Built on top of [sktime](https://www.sktime.net/en/stable/) and [numpyro](https://num.pyro.ai/en/stable/), Prophetverse aims to provide a flexible and easy-to-use library for time series forecasting with a focus on interpretability and customizability. It is particularly useful for Marketing Mix Modeling, where understanding the effect of different marketing channels on sales is crucial.




  - [🚀 Installation](#-installation)
  - [📊 Forecasting with default hyperparameters](#-forecasting-with-default-hyperparameters)
  - [🌟 Features & Comparison with Meta's Prophet](#-features--comparison-with-metas-prophet)
  - [🤝 Contributing to Prophetverse](#-contributing-to-prophetverse)
  - [📚 Documentation](#-documentation)
  - [🗺 Roadmap](https://github.com/felipeangelimvieira/prophetverse/discussions/99)



  To install with pip:

  ```bash
  pip install prophetverse
  ```

  Or with poetry:

  ```bash
  poetry add prophetverse
  ```



  Prophetverse model provides an interface compatible with sktime. Here's how to use it:

  ```python
  from prophetverse.sktime import Prophetverse


  model = Prophetverse()


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


  y_pred = model.predict(X=X, fh=[1,2,3,4])
  ```



  Prophetverse is similar to the original Prophet model in many aspects, but it has some differences and new features. The following table summarizes the main features of Prophetverse and compares them with the original Prophet model:



  | Feature                         | Prophetverse                                                                                                               | Original Prophet                         | Motivation |
  |---------------------------------|----------------------------------------------------------------------------------------------------------------------------|------------------------------------------| ----------------------------------------- |
  | **Logistic trend**              | Capacity as a random variable                           | Capacity as a hyperparameter, user input required             | The capacity is usually unknown by the users. Having it as a variable is useful for Total Addressable Market inference |
  | **Custom trend**               | Customizable trend functions                                                                                                | Not available                            | Users can create custom trends and leverage their knowledge about the timeseries to enhance long-term accuracy |
  | **Likelihoods**                 | Gaussian, Gamma and Negative Binomial                                                                                                | Gaussian only                            | Gaussian likelihood fails to provide good forecasts to positive-only and count data (sales, for example) |
  | **Custom priors**               | Supports custom priors for model parameters and exogenous variables                                                        | Not supported                            | Forcing positive coefficients, using prior knowledge to model the timeseries|
  | **Custom exogenous effects**              | Non-linear and customizable effects for exogenous variables, shared coefficients between time series                       | Not available                            | Users can create any kind of relationship between exogenous variables and the timeseries, which can be useful for Marketing Mix Modeling and other applications. |
  | **Changepoints**                | Uses changepoint interval                                                                                                  | Uses changepoint number                  | The changepoint number is not stable in the sense that, when the size of timeseries increases, its impact on forecast changes. Think about setting a changepoint number when timeseries has 6 months, and forecasting in future with 2 years of data (4x time original size). Re-tuning would be required. Prophetverse is expected to be more stable |
  | **Scaling**                     | Time series scaled internally, exogenous variables scaled by the user                                                      | Time series scaled internally            | Scaling `y` is needed to enhance user experience with hyperparameters. On the other hand, not scaling the exogenous variables provide more control to the user and they can leverage sktime's transformers to handle that. |
  | **Seasonality**                 | Fourier terms for seasonality passed as exogenous variables                                                                | Built-in seasonality handling            | Setting up seasonality requires almost zero effort by using `LinearFourierSeasonality` in Prophetverse. The idea is to allow the user to create custom seasonalities easily, without hardcoding it in the code. |
  | **Multivariate model**          | Hierarchical model with multivariate normal likelihood and LKJ prior, bottom-up forecast                                    | Not available                            | Having shared coefficients, using global information to enhance individual forecast.|| **Inference methods**           | MCMC and MAP                                                                                                               | MCMC and MAP                            | |
  | **Implementation** | Numpyro | Stan




  We welcome contributions! Check out our [contributing guidelines](https://prophetverse.com/development/development-guide//) to get started.



  Detailed documentation is available [here](https://prophetverse.com)


pkgId: b7b362ac8393666c08a420753ed85e4a3b9cc9455efe420b16d912892d222c9c
name: python-prosthetic-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for prosthetic
url: https://pypi.org/project/prosthetic/
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prosthetic-2.0.0-1.src.rpm
location_href: Packages/python-prosthetic-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  ******

  Bravo!  You have received a Mercantilism Diploma in "prosthetic" from
  the Orbital Convergence University International Air and Water
  Embassy of the tangerine Planet (the planet that is one ellipse further from
  the Sun than Earth's ellipse).

  You are now officially certified to include "prosthetic" in your practice.

  ******

  Please feel free to use this module however (business, personal, etc.)
  subject to the terms of AGPL 3.0 License, or any of the other licenses
  in the the pypi "prosthetic/_licenses/options" directory.

  	@ BGraceful

  ******




  ******


  `[xonsh] pip install prosthetic`

  ******


  `[xonsh] prosthetic school`

  ******


  ```
  	/prosthetic_1
  		/trends
  		/treasures
  			/treasure.1
  			/treasure.2

  		prosthetic_essence.py
  			essence = {}
  ```


  From a directory that is after the "prosthetic_essence.py" file.
  ```
  [@ prosthetic_1]
  prosthetic ventures on
  prosthetic form
  ```


  ```
  [@ prosthetic_1]
  prosthetic ventures off
  ```


  ```
  [@ prosthetic_1]
  prosthetic ventures refresh
  ```

  ******



  ```
  [@ prosthetic_1]
  prosthetic treasures itemize
  ```


  ```
  [@ prosthetic_1]
  prosthetic treasures stow --name "garbage.1"
  ```


  ******



  ```
  [@ prosthetic_1]
  prosthetic trends itemize
  ```


  ```
  [@ prosthetic_1]
  prosthetic trends search --domain "wallet.1"
  ```


  ```
  [@ prosthetic_1]
  prosthetic trends insert-document --domain "wallet.1" --names "[ 'name_1', 'name_2' ]"`
  prosthetic trends insert-document --domain "solid_food.1" --topics "[ 'food' ]" --cautions "[ 'homo-sapiens ages months 6+' ]"
  ```

  ******



  This saves the collections as .export files, sort of like JSON.

  ```
  [@ prosthetic_1]
  prosthetic trends saves exports-export --version 1
  ```


  This deletes the collections, and then imports the save.

  ```
  [@ prosthetic_1]
  prosthetic trends saves exports-import-overwrite --version 1
  ```


  This merges the save into the current collection.

  ```
  [@ prosthetic_1]
  prosthetic trends saves exports-import-overwrite --version
  ```


pkgId: 82837e98f2332a2db48305bb01e47da4f9e7910d6391a4b63ba2c57486dc56b8
name: python-prosuite-help
arch: noarch
version: 1.4.0.1
epoch: 0
release: 1
summary: Development documents and examples for prosuite
url: https://dirageosystems.ch/prosuite/doc/api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prosuite-1.4.0.1-1.src.rpm
location_href: Packages/python-prosuite-help-1.4.0.1-1.noarch.rpm
checksum_type: sha256
description:
  The Dira ProSuite Python Client is the Python API for the ProSuite Quality Verification Server. ProSuite is a suite of high-end productivity tools for ArcGIS for data production, quality assurance, and cartographic refinement.

  The ProSuite Python Client API is a lightweight package that provides access to the ProSuite QA functionality. It has been specifically designed as an easy-to-use programming interface that supports intellisense and comes with a documentation and samples.
  Quality specifications containing QA tests for geodata can be fully defined in Python and executed on a ProSuite server which runs either locally or on a remote machine. Alternatively, an existing XML specification can be executed with just a few lines of code.

  Find out more about ProSuite at [Dira GeoSystems](https://dirageosystems.ch/prosuite).


  ``pip install prosuite``


  See [ProSuite Python](https://dirageosystems.ch/prosuite/doc/api).


pkgId: dec46dc81325134bdfda838862fbf349894272517a0a85c5d29f7c0ae0822911
name: python-protein-metamorphisms-is-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for protein-metamorphisms-is
url: https://pypi.org/project/protein-metamorphisms-is/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-protein-metamorphisms-is-1.2.1-1.src.rpm
location_href: Packages/python-protein-metamorphisms-is-help-1.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Ensure Docker is installed on your system. If it’s not, you can download it from [here](https://docs.docker.com/get-docker/).

  Run the following command to start a PostgreSQL container with the pgvector extension:
  ```bash
  docker run -d --name pgvectorsql \
      -e POSTGRES_USER=usuario \
      -e POSTGRES_PASSWORD=clave \
      -e POSTGRES_DB=BioData \
      -p 5432:5432 \
      pgvector/pgvector:pg16
  ```
  Once the container is running, connect to the database and enable the `vector` extension:
  ```sql
  CREATE EXTENSION IF NOT EXISTS vector;
  ```

  Start a RabbitMQ container using the command below:
  ```bash
  docker run -d --name rabbitmq \
      -p 15672:15672 \
      -p 5672:5672 \
      rabbitmq:management
  ```

  Poetry is used for managing dependencies. Install it by following the official instructions [here](https://python-poetry.org/docs/#installation).

  Clone the repository and navigate into its directory:
  ```bash
  git clone https://github.com/CBBIO/protein-metamorphisms-is.git
  cd protein-metamorphisms-is
  ```

  Use Poetry to install the project dependencies:
  ```bash
  poetry install
  ```


  The main `config.yaml` file defines various settings used across the application, including system parameters, database configuration, and task-specific settings, pipelines such as FANTASIA contains a reduced template instance of this file on its own directory.
  - **System Configuration**:
    - `max_workers`: Specifies the maximum number of worker threads that the system can use. This controls the concurrency level for processing tasks.
    - `binaries_path`: Defines the relative path where binary files required by the application are stored.
  - **Database Configuration**:
    - `DB_USERNAME`: The username used to connect to the PostgreSQL database.
    - `DB_PASSWORD`: The password associated with the PostgreSQL user.
    - `DB_HOST`: The hostname of the PostgreSQL server (e.g., `localhost`).
    - `DB_PORT`: The port on which the PostgreSQL server is running (default: `5432`).
    - `DB_NAME`: The name of the PostgreSQL database where data is stored.
  - **RabbitMQ Configuration**:
    - `rabbitmq_host`: The hostname of the RabbitMQ server.
    - `rabbitmq_user`: The username used to authenticate with RabbitMQ.
    - `rabbitmq_password`: The password associated with the RabbitMQ user.
  - **Information System**:
    - `load_accesion_csv`: Path to the CSV file containing accession codes to be loaded into the system.
    - `load_accesion_column`: The column name in the CSV file that contains the accession IDs.
    - `tag`: A tag to be associated with the accession data for identification purposes.
    - `max_attempts`: Maximum number of attempts the system should make to process a given task before failing.
    - `search_criteria`: Criteria used to search for relevant data, typically in the format of a query string.
    - `limit`: The maximum number of results to return from a search query.
  - **PDB Extraction**:
    - `resolution_threshold`: Maximum resolution (in Ångströms) for selecting PDB structures.
    - `server`: URL of the PDB server to download structure files.
    - `data_directory`: Path where PDB data files are stored.
    - `file_format`: Format of the PDB files (e.g., `mmCif`).
    - `allow_multiple_chain_models`: Boolean flag indicating whether to allow multiple chain models, typically set to `False` for NMR data.
  - **Operations**:
    - `constants`: Path to the `constants.yaml` file containing various constant definitions used across the system.
  - **Sequence Clustering**:
    - `fasta_path`: Path where the FASTA file containing sequences is saved.
    - `cdhit_out_path`: Path where CD-HIT output files are stored.
    - `sequence_identity_threshold`: Threshold for sequence identity used by CD-HIT to determine clusters.
    - `alignment_coverage`: Minimum alignment coverage required for sequences to be considered similar.
    - `memory_usage`: Maximum amount of memory (in MB) that CD-HIT is allowed to use.
    - `most_representative_search`: Boolean flag to enable or disable searching for the most representative sequence in each cluster.
  - **Structural Alignment**:
    - `structural_alignment`: Contains settings for structural alignment tasks.
      - `types`: List of integers representing the types of alignments to perform.
      - `retry_timeout`: Time (in seconds) to wait before retrying a failed task.
      - `retry_count`: Maximum number of retry attempts for a failed task.
      - `batch_size`: Number of structures to process in a single batch.
      - `task_timeout`: Time (in seconds) to allow for the completion of a task before it times out.
  - **Embedding**:
    - `embedding`: Contains settings for generating embeddings from sequences.
      - `types`: List of integers representing the types of embeddings to generate (e.g., ESM, Prost).
      - `batch_size`: Number of sequences to process in a single batch.
  - **GO Metrics**:
    - `obo`: Path to the GO ontology file in OBO format.
    - `go_annotation_file`: Path to the file containing GO annotations.
    - `allowed_evidences`: List of evidence codes allowed when processing GO annotations.


pkgId: c302475aa910072c7b6156a6c48df9688a289393ee7f1e9882c4fdfe76d90d40
name: python-proteobench-help
arch: noarch
version: 0.5.7
epoch: 0
release: 1
summary: Development documents and examples for proteobench
url: https://github.com/ProteoBench
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-proteobench-0.5.7-1.src.rpm
location_href: Packages/python-proteobench-help-0.5.7-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/proteobench)

  Website: https://proteobench.cubimed.rub.de/

  PyPI: https://pypi.org/project/proteobench/

  Learn about the ProteoBench project on [proteobench.readthedocs.io](https://proteobench.readthedocs.io/en/latest/).

  See [here](https://proteobench.readthedocs.io/en/latest/developer-guide/development-setup/) for how to use ProteoBench locally, and how to contribute.

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


pkgId: ba48f573bade9207a95a5e3080809e3e7f2a5a10a719bd4522501d259361486e
name: python-protoletariat-help
arch: noarch
version: 3.3.5
epoch: 0
release: 1
summary: Development documents and examples for protoletariat
url: https://github.com/cpcloud/protoletariat
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-protoletariat-3.3.5-1.src.rpm
location_href: Packages/python-protoletariat-help-3.3.5-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/cpcloud/protoletariat/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/cpcloud/protoletariat/actions/workflows/ci.yml)



  Are you annoyed by having to fix the absolute imports generated by `protoc`?

  If so, then `protoletariat` is the tool for you.

  `protoletariat` has one goal: fixing the broken imports for the Python code
  generated by `protoc`.

  See https://github.com/protocolbuffers/protobuf/issues/1491 for the discussion that inspired this tool.



  |   Artifact    |                                                              Status                                                               |                Installation Command                |
  | :-----------: | :-------------------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------: |
  | PyPI Package  |                  [![PyPI](https://img.shields.io/pypi/v/protoletariat)](https://pypi.org/project/protoletariat)                   |            `pip install protoletariat`             |
  | Conda Package | [![Conda Version](https://img.shields.io/conda/vn/conda-forge/protoletariat.svg)](https://anaconda.org/conda-forge/protoletariat) |    `conda install protoletariat -c conda-forge`    |
  | Docker Image  |                                                                 ∅                                                                 | `docker pull ghcr.io/cpcloud/protoletariat:latest` |

  **Note: the `conda-forge` package version may lag behind the other artifacts by a few hours.**



  `protoletariat` is designed to be run as a post-processing step _after_ running
  `protoc`. It operates directly on the generated code.



  Here's an example of how to use the tool, called `protol`:

  1. Create a few protobuf files

  ```protobuf
  // thing1.proto
  syntax = "proto3";

  import "thing2.proto";

  package things;

  message Thing1 {
    Thing2 thing2 = 1;
  }
  ```

  ```protobuf
  // thing2.proto
  syntax = "proto3";

  package things;

  message Thing2 {
    string data = 1;
  }
  ```

  2. Run `protoc` on those files

  ```sh
  $ mkdir out
  $ protoc \
    --python_out=out \
    --proto_path=directory/containing/protos thing1.proto thing2.proto
  ```

  3. Run `protol` on the generated code

  ```sh
  $ protol \
    --create-package \
    --in-place \
    --python-out out \
    protoc --proto-path=directory/containing/protos thing1.proto thing2.proto
  ```

  The `out/thing1_pb2.py` module should show a diff containing at least these lines:

  ```patch
  -import thing2_pb2 as thing2__pb2
  -
  +from . import thing2_pb2 as thing2__pb2
  ```



  At a high level `protoletariat` converts absolute imports to relative imports.

  However, it doesn't convert just any absolute import to a relative import.

  The `protol` tool will only convert imports that were generated from `.proto`
  files. It does this by inspecting `FileDescriptorProtos` generated from the
  proto files.

  The core rewrite mechanism is implemented using a simplified form of pattern
  matching that looks at the Python AST, and invokes rewrite rules for matched
  import patterns.



  `protoletariat` has a subcommand for each tool that you might like to use to
  generate `FileDescriptorSet` bytes:

  | Subcommand | Description                                                                |
  | :--------: | :------------------------------------------------------------------------- |
  |  `protoc`  | Uses `protoc` to generate `FileDescriptorSet` bytes                        |
  |   `buf`    | Uses `buf` to generate `FileDescriptorSet` bytes                           |
  |   `raw`    | You provide the `FileDescriptorSet` bytes as a file or directly from stdin |



  ```
  $ protol
  Usage: protol [OPTIONS] COMMAND [ARGS]...

    Rewrite protoc or buf-generated imports for use by the protoletariat.

  Options:
    -o, --python-out DIRECTORY      Directory containing protoc or buf-generated Python code  [required]
    --in-place / --not-in-place     Overwrite all relevant files under `--python-out` with adjusted imports  [default: not-in-place]
    --create-package / --dont-create-package
                                    Recursively create __init__.py files under `--python-out`  [default: dont-create-package]
    -s, --module-suffixes TEXT      Suffixes of Python/mypy modules to process  [default: _pb2.py, _pb2.pyi, _pb2_grpc.py, _pb2_grpc.pyi]
    --exclude-google-imports / --dont-exclude-google-imports
                                    Exclude rewriting imports prefixed with google/protobuf
    -e, --exclude-imports-glob TEXT
                                    Exclude imports matching a glob pattern from being rewritten. Multiple values are allowed
    --help                          Show this message and exit.

  Commands:
    buf     Use buf to generate the FileDescriptorSet blob
    protoc  Use protoc to generate the FileDescriptorSet blob
    raw     Rewrite imports using FileDescriptorSet bytes from a file or stdin
  ```


pkgId: f1260bf0b7794319db49af8e39b89c7f97917e0890c5d5ec29f13106ff75ee1d
name: python-protollm-worker-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for protollm-worker
url: https://pypi.org/project/protollm-worker/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-protollm-worker-1.0.0-1.src.rpm
location_href: Packages/python-protollm-worker-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  1. [Docker Compose Setup](#docker-compose-setup)
     - [Adding Multiple Models](#adding-multiple-models)
  2. [Main Script Overview](#main-script-overview)
     - [Using Custom Models](#using-custom-models)
  3. [Environment Variable Configuration](#environment-variable-configuration)


pkgId: 56ef9d8dd65d5a697fd15f23dd81001da22375ae1014c32ae06e371dca613bb6
name: python-protomatics-help
arch: noarch
version: 0.8.4
epoch: 0
release: 1
summary: Development documents and examples for protomatics
url: https://github.com/j-p-terry/protomatics
rpm_license: LICENSE.md
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-protomatics-0.8.4-1.src.rpm
location_href: Packages/python-protomatics-help-0.8.4-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <!-- <a href="https://app.circleci.com/pipelines/github/j-p-terry/non_keplerian_anomaly_detection"><img alt="Build" src="https://shields.api-test.nl/circleci/build/github/j-p-terry/non_keplerian_anomaly_detection?style=for-the-badge&token=4bae0fb820e3e7d4ec2352639e35d499c673d78c"></a> -->
    <a href="https://www.python.org/"><img alt="Python" src="https://img.shields.io/badge/-Python 3.9+-blue?style=for-the-badge&logo=python&logoColor=white"></a>
    <!-- <a href="https://black.readthedocs.io/en/stable/"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-black.svg?style=for-the-badge&labelColor=gray"></a> -->
    <!-- <a href="https://doi.org/10.5281/zenodo.8410680"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.8410680.svg" alt="DOI"></a> -->
    <a href="https://zenodo.org/record/8410681"><img src="https://img.shields.io/badge/DOI-10.5281%2Fzenodo.8410680-blue?style=for-the-badge&logo=Zenodo&logoColor=white" alt="DOI - 10.5281/zenodo.8410680"></a>
  </h1>

  ProtoMatics is a python package to analyze and visualize protoplanetary disk data, particularly in the context of kinematics. It can calculate moment maps, extract velocity channels, visualize fits files (e.g. line emission data), and calculate other quantities of interest. It is mainly designed to be used as a helper in larger analysis scripts.

  It can be installed via

  ```bash
  pip install protomatics
  ```

  and imported into any python script with

  ```python
  import protomatics as pm
  ```



  (Note: all dashes given in the text variable names should be considered underscores.)



  Several different types of plots can be made. One generally useful function plots data in WCS. Among other functionality, contours of other data can be overlaid, other data can be subtracted, and beams can be plotted.

  ```python
  pm.plot_wcs_data(
      hdu,
      fits_path,
      plot_data,
      channel=0.0,
      line_index=0.0,
      contour_value=None,
      save=False,
      save_name="./plot.pdf",
      trim=(None, None),
      vmin=None,
      vmax=None,
      overlay_hdu=None,
      overlay_pmin=0.0,
      overlay_channels=None,
      subtract_data=None,
      subtract_channels=None,
      subtract_overlay_channels=None,
      num_ticks=5,
      log=False,
      scale_data=1.0,
      overlay_data_scale=1.0,
      plot_cmap="magma",
      plot_units="",
      beam_position=None,
      overlay_beam_position=None,
      beam_color="white",
      overlay_beam_color="limegreen",
      plot_beam=False,
      plot_overlay_beam=False,
      show=True,
      **kwargs,
  )
  ```

  where $\mathrm{\texttt{**kwargs}}$ includes options to override default plot values. $\mathrm{\texttt{label-font}}$ sets the axis label font size. $\mathrm{\texttt{tick-font}}$ sets the tick label size. $\mathrm{\texttt{legend-font}}$ sets the legend font size. $\mathrm{\texttt{figsize}}$ sets the figure size as a tuple (H, W). $\mathrm{\texttt{overlay-cmap}}$ sets the default colormap for the overlay contours. $\mathrm{\texttt{overlay-color-list}}$ explicitly passes the colors for the overlay contours. All arguments above are shown as their default values.

  Polar plots can be made with

  ```python
  pm.plot_polar_and_get_contour(data, contour_value)
  ```
  which creates a heatmap in polar coordinates and extracts a contour at the given value (optional).

  ```python
  pm.polar_plot(rs, phis, scatter=whether_to_use_scatter_or_line)
  ```

  will make a scatter or line plot in polar coordinates depending on the value of $\mathrm{\texttt{scatter}}$.

  Basic image plots can be made with
  ```python
  pm.basic_image_plot(
      data,
      xlabel="",
      ylabel="",
      cbar_label="",
      plot_cmap="magma",
      vmin=None,
      vmax=None,
      save=False,
      show=True,
      save_name="plot.pdf",
      log=False,
  )
  ```





  ProtoMatics can calculate moment-0, 1, 2, 8, and 9 maps using [bettermoments](https://github.com/richteague/bettermoments). To caluculate moments, use

  ```python
  moments, uncertainties = pm.make_moments(
      path_to_fits,
      which_moments=[moments_you_want_to_plot],
      vel_min=minimum_velocity_to_use,
      vel_max=maximum_velocity_to_use,
      sub_cont=whether_to_subtract_average_of_first_and_last_channels,
      masked_data=array_with_mask_to_use,
      velax=precalculated_velocity_list,
      rms=precalculated_rms_of_data,
      save_moments=whether_to_save_results,
      outname=prefix_of_saved_file,
  )
  ```

  where $\mathrm{\texttt{moments}}$ and $\mathrm{\texttt{uncertainties}}$ are dictionaries with keys corresponding to the moment order. All arguments except for $\mathrm{\texttt{path-to-fits}}$ are optional. If only $\mathrm{\texttt{path-to-fits}}$ is provided, the moments will be loaded and calculated without any additional options.

  The moments can be plotted with

  ```python
  pm.plot_moments(moment_dictionary, fits_path=path_to_fits)
  ```

  This has no required arguments. Previously calculated moments ($\mathrm{\texttt{calc-moments}}$) can be passed through or $\mathrm{\texttt{fits-path}}$ can be used to direct the calculation of moments for a given fits file. One of these two things must be put into the function or else there is nothing to plot. The precalcualted moments get priority if both are used. Keplerian moments are calculated if $\mathrm{\texttt{sub-kep-moment}}$ = True. Keplerian moments are calculated using $\mathrm{\texttt{M-star}}$, $\mathrm{\texttt{inc}}$, and $\mathrm{\texttt{distance}}$. They are matched in position space using the fits provided in $\mathrm{\texttt{fits-path}}$.
  $\mathrm{\texttt{vmaxes}}$ and $\mathrm{\texttt{vmins}}$ are dictionaries with the maximum and minimum values to plot, respectively.

  Moments can also be masked into their Keplerian and non-Keplerian components. Masks are calculated by determining if a given region is within some tolerance ($\mathrm{\texttt{vel-tol}}$) of the Keplerian velocity at that location.

  ```python
  pm.make_masked_moments(path_to_fits)
  ```
  with similar key word arguments to pm.make_moments()

  Wiggles can be extracted in either position-position space (where moment-1 = 0) of position-velocity space (velocity along minor axis).

  ```python
  wiggle_rs, wiggle_y = pm.extract_wiggle(
      moment1_map,
      in_pv_space=whether_to_get_positon_velocity_wiggle,
      rotation_angle=minor_axis_offset_in_degrees,
  )
  ```
  $\mathrm{\texttt{wiggle-y}}$ is in radians for (i.e. azimuthal angle of wiggle) position-positon curve and in km/s for position-velocity curve.

  The amplitude of the wiggle can be calculated using either integration along the curve or by simple standard deviation.

  ```python
  amplitude = pm.get_wiggle_amplitude(
      rs,
      phis,
      ref_rs=list_of_reference_curves_rs,
      ref_phis=list_of_reference_curves_phis,
      vel_is_zero=whether_the_systemic_channel_is_used,
      use_std_as_amp=whether_to_get_amplitude_as_standard_deviation,
  )
  ```
  Only $\mathrm{\texttt{rs}}$ and $\mathrm{\texttt{phis}}$ are required. If $\mathrm{\texttt{vel-is-zero}}$ = True, the $\mathrm{\texttt{reference-curve}}$ is simply taken as the minor axis (i.e, $\phi = \pm \pi / 2$).

  One can also calculate the azimuthal average of an array of data using
  ```python
  average_by_r, average_map = pm.calc_azimuthal_average(
      data,
      r_grid=grid_of_radius_at_each_point_in_physical_space,
  )
  ```
  $\mathrm{\texttt{data}}$ is mandatory, but the grid is not. If no grid is provided, the radii will be calculated in terms of pixels instead of the physical space defined by $\mathrm{\texttt{r-grid}}$.

  This method is conveneint for calculating Doppler flip plots if $\mathrm{\texttt{data}}$ = azimuthal velocity field



  Adding the ability to analyze HDF5 files (e.g. created from PHANTOM outputs) is ongoing. As of now, HDF5 files can be loaded as Pandas dataframes, which can be used to do things such as make an interpolated map of a given value or calculate values such as Fourier amplitudes. Loading a dataframe can be done with

  ```python
  pm.make_hdf5_dataframe(path_to_hdf5_file, extra_file_keys=None)
  ```
  This will return a dataframe with the x, y, z, r, and $\phi$ positions of each particle as well as the x, y, z, r, and $\phi$ components of their velocity. $\mathrm{\texttt{extra-file-keys}}$ is a list of additional data to load. This can be done for any scalar value with a corresponding key in the HDF5 particle dataset. If one wants to load the magnetic field, the key "Bxyz" should be used. This will add the x, y, z, r, and $\phi$ components of the magnetic field to the dataframe.

  A 2D grid of interpolated data can be made using this dataframe (or any dataframe). Any value in the dataframe can be made into a grid. This is done with

  ```python
  pm.make_interpolated_grid(
      dataframe,
      grid_size=height_of_grid_in_pixels,
      interpolate_value=value_to_use,
      file_path=path_to_hd5f_file,
      extra_file_keys=any_extra_info,
      return_grids=return_grids_that_were_made,
  )
  ```
  $\mathrm{\texttt{dataframe}}$ can be None, but then $\mathrm{\texttt{file-path}}$ needs to be the path to the HDF5 file to be used.

  This is all put together to calculate the Doppler flip with

  ```python
  pm.calculate_doppler_flip(
      hdf5_path,
      grid_size=height_of_grid_in_pixels,
      interpolate_value=value_to_use,
      file_path=path_to_hd5f_file,
      extra_file_keys=None,
      return_grids=False,
      plot=whether_to_plot,
      save_plot=whether_to_save_plot,
      show_plot=whether_to_show_plot,
      xlabel=plot_xlabel,
      ylabel=plot_ylabel,
      vmin=plot_minimum_value,
      vmax=plot_maximum_value,
  )
  ```

  This will return a map of the doppler flip, a map of the azimuthal velocity, and a map of the azimuthally averaged azimuthal velocity.

  HDF5 files can also be used to calculate Fourier amplitudes for given modes within an annulus between a set radial range. This is done with

  ```python
  pm.calculate_fourier_amps(
      r_min,
      r_max,
      modes=modes_to_use,
      hdf5_df=loaded_hdf5_dataframe,
      hdf5_path=path_to_hdf5_file_if_not_loaded,
  )
  ```


  Other functionality is quickly being added. Please report any bugs. More substantial documentation is coming soon.





  Please cite the DOI corresponding to the version of $\mathrm{\texttt{ProtoMatics}}$ you used, ensuring that future researchers can access the exact version you utilized. The DOIs for each version can be found in the [Zenodo archive](https://zenodo.org/record/8410680).


  If you are discussing $\mathrm{\texttt{ProtoMatics}}$ broadly and not referring to a specific version in your work, please use the persistent DOI: [10.5281/zenodo.8410680](https://doi.org/10.5281/zenodo.8410680).


  ```bibtex
  @software{protomatics,
    author       = {Jason P. Terry},
    title        = {ProtoMatics: v0.3.2},
    month        = oct,
    year         = 2023,
    publisher    = {Zenodo},
    version      = {v0.3.2},
    doi          = {10.5281/zenodo.8410681},
    url          = {https://doi.org/10.5281/zenodo.8410681}
  }
  ```


  ```bibtex
  @software{protomatics,
    author       = {Jason P. Terry},
    title        = {ProtoMatics},
    month        = sep,
    year         = 2023,
    publisher    = {PyPi},
    doi          = {10.5281/zenodo.8410680},
    url          = {https://pypi.org/project/protomatics/}
  }
  ```


pkgId: 21752b3c395f0e9ea507fc3cffe8eb93c69a58a67cda30b8e86a997ae6548624
name: python-protools4py-help
arch: noarch
version: 1.2.2
epoch: 0
release: 1
summary: Development documents and examples for protools4py
url: https://github.com/GCS-ZHN/protools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-protools4py-1.2.2-1.src.rpm
location_href: Packages/python-protools4py-help-1.2.2-1.noarch.rpm
checksum_type: sha256
description:
  Personal protein processing tool collections.



  Necessary requirement is listed in [requirements.txt](./requirements.txt).
  Optional requirement is listed below:
  ```bash
  conda install -c schrodinger pymol
  conda install -c bioconda abnumber
  ```
  Also, pypi release will be updated every github release, just install it by `pip`:
  ```bash
  pip install protools4py
  ```


pkgId: 3eced3ae2a8bc3a0486a038e3e0593c15e834afc60a9544b90ffa565263bb40b
name: python-protspace-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for protspace
url: https://pypi.org/project/protspace/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-protspace-1.0.3-1.src.rpm
location_href: Packages/python-protspace-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  ProtSpace is a visualization tool for exploring protein embeddings or similarity matrix along their 3D protein structures. It allows users to interactively visualize high-dimensional protein language model data in 2D or 3D space, color-code proteins based on various features, and view protein structures when available.



  - [ProtSpace](#protspace)
    - [Table of Contents](#table-of-contents)
    - [Quick Start with Google Colab](#quick-start-with-google-colab)
    - [Example Outputs](#example-outputs)
      - [2D Scatter Plot (SVG)](#2d-scatter-plot-svg)
      - [3D Interactive Plot](#3d-interactive-plot)
    - [Installation](#installation)
    - [Usage](#usage)
      - [Data Preparation](#data-preparation)
      - [Running protspace](#running-protspace)
    - [Features](#features)
    - [Data Preparation](#data-preparation-1)
      - [Required Arguments](#required-arguments)
      - [Optional Arguments](#optional-arguments)
      - [Method-Specific Parameters](#method-specific-parameters)
    - [Custom Feature Styling](#custom-feature-styling)
    - [File Formats](#file-formats)
      - [Input](#input)
      - [Output](#output)



  Try ProtSpace instantly using our Google Colab notebooks:

  **Note**: Some Google Colab functionalities may not work properly in Safari browsers. For the best experience, we recommend using Chrome or Firefox.

  1. **Explore Pre-computed Visualizations**:
  [![Open Explorer In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/tsenoner/protspace/blob/main/examples/notebook/Explore_ProtSpace.ipynb)

  2. **Generate Protein Embeddings**:
  [![Open Embeddings In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/tsenoner/protspace/blob/main/examples/notebook/ClickThrough_GenerateEmbeddings.ipynb)

  3. **Full Pipeline Demo**:
  [![Open Pipeline In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/tsenoner/protspace/blob/main/examples/notebook/Run_ProtSpace.ipynb)





  ![2D Scatter Plot Example](https://tsenoner.github.io/protspace/examples/out/toxins/protein_category_umap.svg)



  [View 3D Interactive Plot](https://tsenoner.github.io/protspace/examples/out/3FTx/UMAP3_major_group.html)



  ```bash
  pip install protspace
  ```





  ```bash
  protspace-json -i embeddings.h5 -m features.csv -o output.json --methods pca3 umap2 tsne2
  ```



  ```bash
  protspace output.json [--pdb_zip pdb_files.zip] [--port 8050]
  ```

  Access the interface at `http://localhost:8050`



  - Interactive 2D/3D visualization with multiple dimensionality reduction methods:
    - Principal Component Analysis (PCA)
    - Multidimensional Scaling (MDS)
    - Uniform Manifold Approximation and Projection (UMAP)
    - t-Distributed Stochastic Neighbor Embedding (t-SNE)
    - Pairwise Controlled Manifold Approximation (PaCMAP)
  - Feature-based coloring and marker styling
  - Protein structure visualization (with PDB files)
  - Search and highlight functionality
  - High-quality plot exports
  - Responsive web interface



  The `protspace-json` command supports:



  - `-i, --input`: HDF file (.h5) or similarity matrix (.csv)
  - `-m, --metadata`: CSV file with features (first column must be named "identifier" and match IDs in HDF5/similarity matrix)
  - `-o, --output`: Output JSON path
  - `--methods`: Reduction methods (e.g., pca2, tsne3, umap2, pacmap2, mds2)



  - `--custom_names`: Custom projection names (e.g., pca2=PCA_2D)
  - `--verbose`: Increase output verbosity



  - UMAP:
    - `--n_neighbors`: Number of neighbors (default: 15)
    - `--min_dist`: Minimum distance (default: 0.1)
  - t-SNE:
    - `--perplexity`: Perplexity value (default: 30)
    - `--learning_rate`: Learning rate (default: 200)
  - PaCMAP:
    - `--mn_ratio`: MN ratio (default: 0.5)
    - `--fp_ratio`: FP ratio (default: 2.0)
  - MDS:
    - `--n_init`: Number of initializations (default: 4)
    - `--max_iter`: Maximum iterations (default: 300)



  Use `protspace-feature-colors` to customize feature appearance:

  ```bash
  protspace-feature-colors input.json output.json --feature_styles '{
    "feature_name": {
      "colors": {
        "value1": "#FF0000",
        "value2": "#00FF00"
      },
      "shapes": {
        "value1": "circle",
        "value2": "square"
      }
    }
  }'
  ```

  Available shapes: circle, circle-open, cross, diamond, diamond-open, square, square-open, x





  1. **Embeddings/Similarity**
     - HDF5 (.h5) for embeddings
     - CSV for similarity matrix

  2. **Metadata**
     - CSV with mandatory 'identifier' column matching IDs in embeddings/similarity data
     - Additional columns for features

  3. **Structures**
     - ZIP containing PDB/CIF files
     - Filenames match identifiers (dots replaced with underscores)



  - JSON containing:
    - Protein features
    - Projection coordinates
    - Visualization state (colors, shapes)


pkgId: d0ee76325ff0aba3caf9533ae6d90d39114f69a1cf10e7de3a1956c441f4185b
name: python-provenaclient-help
arch: noarch
version: 0.23.0
epoch: 0
release: 1
summary: Development documents and examples for provenaclient
url: https://pypi.org/project/provenaclient/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-provenaclient-0.23.0-1.src.rpm
location_href: Packages/python-provenaclient-help-0.23.0-1.noarch.rpm
checksum_type: sha256
description:
  Welcome to the Provena Python Client repository! This client library is a programmatic interface designed to interact seamlessly with your Provena instance. The client uses the same Pydantic models as the Provena API, ensuring a one-to-one typed interface with the API. This means that the models used in the client library directly correspond to those used by the API, providing consistency and ease of use. It allows you to replicate most functionalities of the Provena Web app through Python code, including fetching or minting datasets, creating items within the registry, and launching provenance workflows. With the Provena Python Client, you can achieve comprehensive interactions with only a few lines of code.




  To install the Provena Python Client, simply use pip:

  ```bash
  pip install provenaclient
  ```

  Once you have successfully installed provenaclient, refer to the following notebook for examples on how to use the client. Example Notebook here at: [Example Notebook](docs/example-client-workflow.ipynb).

  To find more examples on how to use the client, refer to these collection of notebooks: [Provena Notebook Repository](https://github.com/provena/provena-example-notebooks)




  If you are interested in running any tests, please make sure to first clone this repository and then follow the below steps:



  The Provena Python Client includes unit tests that check functionality using real server interactions and mocked components using `httpx_mock`. Tests cover HTTP methods, error handling, and JSON parsing.

  **To run unit tests:**
  1. Install dependencies from `pyproject.toml`.
  2. Run `pytest test_unit.py` in the test directory.



  The Provena Python Client includes integration tests that validate and assess the functioning of the client library and its interaction with Provena API's, focusing on dataset operations, entity searching, item fetching, and provenance lifecycle.

  **To run integration tests:**
  1. Install dependencies from `pyproject.toml`.
  2. Set up necessary credentials in `.env` (contact Provena Development Team for setup).
  3. Run `pytest test_integration.py` in the test directory.

  For detailed testing procedures, see the [Testing Guide](tests/README.md).



  Find Provena Python Client documentation and API Reference at: ([Provena Client Documentation](https://provena.github.io/provena-python-client/))


  Contact Provena Developers via https://www.csiro.au/en/contact


   Refer to the following doc [Contributing Guidelines](./CONTRIBUTING.md)



  `provenaclient` was created by Provena Development Team (CSIRO). Provena Development Team (CSIRO) retains all rights to the source and it may not be reproduced, distributed, or used to create derivative works.


   The development of Provena Python Client was funded by Reef Restoration and Adaptation Program (RRAP), which is a partnership between the Australian Government’s Reef Trust and the Great Barrier Reef Foundation. Provena Python Client has been developed to support the Modelling and Decision Support (MDS) Subprogram (https://gbrrestoration.org/program/modelling-and-decision-support/).

   People who contributed and developed Provena Python Client (ordered alphabetically):
    - Jonathan Yu
    - Parth Kulkarni
    - Peter Baker
    - Ross Petridis


pkgId: bfedee7a2a33b7945fcc92071bb5fc090def2e88148fb73e4fab36766a089294
name: python-prowler-cloud-help
arch: noarch
version: 5.0.1
epoch: 0
release: 1
summary: Development documents and examples for prowler-cloud
url: https://github.com/prowler-cloud/prowler
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prowler-cloud-5.0.1-1.src.rpm
location_href: Packages/python-prowler-cloud-help-5.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img align="center" src="https://github.com/prowler-cloud/prowler/blob/master/docs/img/prowler-logo-black.png#gh-light-mode-only" width="50%" height="50%">
    <img align="center" src="https://github.com/prowler-cloud/prowler/blob/master/docs/img/prowler-logo-white.png#gh-dark-mode-only" width="50%" height="50%">
  </p>
  <p align="center">
    <b><i>Prowler SaaS </b> and <b>Prowler Open Source</b> are as dynamic and adaptable as the environment they’re meant to protect. Trusted by the leaders in security.
  </p>
  <p align="center">
  <b>Learn more at <a href="https://prowler.com">prowler.com</i></b>
  </p>

  <p align="center">
  <a href="https://goto.prowler.com/slack"><img width="30" height="30" alt="Prowler community on Slack" src="https://github.com/prowler-cloud/prowler/assets/38561120/3c8b4ec5-6849-41a5-b5e1-52bbb94af73a"></a>
    <br>
    <a href="https://goto.prowler.com/slack">Join our Prowler community!</a>
  </p>
  <hr>
  <p align="center">
    <a href="https://goto.prowler.com/slack"><img alt="Slack Shield" src="https://img.shields.io/badge/slack-prowler-brightgreen.svg?logo=slack"></a>
    <a href="https://pypi.org/project/prowler/"><img alt="Python Version" src="https://img.shields.io/pypi/v/prowler.svg"></a>
    <a href="https://pypi.python.org/pypi/prowler/"><img alt="Python Version" src="https://img.shields.io/pypi/pyversions/prowler.svg"></a>
    <a href="https://pypistats.org/packages/prowler"><img alt="PyPI Prowler Downloads" src="https://img.shields.io/pypi/dw/prowler.svg?label=prowler%20downloads"></a>
    <a href="https://hub.docker.com/r/toniblyx/prowler"><img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/toniblyx/prowler"></a>
    <a href="https://hub.docker.com/r/toniblyx/prowler"><img alt="Docker" src="https://img.shields.io/docker/cloud/build/toniblyx/prowler"></a>
    <a href="https://hub.docker.com/r/toniblyx/prowler"><img alt="Docker" src="https://img.shields.io/docker/image-size/toniblyx/prowler"></a>
    <a href="https://gallery.ecr.aws/prowler-cloud/prowler"><img width="120" height=19" alt="AWS ECR Gallery" src="https://user-images.githubusercontent.com/3985464/151531396-b6535a68-c907-44eb-95a1-a09508178616.png"></a>
    <a href="https://codecov.io/gh/prowler-cloud/prowler"><img src="https://codecov.io/gh/prowler-cloud/prowler/graph/badge.svg?token=OflBGsdpDl"/></a>
  </p>
  <p align="center">
    <a href="https://github.com/prowler-cloud/prowler"><img alt="Repo size" src="https://img.shields.io/github/repo-size/prowler-cloud/prowler"></a>
    <a href="https://github.com/prowler-cloud/prowler/issues"><img alt="Issues" src="https://img.shields.io/github/issues/prowler-cloud/prowler"></a>
    <a href="https://github.com/prowler-cloud/prowler/releases"><img alt="Version" src="https://img.shields.io/github/v/release/prowler-cloud/prowler?include_prereleases"></a>
    <a href="https://github.com/prowler-cloud/prowler/releases"><img alt="Version" src="https://img.shields.io/github/release-date/prowler-cloud/prowler"></a>
    <a href="https://github.com/prowler-cloud/prowler"><img alt="Contributors" src="https://img.shields.io/github/contributors-anon/prowler-cloud/prowler"></a>
    <a href="https://github.com/prowler-cloud/prowler"><img alt="License" src="https://img.shields.io/github/license/prowler-cloud/prowler"></a>
    <a href="https://twitter.com/ToniBlyx"><img alt="Twitter" src="https://img.shields.io/twitter/follow/toniblyx?style=social"></a>
    <a href="https://twitter.com/prowlercloud"><img alt="Twitter" src="https://img.shields.io/twitter/follow/prowlercloud?style=social"></a>
  </p>
  <hr>
  <p align="center">
    <img align="center" src="/docs/img/prowler-cli-quick.gif" width="100%" height="100%">
  </p>



  **Prowler** is an Open Source security tool to perform AWS, Azure, Google Cloud and Kubernetes security best practices assessments, audits, incident response, continuous monitoring, hardening and forensics readiness, and also remediations! We have Prowler CLI (Command Line Interface) that we call Prowler Open Source and a service on top of it that we call <a href="https://prowler.com">Prowler SaaS</a>.



  Prowler App is a web application that allows you to run Prowler in your cloud provider accounts and visualize the results in a user-friendly interface.

  ![Prowler App](docs/img/overview.png)

  >More details at [Prowler App Documentation](https://docs.prowler.com/projects/prowler-open-source/en/latest/#prowler-app-installation)



  ```console
  prowler <provider>
  ```
  ![Prowler CLI Execution](docs/img/short-display.png)



  ```console
  prowler dashboard
  ```
  ![Prowler Dashboard](docs/img/dashboard.png)

  It contains hundreds of controls covering CIS, NIST 800, NIST CSF, CISA, RBI, FedRAMP, PCI-DSS, GDPR, HIPAA, FFIEC, SOC2, GXP, AWS Well-Architected Framework Security Pillar, AWS Foundational Technical Review (FTR), ENS (Spanish National Security Scheme) and your custom security frameworks.

  | Provider | Checks | Services | [Compliance Frameworks](https://docs.prowler.com/projects/prowler-open-source/en/latest/tutorials/compliance/) | [Categories](https://docs.prowler.com/projects/prowler-open-source/en/latest/tutorials/misc/#categories) |
  |---|---|---|---|---|
  | AWS | 561 | 81 -> `prowler aws --list-services` | 30 -> `prowler aws --list-compliance` | 9 -> `prowler aws --list-categories` |
  | GCP | 77 | 13 -> `prowler gcp --list-services` | 3 -> `prowler gcp --list-compliance` | 2 -> `prowler gcp --list-categories`|
  | Azure | 139 | 18 -> `prowler azure --list-services` | 4 -> `prowler azure --list-compliance` | 2 -> `prowler azure --list-categories` |
  | Kubernetes | 83 | 7 -> `prowler kubernetes --list-services` | 1 -> `prowler kubernetes --list-compliance` | 7 -> `prowler kubernetes --list-categories` |





  Prowler App can be installed in different ways, depending on your environment:

  > See how to use Prowler App in the [Prowler App Usage Guide](https://docs.prowler.com/projects/prowler-open-source/en/latest/tutorials/prowler-app/).



  **Requirements**

  * `Docker Compose` installed: https://docs.docker.com/compose/install/.

  **Commands**

  ``` console
  curl -LO https://raw.githubusercontent.com/prowler-cloud/prowler/refs/heads/master/docker-compose.yml
  curl -LO https://raw.githubusercontent.com/prowler-cloud/prowler/refs/heads/master/.env
  docker compose up -d
  ```

  > Enjoy Prowler App at http://localhost:3000 by signing up with your email and password.



  **Requirements**

  * `git` installed.
  * `poetry` installed: [poetry installation](https://python-poetry.org/docs/#installation).
  * `npm` installed: [npm installation](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
  * `Docker Compose` installed: https://docs.docker.com/compose/install/.

  **Commands to run the API**

  ``` console
  git clone https://github.com/prowler-cloud/prowler
  cd prowler/api
  poetry install
  poetry shell
  set -a
  source .env
  docker compose up postgres valkey -d
  cd src/backend
  python manage.py migrate --database admin
  gunicorn -c config/guniconf.py config.wsgi:application
  ```

  > Now, you can access the API documentation at http://localhost:8080/api/v1/docs.

  **Commands to run the API Worker**

  ``` console
  git clone https://github.com/prowler-cloud/prowler
  cd prowler/api
  poetry install
  poetry shell
  set -a
  source .env
  cd src/backend
  python -m celery -A config.celery worker -l info -E
  ```

  **Commands to run the UI**

  ``` console
  git clone https://github.com/prowler-cloud/prowler
  cd prowler/ui
  npm install
  npm run build
  npm start
  ```

  > Enjoy Prowler App at http://localhost:3000 by signing up with your email and password.



  Prowler CLI is available as a project in [PyPI](https://pypi.org/project/prowler-cloud/), thus can be installed using pip with Python >= 3.9, < 3.13:

  ```console
  pip install prowler
  prowler -v
  ```
  >More details at [https://docs.prowler.com](https://docs.prowler.com/projects/prowler-open-source/en/latest/#prowler-cli-installation)



  The available versions of Prowler CLI are the following:

  - `latest`: in sync with `master` branch (bear in mind that it is not a stable version)
  - `v4-latest`: in sync with `v4` branch (bear in mind that it is not a stable version)
  - `v3-latest`: in sync with `v3` branch (bear in mind that it is not a stable version)
  - `<x.y.z>` (release): you can find the releases [here](https://github.com/prowler-cloud/prowler/releases), those are stable releases.
  - `stable`: this tag always point to the latest release.
  - `v4-stable`: this tag always point to the latest release for v4.
  - `v3-stable`: this tag always point to the latest release for v3.

  The container images are available here:
  - Prowler CLI:
      - [DockerHub](https://hub.docker.com/r/toniblyx/prowler/tags)
      - [AWS Public ECR](https://gallery.ecr.aws/prowler-cloud/prowler)
  - Prowler App:
      - [DockerHub - Prowler UI](https://hub.docker.com/r/prowlercloud/prowler-ui/tags)
      - [DockerHub - Prowler API](https://hub.docker.com/r/prowlercloud/prowler-api/tags)



  Python >= 3.9, < 3.13 is required with pip and poetry:

  ``` console
  git clone https://github.com/prowler-cloud/prowler
  cd prowler
  poetry shell
  poetry install
  python prowler.py -v
  ```
  > If you want to clone Prowler from Windows, use `git config core.longpaths true` to allow long file paths.



  The **Prowler App** consists of three main components:

  - **Prowler UI**: A user-friendly web interface for running Prowler and viewing results, powered by Next.js.
  - **Prowler API**: The backend API that executes Prowler scans and stores the results, built with Django REST Framework.
  - **Prowler SDK**: A Python SDK that integrates with the Prowler CLI for advanced functionality.

  ![Prowler App Architecture](docs/img/prowler-app-architecture.png)


  You can run Prowler from your workstation, a Kubernetes Job, a Google Compute Engine, an Azure VM, an EC2 instance, Fargate or any other container, CloudShell and many more.

  ![Architecture](docs/img/architecture.png)




  - `Allowlist` now is called `Mutelist`.
  - The `--quiet` option has been deprecated, now use the `--status` flag to select the finding's status you want to get from PASS, FAIL or MANUAL.
  - All `INFO` finding's status has changed to `MANUAL`.
  - The CSV output format is common for all the providers.

  We have deprecated some of our outputs formats:
  - The native JSON is replaced for the JSON [OCSF](https://schema.ocsf.io/) v1.1.0, common for all the providers.


  - Deprecate the AWS flag --sts-endpoint-region since we use AWS STS regional tokens.
  - To send only FAILS to AWS Security Hub, now use either `--send-sh-only-fails` or `--security-hub --status FAIL`.




  Install, Usage, Tutorials and Developer Guide is at https://docs.prowler.com/



  Prowler is licensed as Apache License 2.0 as specified in each file. You may obtain a copy of the License at
  <http://www.apache.org/licenses/LICENSE-2.0>


pkgId: b2dddb92469a39fcd66a7b7f3f0e17b7a3e9eb7dd032b99542e708392e65c098
name: python-proxystore-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for proxystore
url: https://proxystore.dev
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-proxystore-0.8.0-1.src.rpm
location_href: Packages/python-proxystore-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/proxystore)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/proxystore)
  ![GitHub License](https://img.shields.io/github/license/proxystore/proxystore)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8077899.svg)](https://doi.org/10.5281/zenodo.8077899)

  [![docs](https://github.com/proxystore/proxystore/actions/workflows/docs.yml/badge.svg)](https://github.com/proxystore/proxystore/actions/workflows/docs.yml)
  [![tests](https://github.com/proxystore/proxystore/actions/workflows/tests.yml/badge.svg?label=tests)](https://github.com/proxystore/proxystore/actions)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/proxystore/proxystore/main.svg)](https://results.pre-commit.ci/latest/github/proxystore/proxystore/main)

  ProxyStore facilitates efficient data flow management in distributed Python applications, such as dynamic task-based workflows or serverless and edge applications.

  The [*transparent object proxy*](https://docs.proxystore.dev/latest/concepts/proxy/), the core building block within ProxyStore, acts like a wide-area reference that can be cheaply communicated.
  Unlike traditional references that are only valid within the virtual address space of a single process, the proxy references an object in remote storage and can be implicitly dereferenced in arbitrary processes—even on remote machines.
  The proxy is transparent in that it implicitly dereferences its target object when used—referred to a *just-in-time resolution*—and afterwards forwards all operations on itself to the cached target object.

  This paradigm results in the best of both pass-by-reference and pass-by-value semantics, improves performance and portability by reducing transfer overheads through intermediaries, and abstracts low-level communication methods which reduces code complexity.
  A proxy contains within itself all the information and logic necessary to resolve the target object.
  This self-contained nature means a proxy consumer need not be aware of the low-level communication mechanisms used by the proxy; rather, this is unilaterally determined by the producer of the proxy.

  ProxyStore supports a diverse set of programming patterns built on the proxy paradigm:

  * [Task-based Workflows](https://arxiv.org/abs/2303.08803)
  * [Function-as-a-Service/Serverless Applications](https://docs.proxystore.dev/latest/guides/globus-compute/)
  * [Distributed Futures](https://docs.proxystore.dev/latest/guides/proxy-futures/)
  * [Bulk Data Streaming](https://docs.proxystore.dev/latest/guides/streaming/)
  * and more!

  ProxyStore can leverage many popular mediated data transfer and storage systems:
  [DAOS](https://docs.daos.io/v2.4/),
  [Globus Transfer](https://www.globus.org/data-transfer),
  [Kafka](https://kafka.apache.org/),
  [KeyDB](https://docs.keydb.dev/), and
  [Redis](https://redis.io/).
  Custom communication methods built on
  [Mochi](https://mochi.readthedocs.io/en/latest/margo.html),
  [UCX](https://openucx.org/),
  [WebRTC](https://webrtc.org/), and
  [ZeroMQ](https://zeromq.org/)
  are provided for high-performance and peer-to-peer applications.

  Read more about ProxyStore's concepts [here](https://docs.proxystore.dev/latest/concepts/).
  Complete documentation for ProxyStore is available at
  [docs.proxystore.dev](https://docs.proxystore.dev).



  The base ProxyStore package can be installed with [`pip`](https://pip.pypa.io/en/stable/).
  ```bash
  pip install proxystore
  ```

  Leveraging third-party libraries may require dependencies not installed by default but can be enabled via extras installation options (e.g., `endpoints`, `kafka`, or `redis`).
  *All* additional dependencies can be installed with:
  ```bash
  pip install proxystore[all]
  ```
  This will also install the [`proxystore-ex`](https://extensions.proxystore.dev/)
  package which contains extensions and experimental features.
  The extensions package can also be installed with `pip` using
  `proxystore[extensions]` or `proxystore-ex`.

  See the [Installation](https://docs.proxystore.dev/latest/installation) guide
  for more information about the available extras installation options.
  See the [Contributing](https://docs.proxystore.dev/latest/contributing) guide
  to get started for local development.



  Using ProxyStore to store and transfer objects only requires a few lines of code.

  ```python
  from proxystore.connectors.redis import RedisConnector
  from proxystore.proxy import Proxy
  from proxystore.store import Store

  data = MyDataType(...)

  def my_function(x: MyDataType) -> ...:
      
      
      
      assert isinstance(x, MyDataType)

  with Store(
      'example',
      connector=RedisConnector('localhost', 6379),
      register=True,
  ) as store:
      
      
      proxy = store.proxy(data)
      assert isinstance(proxy, Proxy)

      
      my_function(proxy)
  ```

  Check out the [Get Started](https://docs.proxystore.dev/latest/get-started)
  guide to learn more!



  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8077899.svg)](https://doi.org/10.5281/zenodo.8077899)

  If you use ProxyStore or any of this code in your work, please cite our ProxyStore ([SC '23](https://dl.acm.org/doi/10.1145/3581784.3607047)) and Proxy Patterns ([arXiv preprint](https://arxiv.org/abs/2407.01764)) papers.
  ```bib
  @inproceedings{pauloski2023proxystore,
      author = {Pauloski, J. Gregory and Hayot-Sasson, Valerie and Ward, Logan and Hudson, Nathaniel and Sabino, Charlie and Baughman, Matt and Chard, Kyle and Foster, Ian},
      title = {{Accelerating Communications in Federated Applications with Transparent Object Proxies}},
      address = {New York, NY, USA},
      articleno = {59},
      booktitle = {Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis},
      doi = {10.1145/3581784.3607047},
      isbn = {9798400701092},
      location = {Denver, CO, USA},
      numpages = {15},
      publisher = {Association for Computing Machinery},
      series = {SC '23},
      url = {https://doi.org/10.1145/3581784.3607047},
      year = {2023}
  }

  @misc{pauloski2024proxystore,
      author = {J. Gregory Pauloski and Valerie Hayot-Sasson and Logan Ward and Alexander Brace and André Bauer and Kyle Chard and Ian Foster},
      title = {{Object Proxy Patterns for Accelerating Distributed Applications}},
      archiveprefix = {arXiv},
      eprint = {2407.01764},
      primaryclass = {cs.DC},
      url = {https://arxiv.org/abs/2407.01764},
      year = {2024}
  }
  ```


pkgId: 82b9a23789546859990b17e7e3f5c4a80bf910f497b844cdd838b8c2d0ad996d
name: python-prune-envs-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for prune-envs
url: https://github.com/davidfokkema/prune-envs
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prune-envs-1.1.0-1.src.rpm
location_href: Packages/python-prune-envs-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  If you're a heavy user of conda environments there inevitably comes a time that you want to clean things up. Of course, you can use:
  ```
  $ conda env remove -n my_old_env
  ```
  for each and every environment you have lying around. You can also find out where your environments live and manually remove their folders.

  Now, there is another way, using a TUI!

  ![Screenshot of the terminal user interface](https://raw.githubusercontent.com/davidfokkema/prune-envs/main/pruneenvironments_screenshot.svg)




  You can install the application using `pipx`:
  ```
  $ pipx install prune-envs
  ```
  Of course, you can also use plain old `pip`. Start the application by typing:
  ```
  $ prune-envs
  ```
  Simply select an environment using the mouse or arrow keys and press 'D' to delete!


pkgId: 444cc6053eb7a664f28a42233c28db9ca85aee8fa570520631ef5b0863e562ba
name: python-pshnb-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for pshnb
url: https://github.com/answerdotai/pshnb
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pshnb-0.0.2-1.src.rpm
location_href: Packages/python-pshnb-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

  `pshnb` adds `%psh` and `%psh` functions to Jupyter and IPython, which
  execute expressions in a persistent shell.



  Install pshnb with:

      pip install pshnb

  Once that’s complete, you can install the magics to all IPython and
  Jupyter sessions automatically by running in your terminal:

      pshnb_install



  In jupyter and ipython, you can run a shell command using the `!`
  prefix:

  ``` python
  !pwd
  ```

      /Users/jhoward/Documents/GitHub/pshnb

  However, each time you run this command, a new shell is created and then
  removed, so for instance, `cd` doesn’t actually do anything if you run
  another command afterwards:

  ``` python
  !cd ..
  !pwd
  ```

      /Users/jhoward/Documents/GitHub/pshnb

  As you see from the `!pwd` output, the directory hasn’t actually
  changed!

  `%psh`, on the other hand, creates a *persistent* shell, which solves
  this problem:

  ``` python
  %psh pwd
  ```

      /Users/jhoward/Documents/GitHub/pshnb

  ``` python
  %psh cd ..
  %psh pwd
  ```

      /Users/jhoward/Documents/GitHub

  With `%psh`, you can implement, and document in notebooks, multi-step
  stateful shell interactions, including setting environment variables,
  sourcing scripts, and changing directories.





  You can use the `%psh` cell magic to run multi-line shell commands,
  such as here-docs. For instance:

  ``` python
  %psh
  cat > tmp << EOF
  hi
  there
  EOF
  ```

  This creates a file called `tmp` containing two lines. Let’s check it
  worked, and then remove it – as you see, you can also use the cell magic
  to run multiple commands:

  ``` python
  %psh
  cat tmp
  rm tmp
  ```

      hi
      there



  You can pipe commands together just like in a regular shell, and use
  standard unix utilities like `head` to process the output. For instance,
  here we show just the first 3 lines of the directory listing:

  ``` python
  %psh ls | head -3
  ```

  You can use Python variables in your shell commands by prefixing them
  with `@{}`. For instance, here we create a variable `n` and then display
  it using `echo`:

  ``` python
  n = 2
  ```

  ``` python
  %psh echo @{n}
  ```

      2

  Here we use `n` to show just the first two entries from the directory
  listing:

  ``` python
  %psh ls | head -@{n}
  ```

      ContextKit
      FastHTML-Gallery



  You can run commands in the background in the shell by adding `&` at the
  end of a command. The parentheses `(...)` group commands together to run
  as one unit. In this example, we first print “starting”, and then create
  a background process that will wait for 1 second (using `sleep 1`) and
  then print “finished”. The shell immediately shows us “starting” and
  tells us it created background process number 1 (with a process ID):

  ``` python
  %psh
  echo starting
  (sleep 1; echo finished) &
  ```

      starting
      [1] 99418

  For this demonstration, we wait for 1.1 seconds (slightly longer than
  the background process needs). During this time, the background process
  will complete in the background. But we won’t see any output from it
  yet.

  ``` python
  from time import sleep
  sleep(1.1)
  ```

  The next time we run *any* `psh` magic we will also see any output that
  has occurred in our persistent shell since the last command. Run `%psh`
  by itself to *only* see those updates, e.g here we see that “finished”
  was printed, and the shell tells us that background job 1 completed
  successfully.

  ``` python
  %psh
  ```

      finished

      [1]+  Done                    ( sleep 1; echo finished )



  You can get help on the `%psh` magic’s options using `-h`.

  ``` python
  %psh -h
  ```

      ::

        %psh [-h] [-r] [-o] [-x] [-X] [-s] [-S] [-t TIMEOUT] [command ...]

      Run line or cell in persistent shell

      positional arguments:
        command               The command to run

      options:
        -h, --help            Show this help
        -r, --reset           Reset the shell interpreter
        -o, --obj             Return this magic object
        -x, --expand          Enable variable expansion
        -X, --no-expand       Disable variable expansion
        -s, --sudo            Enable sudo
        -S, --no-sudo         Disable sudo
        -t TIMEOUT, --timeout TIMEOUT
                              Set timeout in seconds

  You can reset the shell to its initial state using the `-r` flag. Let’s
  first check our current directory:

  ``` python
  %psh pwd
  ```

      /Users/jhoward/Documents/GitHub

  Now let’s reset the shell:

  ``` python
  %psh -r
  ```

  As you can see, after resetting we’re back in our starting directory:

  ``` python
  %psh pwd
  ```

      /Users/jhoward/Documents/GitHub/pshnb

  The `-s` flag enables `sudo` mode, which runs commands as the root user,
  and `-S` disables it. For instance, here we first enable `sudo` mode:

  ``` python
  %psh -s
  ```

  Then we can check which user we’re running as:

  ``` python
  %psh whoami
  ```

      root

  As you can see, we’re now running as `root`. We can disable `sudo` mode:

  ``` python
  %psh -S
  ```

  And when we check again, we’re back to our regular user:

  ``` python
  %psh whoami
  ```

      jhoward

  You can set a timeout (in seconds) using the `-t` flag, which will raise
  a `TIMEOUT` exception if a command takes too long. For instance, here we
  set a 1-second timeout:

  ``` python
  %psh -t 1
  ```

  Then we try to run a command that sleeps for 2 seconds – since this is
  longer than our timeout, we’ll get a timeout error:

  ``` python
  try: get_ipython().run_line_magic('psh', 'sleep 2')
  except TIMEOUT: print("timed out")
  ```


pkgId: d88f9bfc2855b768deb2300800be42e5c8980280e83fb27b49d82774fd57a0e4
name: python-psl-help
arch: noarch
version: 2024.12.16
epoch: 0
release: 1
summary: Development documents and examples for psl
url: https://github.com/sethmlarson/psl
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-psl-2024.12.16-1.src.rpm
location_href: Packages/python-psl-help-2024.12.16-1.noarch.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/psl)](https://pypi.org/project/psl)
  [![Downloads](https://pepy.tech/badge/psl)](https://pepy.tech/project/psl)
  ![CI](https://img.shields.io/github/workflow/status/sethmlarson/psl/CI/master)

  Mozilla Public Suffix list as a Python package and updated daily.

  Install via `python -m pip install psl`

  See https://publicsuffix.org for more information regarding the list itself.



  The package provides the following members as an API:



  ```python
  def domain_suffixes(dn: str, *, icann_only: bool=False) -> Suffixes: ...
  ```

  Queries the Public Suffix list for the given domain and returns a named tuple containing
  the public and private suffixes for the domain.  Either value can be `None` if that
  field isn't available. (eg `private=None` for the domain `com`)



  ```python
  def domain_can_set_cookie(*, http_domain: str, cookie_domain: str) -> bool: ...
  ```

  Determines if a user-agent that receives an HTTP response from domain `<http_domain>`
  with `Set-Cookie` headers with parameter `Domain=<cookie_domain>` should allow
  that cookie to be set.  This disallows cookies from being set on public suffixes
  and on domains that the HTTP domain has no authority over.

  This is the same mechanism that modern browsers use to determine whether it's safe
  to set a cookie to prevent 'super-cookies'.



  MPL-2.0


pkgId: 921c24cb416d1dd06ba2859331173530dbf3f631178b673e3588aad28676715f
name: python-pspdfutils-help
arch: noarch
version: 3.3.7
epoch: 0
release: 1
summary: Development documents and examples for pspdfutils
url: https://pypi.org/project/pspdfutils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pspdfutils-3.3.7-1.src.rpm
location_href: Packages/python-pspdfutils-help-3.3.7-1.noarch.rpm
checksum_type: sha256
description:
  This package has been renamed. Use `pip install psutils` instead.

  New package: https://pypi.org/project/psutils/


pkgId: fb5defcc948cd0717daa15f85b8abd5198978db0ff4e5549084b688569e7d220
name: python-psplpy-help
arch: noarch
version: 1.26.0
epoch: 0
release: 1
summary: Development documents and examples for psplpy
url: https://pypi.org/project/psplpy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-psplpy-1.26.0-1.src.rpm
location_href: Packages/python-psplpy-help-1.26.0-1.noarch.rpm
checksum_type: sha256
description:
  The **P**ersonal **S**tudy **P**urposes **L**ibrary of **PY**thon.

  It's only a python library for personal study purposes.


pkgId: aa2650263cd9140cf42f4eb3945724db8dc740b566d0ed55dfa7bb5872725ddb
name: python-psutil-debuginfo
arch: aarch64
version: 6.1.1
epoch: 0
release: 1
summary: Debug information for package python-psutil
url: https://github.com/giampaolo/psutil
rpm_license: BSD-3-Clause
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-psutil-6.1.1-1.src.rpm
location_href: Packages/python-psutil-debuginfo-6.1.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-psutil.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: a4e660bf48a390a8831f4b8299ec0edb486f81b06029b69e604fb2d4143ceb46
name: python-psutil-debugsource
arch: aarch64
version: 6.1.1
epoch: 0
release: 1
summary: Debug sources for package python-psutil
url: https://github.com/giampaolo/psutil
rpm_license: BSD-3-Clause
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-psutil-6.1.1-1.src.rpm
location_href: Packages/python-psutil-debugsource-6.1.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-psutil.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 70d3c0d0d92a3a4edb9f142b1b6f4f4aac06818eff357c63e6ea9736ec93c9c1
name: python-psychopy-bids-help
arch: noarch
version: 2024.2.0
epoch: 0
release: 1
summary: Development documents and examples for psychopy-bids
url: https://pypi.org/project/psychopy-bids/
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-psychopy-bids-2024.2.0-1.src.rpm
location_href: Packages/python-psychopy-bids-help-2024.2.0-1.noarch.rpm
checksum_type: sha256
description:
  A [PsychoPy](https://www.psychopy.org/) plugin to work with the [Brain Imaging Data Structure (BIDS)](https://bids-specification.readthedocs.io/)

  * **Website:** [https://psygraz.gitlab.io/psychopy-bids](https://psygraz.gitlab.io/psychopy-bids)
  * **Documentation:** [https://psychopy-bids.readthedocs.io](https://psychopy-bids.readthedocs.io)
  * **Source code:** [https://gitlab.com/psygraz/psychopy-bids](https://gitlab.com/psygraz/psychopy-bids)
  * **Contributing:** [https://psychopy-bids.readthedocs.io/en/latest/contributing](https://psychopy-bids.readthedocs.io/en/latest/contributing)
  * **Bug reports:** [https://gitlab.com/psygraz/psychopy-bids/issues](https://gitlab.com/psygraz/psychopy-bids/issues)
  * **Code of Conduct:** [https://psychopy-bids.readthedocs.io/en/latest/conduct](https://psychopy-bids.readthedocs.io/en/latest/conduct)



  We recommend installation in a virtual environment.

  ```console
  pip install psychopy-bids
  ```



  The psychopy bids plugin can be used to create valid BIDS valid datasets by creating [behavioral](https://bids-specification.readthedocs.io/en/stable/modality-specific-files/behavioral-experiments.html#example-_behtsv) or [task events](https://bids-specification.readthedocs.io/en/stable/04-modality-specific-files/05-task-events.html) in Psychopy. This can be done directly in python code or using the psychopy builder.

  In code, the *BIDSHandler* can create or extend an existing BIDS dataset, including directory structure and necessary metadata files. Individual BIDS events can be added during the experiment and are passed to the *BIDSHandler* to write event `.tsv` files and accompanying `.json` files.

  ```py
  from psychopy_bids import bids

  handler = bids.BIDSHandler(dataset="example_dataset", subject="01", task="A")
  handler.createDataset()

  events = [
      bids.BIDSTaskEvent(onset=1.0, duration=0.5, event_type="stimulus", response="correct"),
      bids.BIDSTaskEvent(onset=1.0, duration=0, trial_type="trigger")
  ]

  for event in events:
      handler.addEvent(event)

  participant_info = {"participant_id": handler.subject, "age": 18}

  handler.writeTaskEvents(participant_info=participant_info)

  handler.addStimuliFolder(event_file="example_dataset/sub-01/beh/sub-01_task-A_run-1_events.tsv")
  handler.addEnvironment()
  handler.addTaskCode()
  ```



  Interested in contributing? Check out the [contributing guidelines](https://psychopy-bids.readthedocs.io/en/latest/contributing/). Please note that this project is released with a [Code of Conduct](https://psychopy-bids.readthedocs.io/en/latest/conduct/). By contributing to this project, you agree to abide by its terms.



  `psychopy-bids` was created by Christoph Anzengruber & Florian Schöngaßner. It is licensed under the terms of the GNU General Public License v3.0 license.



  `psychopy-bids` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).


pkgId: 72db4c76e068f787b9d956646860e6a5d59e4efdfa2e18f34fdbe4581c5fbb59
name: python-psychopy-cedrus-help
arch: noarch
version: 0.0.10
epoch: 0
release: 1
summary: Development documents and examples for psychopy-cedrus
url: https://pypi.org/project/psychopy-cedrus/
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-psychopy-cedrus-0.0.10-1.src.rpm
location_href: Packages/python-psychopy-cedrus-help-0.0.10-1.noarch.rpm
checksum_type: sha256
description:
  Extension package for PsychoPy which adds support for various hardware devices by the
  [Cedrus Corporation](https://cedrus.com/index.htm).



  Installing this package alongside PsychoPy will enable support for the following devices:

  * RB730 Response Pads



  Install this package with the following shell command::

      pip install psychopy-cedrus

  You may also use PsychoPy's builtin package manager to install this package.



  Once the package is installed, PsychoPy will automatically load it when started and make objects available within the
  `psychopy.hardware.cedrus` namespace.


pkgId: b0ed0fa1ac3e857dd23a65ec77619aaf5c98c15815e75b6ad006f00d48bb7e04
name: python-ptfa-help
arch: noarch
version: 0.2.11
epoch: 0
release: 1
summary: Development documents and examples for ptfa
url: https://github.com/smonto2/PTFA
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ptfa-0.2.11-1.src.rpm
location_href: Packages/python-ptfa-help-0.2.11-1.noarch.rpm
checksum_type: sha256
description:
  `ptfa` provides an implementation of Probabilistic Targeted Factor Analysis, a probabilistic extension of Partial Least Squares (PLS) designed to extract latent factors from features $(X)$ to optimally predict a set of pre-specified target variables $(Y)$. It leverages an Expectation-Maximization (EM) algorithm for robust parameter estimation, accommodating challenges such as missing data, stochastic volatility, and dynamic factors.

  The framework balances flexibility and efficiency, providing an alternative to traditional methods like Principal Component Analysis (PCA) and standard PLS by incorporating probabilistic foundations.



  - Joint estimation of latent factors and parameters.
  - Robust against noise, missing data, and model uncertainty.
  - Extensible to stochastic volatility, mixed-frequency data and dynamic factor models.
  - Competitive performance in high-dimensional forecasting tasks.



  You can install `ptfa` from PyPI:

  ```bash
  pip install ptfa
  ```



  The `ptfa` module includes several classes aimed at implementing PTFA in a variety of real-world data settings:
  - `ProbabilisticTFA`: main workhorse class providing factor extraction from features `X` to predict targets `Y` by extracting `n_components` number of common latent factors.
  - `ProbabilisticTFA_MixedFrequency`: adapts to situations where natural measurement frequency of `X` is larger than `Y` (e.g., using monthly information to predict quarterly variables).
  - `ProbabilisticTFA_StochasticVolatility`: adapts main class to deal with stochastic volatility (variance changing with time) in features and targets.
  - `ProbabilisticTFA_DynamicFactors`: when factors can exhibit time-series persistence, we fit a vector autoregressive of order 1 (VAR-1) process on the latent factors.

  All classes have the following methods in common:
  - `__init__(self, n_components)`: creates the class instance with specified number of latent components.
  - `fit(self, X, Y, ...)`: fits the PTFA model to the given data using a tailored EM algorithm for each class and extracts latent factors.
  - `fitted(self, ...)`: computes the in-sample fitted values for the targets.
  - `predict(self, X)`: out-of-sample predicted values of targets using new features `X`.

  In addition, each class comes equipped with specific functions to handle the respective data-generating processes. More details on the routines and the additional arguments `...` each command can take can be found in the documentation for each class in the [GitHub repository](https://github.com/smonto2/PTFA/tree/main/src/ptfa/)).

  Finally, all classes can handle missing-at-random data in the form of [`numpy.nan` entries](https://numpy.org/doc/stable/reference/constants.html#numpy.nan) in the data arrays `X` and `Y`. Alternatively, these arrays can be directly passed as [`numpy.MaskedArray` objects](https://numpy.org/doc/stable/reference/maskedarray.html#masked-arrays).



  A large example showcasing the capabilities of PTFA is provided in the package repository: [Example Notebook](https://github.com/smonto2/PTFA/blob/main/example.ipynb).

  Here is a quick example of how to use the main class for factor extraction and forecasting, called `ProbabilisticTFA`:

  ```python
  import numpy as np
  from ptfa import ProbabilisticTFA


  X = np.random.rand(100, 10)  # 100 observations, 10 predictors
  Y = np.random.rand(100, 2)   # 100 observations, 2 targets


  model = ProbabilisticTFA(n_components=3)


  model.fit(X, Y)


  Y_fitted = model.fitted()


  X = np.random.rand(100, 10)
  Y_predicted = model.predict(X)

  print("Fitted targets:")
  print(Y_fitted)

  print("Predicted targets:")
  print(Y_predicted)



  print("Recovered factors:")
  print(model.factors)
  ```



  Feel free to open issues or contribute to the repository through pull requests. We welcome suggestions and improvements to the package!


  If you use `ptfa` we would appreciate if you cite our work as:
  ```bibtex
  @misc{herculano_2024_probabilistic,
        title         = {Probabilistic Targeted Factor Analysis},
        author        = {Herculano, Miguel C. and Montoya-Blandón, Santiago},
        year          = {2024},
        eprint        = {2412.06688},
        archivePrefix = {arXiv},
        primaryClass  = {econ.EM},
        url           = {https://arxiv.org/abs/2412.06688},
  }
  ```



  This project is licensed under the MIT License.


pkgId: 0b75b2276601db5253ee7623541ca4ca9f35f2ab930fd7818111d8cd5ae27942
name: python-pthost-help
arch: noarch
version: 1.0.5
epoch: 0
release: 1
summary: Development documents and examples for pthost
url: https://www.penterep.com/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pthost-1.0.5-1.src.rpm
location_href: Packages/python-pthost-help-1.0.5-1.noarch.rpm
checksum_type: sha256
description:
  [![penterepTools](https://www.penterep.com/external/penterepToolsLogo.png)](https://www.penterep.com/)





  ```
  pip install pthost
  ```


  If you're unable to invoke the script from your terminal, it's likely because it's not included in your PATH. You can resolve this issue by executing the following commands, depending on the shell you're using:

  For Bash Users
  ```bash
  echo "export PATH=\"`python3 -m site --user-base`/bin:\$PATH\"" >> ~/.bashrc
  source ~/.bashrc
  ```

  For ZSH Users
  ```bash
  echo "export PATH=\"`python3 -m site --user-base`/bin:\$PATH\"" >> ~/.zshrc
  source ~/.zshrc
  ```



  ```
  pthost -d https://www.example.com/
  pthost -d www.example.com
  ```




  ```
  -d   --domain      <domain>                      Test Domain
  -t   --test        <test-types>                  Specify tests to perform (default all)
                      default-vhost                Test Default vhost
                      open-redirect                Test Open Redirect
                      crlf                         Test CRLF injection
                      host-injection               Test Host injection
                      redir-to-https               Test HTTP to HTTPS redirects
                      seo-fragmentation            Test SEO fragmentation
                      subdomain-reflection-www     Test Subdomain reflection (with www)
                      subdomain-reflection-no-www  Test Subdomain reflection (without www)

  -H   --headers     <header:value>                Set custom headers
  -T   --timeout     <timeout>                     Set timeout (default 7s)
  -ua  --user-agent  <user-agent>                  Set user agent
  -c   --cookie      <cookie=value>                Set cookie(s)
  -p   --proxy       <proxy>                       Set proxy (e.g. http://127.0.0.1:8080)
  -P   --protocol    <protocol>                    Set protocol to test (HTTP, HTTPS), default both
  -C   --cache                                     Cache requests (load from tmp in future)
  -v   --version                                   Show script version and exit
  -h   --help                                      Show this help message and exit
  -j   --json                                      Output in JSON format

  ```



  ```
  ptlibs
  validators
  tldextract
  ```




  Copyright (c) 2024 Penterep Security s.r.o.

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

  pthost is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

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



  You are only allowed to run the tool against the websites which
  you have been given permission to pentest. We do not accept any
  responsibility for any damage/harm that this application causes to your
  computer, or your network. Penterep is not responsible for any illegal
  or malicious use of this code. Be Ethical!


pkgId: a3271c73d36f583e42b185fe191cbe45c2e4fa5c6cb8077a405a1d28a40ad230
name: python-ptresheaders-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for ptresheaders
url: https://www.penterep.com/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ptresheaders-0.0.7-1.src.rpm
location_href: Packages/python-ptresheaders-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  [![penterepTools](https://www.penterep.com/external/penterepToolsLogo.png)](https://www.penterep.com/)




  ptresheaders is an automated tool that efficiently analyzes and tests HTTP response headers for security best practices and compliance with industry standards.



  ```
  pip install ptresheaders
  ```


  If you're unable to invoke the script from your terminal, it's likely because it's not included in your PATH. You can resolve this issue by executing the following commands, depending on the shell you're using:

  For Bash Users
  ```bash
  echo "export PATH=\"`python3 -m site --user-base`/bin:\$PATH\"" >> ~/.bashrc
  source ~/.bashrc
  ```

  For ZSH Users
  ```bash
  echo "export PATH=\"`python3 -m site --user-base`/bin:\$PATH\"" >> ~/.zshrc
  source ~/.zshrc
  ```


  ```
  ptresheaders -u https://www.example.com
  ptresheaders -u https://www.example.com --proxy 127.0.0.1:8080
  ```


  ```
  -u   --url           <url>           Connect to URL
  -p   --proxy         <proxy>         Set proxy
  -c   --cookie        <cookie>        Set cookie
  -H   --headers       <header:value>  Set headers
  -a   --user-agent    <agent>         Set User-Agent
  -T   --timeout                       Set timeout
  -m   --method                        Set method (default GET)
  -r   --redirects                     Follow redirects
  -C   --cache                         Enable HTTP cache
  -j   --json                          Enable JSON output
  -v   --version                       Show script version and exit
  -h   --help                          Show this help message and exit
  ```


  ```
  ptlibs
  ptcookiechecker
  bs4
  lxml
  ```



  Copyright (c) 2024 Penterep Security s.r.o.

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

  ptresheaders is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

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



  You are only allowed to run the tool against the websites which
  you have been given permission to pentest. We do not accept any
  responsibility for any damage/harm that this application causes to your
  computer, or your network. Penterep is not responsible for any illegal
  or malicious use of this code. Be Ethical!


pkgId: 18e7d75cf35e4f9b2d4a909eb7bffa5712000fcb43259590a9083c56a66b8b88
name: python-publicsuffixlist-help
arch: noarch
version: 1.0.2.20241216
epoch: 0
release: 1
summary: Development documents and examples for publicsuffixlist
url: https://github.com/ko-zu/psl
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-publicsuffixlist-1.0.2.20241216-1.src.rpm
location_href: Packages/python-publicsuffixlist-help-1.0.2.20241216-1.noarch.rpm
checksum_type: sha256
description:
  [Public Suffix List](https://publicsuffix.org/) parser implementation for
  Python 3.5+.
  - Compliant with [TEST DATA](https://raw.githubusercontent.com/publicsuffix/list/master/tests/test_psl.txt)
  - Supports IDN (unicode and punycoded).
  - Supports Python3.5+
  - Shipped with built-in PSL and an updater script.
  - Written in Pure Python with no library dependencies.
  [![publish package](https://github.com/ko-zu/psl/actions/workflows/autorelease.yml/badge.svg?branch=master)](https://github.com/ko-zu/psl/actions/workflows/autorelease.yml)
  [![CI test](https://github.com/ko-zu/psl/actions/workflows/citest.yml/badge.svg?branch=devel)](https://github.com/ko-zu/psl/actions/workflows/citest.yml)
  [![PyPI version](https://badge.fury.io/py/publicsuffixlist.svg)](https://badge.fury.io/py/publicsuffixlist)
  [![Downloads](http://pepy.tech/badge/publicsuffixlist)](http://pepy.tech/project/publicsuffixlist)


pkgId: 81b829c6032a3c2018442e82015f762301a8a226d8760618e10f0a73177a4247
name: python-pubpypack-harmony-ricardo-zambrano-debuginfo
arch: aarch64
version: 0.0.5
epoch: 0
release: 1
summary: Debug information for package python-pubpypack-harmony-ricardo-zambrano
url: https://github.com/rzambrano1/first-python-package
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-pubpypack-harmony-ricardo-zambrano-0.0.5-1.src.rpm
location_href: Packages/python-pubpypack-harmony-ricardo-zambrano-debuginfo-0.0.5-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pubpypack-harmony-ricardo-zambrano.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 3dbbdb1debbea2c1274dc843098271aac9498c50ce3eec8cbad6fa31053245f8
name: python-pubpypack-harmony-ricardo-zambrano-debugsource
arch: aarch64
version: 0.0.5
epoch: 0
release: 1
summary: Debug sources for package python-pubpypack-harmony-ricardo-zambrano
url: https://github.com/rzambrano1/first-python-package
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-pubpypack-harmony-ricardo-zambrano-0.0.5-1.src.rpm
location_href: Packages/python-pubpypack-harmony-ricardo-zambrano-debugsource-0.0.5-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pubpypack-harmony-ricardo-zambrano.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 6214a5533dda5d1bbb0967dfe26a2a620dc22aa4b22ce4b8be096ca71e1c2fa9
name: python-pubtools-marketplacesvm-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for pubtools-marketplacesvm
url: https://github.com/release-engineering/pubtools-marketplacesvm
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pubtools-marketplacesvm-1.6.0-1.src.rpm
location_href: Packages/python-pubtools-marketplacesvm-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  A command-line interface to publish various Virtual Machine Images to different cloud marketplaces,
  used by [release-engineering](https://github.com/release-engineering) publishing tools.

  [![PyPI version](https://badge.fury.io/py/pubtools-marketplacesvm.svg)](https://badge.fury.io/py/pubtools-marketplacesvm)

  - [Source](https://github.com/release-engineering/pubtools-marketplacesvm)
  - [Documentation](https://release-engineering.github.io/pubtools-marketplacesvm/)




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


pkgId: 669069da773f0597fada7af5061dfada719eba169ea3eecfc01da63c24a6ed05
name: python-pulumi-aiven-help
arch: noarch
version: 6.29.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-aiven
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-aiven-6.29.0-1.src.rpm
location_href: Packages/python-pulumi-aiven-help-6.29.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-aiven/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-aiven/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Faiven.svg)](https://www.npmjs.com/package/@pulumi/aiven)
  [![Python version](https://badge.fury.io/py/pulumi-aiven.svg)](https://pypi.org/project/pulumi-aiven)
  [![NuGet version](https://badge.fury.io/nu/pulumi.aiven.svg)](https://badge.fury.io/nu/pulumi.aiven)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-aiven/sdk/v5/go)](https://pkg.go.dev/github.com/pulumi/pulumi-aiven/sdk/v5/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-aiven/blob/master/LICENSE)



  The Aiven resource provider for Pulumi lets you manage Aiven resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/aiven

  or `yarn`:

      $ yarn add @pulumi/aiven



  To use from Python, install using `pip`:

      $ pip install pulumi_aiven



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-aiven/sdk/v5



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Aiven



  The following configuration points are available:

  - `aiven:apiToken` - (Optional) This is the API token to interact with your Aiven account. May be set via the `AIVEN_TOKEN` environment variable.



  For further information, please visit [the Aiven provider docs](https://www.pulumi.com/docs/intro/cloud-providers/aiven) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/aiven).


pkgId: df4fdae9c57093c93426cb524564cdfa410b257214cb752570c41ab8dea090ff
name: python-pulumi-akamai-help
arch: noarch
version: 7.6.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-akamai
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-akamai-7.6.0-1.src.rpm
location_href: Packages/python-pulumi-akamai-help-7.6.0-1.noarch.rpm
checksum_type: sha256
description:
  The Akamai Resource Provider lets you manage Akamai resources.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/akamai

  or `yarn`:

      $ yarn add @pulumi/akamai



  To use from Python, install using `pip`:

      $ pip install pulumi_akamai



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-akamai/sdk/v7



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Akamai



  The following configuration options are available

  * `akamai:edgerc` - (Optional) The location of the `.edgerc` file containing credentials. Default: `$HOME/.edgerc`.
  * `akamai:propertySection` - (Optional) The credential section to use for the Property Manager API (PAPI). Default `default`.
  * `akamai:dnsSection` - (Optional) The credential section to use for the Config DNS API. Default `default`.
  * `akamai:gtmSection` - (Optional) The credential section to use for the Config GTM API. Default `default`.

  You can also specify credential values using environment variables. Environment variables take precedence over the contents of the `.edgerc` file.

  Create environment variables in the format:

  `AKAMAI{_SECTION_NAME}_*`

  For example, if you specify `akamai:propertySection papi` you would set the following ENV variables:

  * AKAMAI_PAPI_HOST
  * AKAMAI_PAPI_ACCESS_TOKEN
  * AKAMAI_PAPI_CLIENT_TOKEN
  * AKAMAI_PAPI_CLIENT_SECRET
  * AKAMAI_PAPI_MAX_BODY (optional)

  If the section name is `default`, you can omit it, instead using:

  * AKAMAI_HOST
  * AKAMAI_ACCESS_TOKEN
  * AKAMAI_CLIENT_TOKEN
  * AKAMAI_CLIENT_SECRET
  * AKAMAI_MAX_BODY (optional)



  For further information, please visit [the Akamai provider docs](https://www.pulumi.com/docs/intro/cloud-providers/akamai)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/akamai).


pkgId: 8f309a70b522305f165a5152c6c645465c604246eb0d59a9efcaa7d46f48a91f
name: python-pulumi-alicloud-help
arch: noarch
version: 3.69.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-alicloud
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-alicloud-3.69.0-1.src.rpm
location_href: Packages/python-pulumi-alicloud-help-3.69.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-alicloud/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-alicloud/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Falicloud.svg)](https://www.npmjs.com/package/@pulumi/alicloud)
  [![Python version](https://badge.fury.io/py/pulumi-alicloud.svg)](https://pypi.org/project/pulumi-alicloud)
  [![NuGet version](https://badge.fury.io/nu/pulumi.alicloud.svg)](https://badge.fury.io/nu/pulumi.alicloud)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-alicloud/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-alicloud/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-alicloud/blob/master/LICENSE)



  The AliCloud resource provider for Pulumi lets you use AliCloud resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/alicloud

  or `yarn`:

      $ yarn add @pulumi/alicloud



  To use from Python, install using `pip`:

      $ pip install pulumi_alicloud



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-alicloud/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Alicloud



  The following configuration points are available:

  - `alicloud:accessKey` - (Required) This is the Alicloud access key. It must be provided, but it can also be sourced from
    the `ALICLOUD_ACCESS_KEY` environment variable.
  - `alicloud:secretKey` - (Required) This is the Alicloud secret key. It must be provided, but it can also be sourced from
    the `ALICLOUD_SECRET_KEY` environment variable.
  - `alicloud:securityToken` - (Optional) Alicloud Security Token Service. It can be sourced from the `ALICLOUD_SECURITY_TOKEN`
    environment variable.
  - `alicloud:ecsRoleName` - (Optional) The RAM Role Name attached on a ECS instance for API operations. You can retrieve
    this from the 'Access Control' section of the Alibaba Cloud console. It can be sourced from the `ALICLOUD_ECS_ROLE_NAME`
    environment variable.
  - `alicloud:region` - (Required) This is the Alicloud region. It must be provided, but it can also be sourced from the
    `ALICLOUD_REGION` environment variables.
  - `alicloud:accountId` - (Optional) Alibaba Cloud Account ID. It is used by the Function Compute service and to
    connect router interfaces. If not provided, the provider will attempt to retrieve it automatically with STS GetCallerIdentity.
    It can be sourced from the `ALICLOUD_ACCOUNT_ID` environment variable.
  - `alicloud:sharedCredentialsFile` - (Optional) This is the path to the shared credentials file. It can also be sourced
    from the `ALICLOUD_SHARED_CREDENTIALS_FILE` environment variable. If this is not set and a profile is specified,
    `~/.aliyun/config.json` will be used.
  - `alicloud:profile` - (Optional) This is the Alicloud profile name as set in the shared credentials file. It can also be
    sourced from the `ALICLOUD_PROFILE` environment variable.
  - `alicloud:skipRegionValidation` - (Optional) Skip static validation of region ID. Used by users of alternative
    AlibabaCloud-like APIs or users w/ access to regions that are not public (yet).




  For further information, please visit [the AliCloud provider docs](https://www.pulumi.com/docs/intro/cloud-providers/alicloud) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/alicloud).


pkgId: b8c0852df72cf9114d7b181f9fd2b3b5ff7f52c6e9619a7937f503c335e29895
name: python-pulumi-archive-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-archive
url: https://www.pulumi.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-archive-0.3.0-1.src.rpm
location_href: Packages/python-pulumi-archive-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-archive/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-archive/actions)
  [![NPM version](https://img.shields.io/npm/v/@pulumi/archive)](https://www.npmjs.com/package/@pulumi/archive)
  [![Python version](https://img.shields.io/pypi/v/pulumi_archive)](https://pypi.org/project/pulumi_archive)
  [![NuGet version](https://img.shields.io/nuget/v/Pulumi.Archive)](https://www.nuget.org/packages/Pulumi.Archive)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-archive/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-archive/sdk/go)
  [![License](https://img.shields.io/github/license/pulumi/pulumi-archive)](https://github.com/pulumi/pulumi-archive/blob/master/LICENSE)



  This provider is mainly used for ease of converting terraform programs to Pulumi.
  For standard use in Pulumi programs, please use your programming language's filesystem library.

  The Archive resource provider for Pulumi lets you use Archive resources in your cloud programs.
  To use this package, please [install the Pulumi CLI first](https://www.pulumi.com/docs/install/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/archive

  or `yarn`:

      $ yarn add @pulumi/archive



  To use from Python, install using `pip`:

      $ pip install pulumi_archive



  To use from Go, use `go get` to grab the latest version of the library:

      $ go get github.com/pulumi/pulumi-archive/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Archive

  <!-- If your provider has configuration, remove this comment and the comment tags below, updating the documentation. -->
  <!--



  The following Pulumi configuration can be used:

  - `archive:token` - (Required) The API token to use with Archive. When not set, the provider will use the `ARCHIVE_TOKEN` environment variable.

  -->

  <!-- If your provider has reference material available elsewhere, remove this comment and the comment tags below, updating the documentation. -->
  <!--



  For further information, please visit [Archive reference documentation](https://example.com/archive).

  -->


pkgId: 4650e6ad47733ad8b41c95a467a8626cc04365f61e0280822b8f3e0c078cb491
name: python-pulumi-artifactory-help
arch: noarch
version: 8.4.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-artifactory
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-artifactory-8.4.1-1.src.rpm
location_href: Packages/python-pulumi-artifactory-help-8.4.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-artifactory/workflows/main/badge.svg)](https://github.com/pulumi/pulumi-artifactory/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fartifactory.svg)](https://www.npmjs.com/package/@pulumi/artifactory)
  [![Python version](https://badge.fury.io/py/pulumi-artifactory.svg)](https://pypi.org/project/pulumi-artifactory)
  [![NuGet version](https://badge.fury.io/nu/pulumi.artifactory.svg)](https://badge.fury.io/nu/pulumi.artifactory)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-artifactory/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-artifactory/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-artifactory/blob/main/LICENSE)



  The Artifactory Resource Provider lets you manage Artifactory resources.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/artifactory

  or `yarn`:

      $ yarn add @pulumi/artifactory



  To use from Python, install using `pip`:

      $ pip install pulumi_artifactory



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-artifactory/sdk/v8



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Artifactory



  The following configuration points are available:

  - `artifactory:url` - (Required) URL of Artifactory. This can also be sourced from the `ARTIFACTORY_URL` environment variable.
  - `artifactory:username` - (Optional) Username for basic auth. Requires password to be set. Conflicts with `apiKey`,
    and `accessToken`. This can also be sourced from the `ARTIFACTORY_USERNAME` environment variable.
  - `artifactory:password` - (Optional) Password for basic auth. Requires username to be set. Conflicts with `apiKey`,
    and `accessToken`. This can also be sourced from the `ARTIFACTORY_PASSWORD` environment variable.
  - `artifactory:apiKey` - (Optional) API key for api auth. Uses `X-JFrog-Art-Api` header. Conflicts with `username`,
    `password`, and `accessToken`. This can also be sourced from the `ARTIFACTORY_API_KEY` environment variable.
  - `artifactory:accessToken` - (Optional) API key for token auth. Uses `Authorization: Bearer` header. For xray
    functionality, this is the only auth method accepted. Conflicts with `username` and `password`, and `apiKey`. This can
    also be sourced from the `ARTIFACTORY_ACCESS_TOKEN` environment variable.



  For further information, please visit [the Artifactory provider docs](https://www.pulumi.com/docs/intro/cloud-providers/artifactory)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/artifactory).


pkgId: 5a528500b263c80985dd083165de0cbda49e7af6dfc03e5a50a632ea1473e517
name: python-pulumi-auth0-help
arch: noarch
version: 3.10.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-auth0
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-auth0-3.10.1-1.src.rpm
location_href: Packages/python-pulumi-auth0-help-3.10.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-auth0/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-auth0/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fauth0.svg)](https://www.npmjs.com/package/@pulumi/auth0)
  [![Python version](https://badge.fury.io/py/pulumi-auth0.svg)](https://pypi.org/project/pulumi-auth0)
  [![NuGet version](https://badge.fury.io/nu/pulumi.auth0.svg)](https://badge.fury.io/nu/pulumi.auth0)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-auth0/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-auth0/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-auth0/blob/master/LICENSE)



  The Auth0 Resource Provider lets you manage Auth0 resources.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/auth0

  or `yarn`:

      $ yarn add @pulumi/auth0



  To use from Python, install using `pip`:

      $ pip install pulumi_auth0



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-auth0/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Auth0



  The following configuration points are available:

  - `auth0:apiToken` - (Optional) Your Auth0 [management api access
    token](https://auth0.com/docs/security/tokens/access-tokens/management-api-access-tokens). It can also be
    sourced from the `AUTH0_API_TOKEN` environment variable. It can be used instead of `auth0:clientId` +
    `auth0:clientSecret`. If both are specified, `auth0:apiToken` will be used over `auth0:clientId` +
    `auth0:clientSecret` fields.
  - `auth0:audience` - (Optional) Your Auth0 audience when using a custom domain. It can also be sourced from
    the `AUTH0_AUDIENCE` environment variable.
  - `auth0:clientId` - (Optional) Your Auth0 client ID. It can also be sourced from the `AUTH0_CLIENT_ID`
    environment variable.
  - `auth0:clientSecret` - (Optional) Your Auth0 client secret. It can also be sourced from the
    `AUTH0_CLIENT_SECRET` environment variable.
  - `auth0:debug` - (Optional) Indicates whether to turn on debug mode.
  - `auth0:domain` - (Required) Your Auth0 domain name. It can also be sourced from the
    `AUTH0_DOMAIN` environment variable.



  For further information, please visit [the Auth0 provider docs](https://www.pulumi.com/docs/intro/cloud-providers/auth0) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/auth0).


pkgId: 97a32a614291cd0a866496557c48327612aa3800b6f96aac3c96f54234e32b61
name: python-pulumi-aws-help
arch: noarch
version: 6.64.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-aws
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-aws-6.64.0-1.src.rpm
location_href: Packages/python-pulumi-aws-help-6.64.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://www.pulumi.com?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=top-logo" title="Pulumi AWS Provider - Build and Deploy Infrastructure as Code Solutions on Any Cloud">
      <img src="https://www.pulumi.com/images/logo/logo-on-white-box.svg?" width="350">
    </a>
  </p>

  [![Actions Status](https://github.com/pulumi/pulumi-aws/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-aws/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Faws.svg)](https://www.npmjs.com/package/@pulumi/aws)
  [![Python version](https://badge.fury.io/py/pulumi-aws.svg)](https://pypi.org/project/pulumi-aws)
  [![NuGet version](https://badge.fury.io/nu/pulumi.aws.svg)](https://badge.fury.io/nu/pulumi.aws)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-aws/sdk/v6/go)](https://pkg.go.dev/github.com/pulumi/pulumi-aws/sdk/v6/go)
  [![License](https://img.shields.io/github/license/pulumi/pulumi-aws)](https://github.com/pulumi/pulumi-aws/blob/master/LICENSE)



  The Amazon Web Services (AWS) resource provider for Pulumi lets you use AWS resources in your cloud programs. To use
  this package, [install the Pulumi CLI](https://www.pulumi.com/docs/get-started/install/). For a streamlined Pulumi walkthrough, including language runtime installation and AWS configuration, select "Get Started" below.

  <div>
      <a href="https://www.pulumi.com/docs/get-started/aws/?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=get-started" title="Get Started">
         <img src="https://www.pulumi.com/images/get-started.svg?" width="120">
      </a>
  </div>



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/aws

  or `yarn`:

      $ yarn add @pulumi/aws



  To use from Python, install using `pip`:

      $ pip install pulumi_aws



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-aws/sdk/v6



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Aws



  The `@pulumi/aws` package provides a strongly-typed means to create cloud applications that create and interact closely
  with AWS resources.  Resources are exposed for the entirety of AWS resources and their properties, including (but not
  limited to), 'apigateway', 'cloudformation', 'EC2', 'ECS', 'iam', 'lambda', etc.  Many convenience APIs have also been
  added to make development easier and to help avoid common mistakes, and to get stronger typing.



  The `aws.lambda.CallbackFunction` class allows you to create an AWS lambda function directly out of a JavaScript/TypeScript
  function object of the right signature. This allows a Pulumi program to simply define a lambda using a simple lambda in
  the language of choice, while having Pulumi itself do the appropriate transformation into the final AWS Lambda resource.

  This makes many APIs easier to use, such as defining a Lambda to execute when an S3 Bucket is manipulated,
  or a CloudWatch timer is fired. To see some examples of this in action, please refer to the `examples/` directory.



  The following configuration points are available:

  - `aws:region` - (Required) This is the AWS region.

  - `aws:accessKey` - (Optional) This is the AWS access key. It can also be sourced from the
    `AWS_ACCESS_KEY_ID` environment variable, or via a shared credentials file if `aws:profile` is specified.
  - `aws:secretKey` - (Optional) This is the AWS secret key. It can also be sourced from the
    `AWS_SECRET_ACCESS_KEY` environment variable, or via a shared credentials file if `aws:profile` is specified.
  - `aws:profile` - (Optional) This is the AWS profile name as set in the shared credentials file.
  - `aws:sharedCredentialsFiles` - (Optional) List of paths to the shared credentials file. If not set and a profile
    is used, the default value is [~/.aws/credentials]. A single value can also be set with the
    `AWS_SHARED_CREDENTIALS_FILE` environment variable.
  - `aws:token` - (Optional) Session token for validating temporary credentials. Typically provided after successful
    identity federation or Multi-Factor Authentication (MFA) login. With MFA login, this is the session token provided
    afterward, not the 6 digit MFA code used to get temporary credentials. It can also be sourced from the
    `AWS_SESSION_TOKEN` environment variable.
  - `aws:maxRetries` - (Optional) This is the maximum number of times an API call is retried, in the case where requests
    are being throttled or experiencing transient failures. The delay between the subsequent API calls increases
    exponentially. If omitted, the default value is `25`.
  - `aws:allowedAccountIds` - (Optional)  List of allowed AWS account IDs to prevent you from mistakenly using an incorrect
    one. Conflicts with `aws:forbiddenAccountIds`.
  - `aws:endpoints` - (Optional) Configuration block for customizing service endpoints. See the Custom Service Endpoints Guide for more information about connecting to alternate AWS endpoints or AWS compatible solutions. See also `aws:useFipsEndpoint`.
  - `aws:forbiddenAccountIds` - (Optional) List of forbidden AWS account IDs to prevent you from mistakenly using the wrong
    one. Conflicts with `aws:allowedAccountIds`.
  - `aws:assumeRole` - (Optional) Supports the following (optional) arguments:
    `durationSections`: Number of seconds to restrict the assume role session duration.
    `externalId`: External identifier to use when assuming the role.
    `policy`: IAM Policy JSON describing further restricting permissions for the IAM Role being assumed.
    `policyArns`: Set of Amazon Resource Names (ARNs) of IAM Policies describing further restricting permissions for the role.
    `roleArn`: Amazon Resource Name (ARN) of the IAM Role to assume.
    `sessionName`: Session name to use when assuming the role.
    `tags`: Map of assume role session tags.
  - `aws:insecure` - (Optional) Explicitly allow the provider to perform "insecure" SSL requests. If omitted, the default value is `false`.
  - `aws:skipCredentialsValidation` - (Optional) Skip the credentials validation via the STS API. Useful for AWS API implementations that do not have STS available or implemented. Default value is `false`. Can be set via the environment variable `AWS_SKIP_CREDENTIALS_VALIDATION`.
  - `aws:skipRegionValidation` - (Optional) Skip validation of provided region name. Useful for AWS-like implementations that use their own region names or to bypass the validation for regions that aren't publicly available yet. Default value is `true`.
  - `aws:skipRequestionAccountId` - (Optional) Skip requesting the account ID. Useful for AWS API implementations that do not have the IAM, STS API, or metadata API. Default value is `false`. When specified, the use of ARNs is compromised as there is no accountID available to construct the ARN.
  - `aws:skipMetadataApiCheck` - (Optional) Skip the AWS Metadata API check. Useful for AWS API implementations that do not have a metadata API endpoint. This provider from authenticating via the Metadata API by default. You may need to use other authentication methods like static credentials, configuration variables, or environment variables. Can be set via the environment variable `AWS_SKIP_METADATA_API_CHECK`.
  - `aws:s3UsePathStyle` - (Optional) Set this to true to force the request to use path-style addressing, i.e., `http://s3.amazonaws.com/BUCKET/KEY`. By default, the S3 client will use virtual hosted bucket addressing, `http://BUCKET.s3.amazonaws.com/KEY`, when possible. Specific to the Amazon S3 service. Default is `false`.
  - `aws:useFipsEndpoint` - (Optional) Force the provider to resolve endpoints with FIPS capability. Can also be set with the `AWS_USE_FIPS_ENDPOINT` environment variable.



  For further information, visit [AWS in the Pulumi Registry](https://www.pulumi.com/registry/packages/aws/?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=reference)
  or for detailed API reference documentation, visit [AWS API Docs in the Pulumi Registry](https://www.pulumi.com/registry/packages/aws/api-docs/?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=reference).



  Delve deeper into our project with additional resources:

  - [Get Started with Pulumi](https://www.pulumi.com/docs/get-started/?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=examples-resources): Deploy a simple application in AWS, Azure, Google Cloud, or Kubernetes using Pulumi.
  - [Documentation](https://www.pulumi.com/docs/?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=examples-resources): Learn about Pulumi concepts, follow user guides, and consult the reference documentation.
  - [Pulumi Blog](https://www.pulumi.com/blog/?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=examples-resources) - Stay in the loop with our latest tech announcements, insightful articles, and updates.
  - [Registry](https://www.pulumi.com/registry/?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=examples-resources): Search for packages and learn about the supported resources you need. Install the package directly into your project, browse the API documentation, and start building.
  - [Try Pulumi AI](https://www.pulumi.com/ai/?utm_campaign=pulumi-pulumi-aws-github-repo&utm_source=github.com&utm_medium=examples-resources) - Use natural-language prompts to generate Pulumi infrastructure-as-code programs in any language.



  Review the planned work for the upcoming quarter and a selected backlog of issues that are on our mind but not yet scheduled on the [Pulumi Roadmap.](https://github.com/orgs/pulumi/projects/44)


pkgId: c4d4c8d01c73f3e156f3639ce2a9ae2ec35f76f657c90a90e2ecb7adbfcceafc
name: python-pulumi-aws-native-help
arch: noarch
version: 1.15.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-aws-native
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-aws-native-1.15.0-1.src.rpm
location_href: Packages/python-pulumi-aws-native-help-1.15.0-1.noarch.rpm
checksum_type: sha256
description:
  > [!NOTE]
  > This provider covers all resources as supported by the [AWS Cloud Control API](https://aws.amazon.com/cloudcontrolapi/). This does not yet include all AWS resources. See the [list of supported resources](https://github.com/pulumi/pulumi-aws-native/blob/master/provider/cmd/pulumi-gen-aws-native/supported-types.txt) for full details.


pkgId: 2e2001a7706235a3d44f4fd4f23ed98d955480b11989534d13e2b11ac1742de7
name: python-pulumi-awsx-help
arch: noarch
version: 2.19.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-awsx
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-awsx-2.19.0-1.src.rpm
location_href: Packages/python-pulumi-awsx-help-2.19.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-awsx/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-awsx/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fawsx.svg)](https://www.npmjs.com/package/@pulumi/awsx)
  [![Python version](https://badge.fury.io/py/pulumi-awsx.svg)](https://pypi.org/project/pulumi-awsx)
  [![NuGet version](https://badge.fury.io/nu/pulumi.awsx.svg)](https://badge.fury.io/nu/pulumi.awsx)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-awsx/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-awsx/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fawsx.svg)](https://github.com/pulumi/pulumi-awsx/blob/master/LICENSE)



  Pulumi's framework for Amazon Web Services (AWS) infrastructure.

  To use this package, [install the Pulumi CLI](https://www.pulumi.com/docs/get-started/install/). For a streamlined Pulumi walkthrough, including language runtime installation and AWS configuration, see the [Crosswalk for AWS documentation](https://www.pulumi.com/docs/guides/crosswalk/aws/).

  The AWS Infrastructure package is intended to provide [component](https://www.pulumi.com/docs/intro/concepts/resources/components/) wrappers around many core AWS 'raw' resources to make them easier and more convenient to use.  In general, the `@pulumi/awsx` package mirrors the module structure of `@pulumi/aws` (i.e. `@pulumi/awsx/ecs` or `@pulumi/awsx/ec2`).  These [components](https://www.pulumi.com/docs/intro/concepts/resources/components/) are designed to take care of much of the redundancy and boilerplate necessary when using the raw AWS resources, while still striving to expose all underlying functionality if needed.

  The AWS Infrastructure package undergoes constant improvements and additions.  While we will strive to maintain backward compatibility here, we will occasionally make breaks here as appropriate if it helps improve the overall quality of this package.

  The AWS Infrastructure package exposes many high level abstractions.  Including:

  * [`ec2`](https://github.com/pulumi/pulumi-awsx/blob/master/awsx/ec2).  A module that makes it easier to work with your AWS network, subnets, and security groups.  By default, the resources in the package follow the [AWS Best Practices](
    https://aws.amazon.com/answers/networking/aws-single-vpc-design/), but can be configured as desired in whatever ways you want.  Most commonly, this package is used to acquire the default Vpc for a region (using `awsx.ec2.DefaultNetwork`).  However, it can also be used to easily create or augment an existing Vpc.

  * [`ecs`](https://github.com/pulumi/pulumi-awsx/blob/master/awsx/ecs).  A module that makes it easy to create and configure clusters, tasks and services for running containers. Convenience resources are created to make the common tasks of creating EC2 or Fargate services and tasks much simpler.

  * [`lb`](https://github.com/pulumi/pulumi-awsx/tree/master/awsx/lb).  A module for simply setting up [Elastic Load Balancing](https://aws.amazon.com/elasticloadbalancing/). This module provides convenient ways to set up either `Network` or `Application` load balancers, along with the appropriate ELB Target Groups and Listeners in order to have a high availability, automatically-scaled service.  These ELB components also work well with the other awsx components.  For example, an `lb.defaultTarget` can be passed in directly as the `portMapping` target of an `ecs.FargateService`.

  <div>
      <a href="https://www.pulumi.com/docs/guides/crosswalk/aws/" title="Get Started">
         <img src="https://www.pulumi.com/images/get-started.svg?" width="120">
      </a>
  </div>



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/awsx
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/awsx
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi-awsx
  ```



  To use from Go, use `go get` to grab the latest version of the library

  ```bash
  go get github.com/pulumi/pulumi-awsx/sdk
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.Awsx
  ```



  The configuration options available for this provider mirror those of the [Pulumi AWS Classic Provider](https://github.com/pulumi/pulumi-aws#configuration)



  Pulumi dependency resolution may result in `awsx.*` resources using a different version of the AWS Classic Provider than
  the rest of the program. The version used by default is fixed for each `@pulumi/awsx` release and can be found in
  [package.json](https://github.com/pulumi/pulumi-awsx/blob/master/awsx/package.json#L25). When this becomes problematic,
  for example a newer version of AWS Classic Provider is desired, it can be specified explicitly. For example, in Python:

  ```python
  import pulumi
  import pulumi_aws as aws
  import pulumi_awsx as awsx

  awsp = aws.Provider("awsp", opts=pulumi.ResourceOptions(version="6.36.0"))
  lb = awsx.lb.ApplicationLoadBalancer("lb", opts=pulumi.ResourceOptions(providers={"aws": awsp}))
  ```



  Before version 1, this package only supported components in TypeScript. All the existing components from the 0.x releases are now available in the `classic` namespace. The `classic` namespace will remain until the next major version release but will only receive updates for critical security fixes.

  1. Change references from `@pulumi/awsx` to `@pulumi/awsx/classic` to maintain existing behaviour.
  2. Refactor to replace the classic components with the new top-level components.

  **Note:** The new top-level components (outside the `classic` namespace) may require additional code changes and resource re-creation.



  - Removed ECS Cluster as this did not add any functionality over the [AWS Classic ECS Cluster resource](https://www.pulumi.com/registry/packages/aws/api-docs/ecs/cluster/).
  - Removed `Vpc.fromExistingIds()` as this was originally added because other components depended on the concrete VPC component class. The new components in v1 no longer have hard dependencies on other resources, so instead the subnets from the existing VPC can be passed into other components directly.



  * [Tutorial](https://www.pulumi.com/blog/crosswalk-for-aws-1-0/)
  * [API Reference Documentation](https://www.pulumi.com/registry/packages/awsx/api-docs/)
  * [Examples](./examples)
  * [Crosswalk for AWS Guide](https://www.pulumi.com/docs/guides/crosswalk/aws/)


pkgId: 2460c04c972a4ee4b9414c4afc3a3ec413a6e9f1dc290d4e88eb070e5a7237c7
name: python-pulumi-azure-help
arch: noarch
version: 6.13.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-azure
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-azure-6.13.0-1.src.rpm
location_href: Packages/python-pulumi-azure-help-6.13.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-azure/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-azure/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fazure.svg)](https://npmjs.com/package/@pulumi/azure)
  [![Python version](https://badge.fury.io/py/pulumi-azure.svg)](https://pypi.org/project/pulumi-azure)
  [![NuGet version](https://badge.fury.io/nu/pulumi.azure.svg)](https://badge.fury.io/nu/pulumi.azure)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-azure/sdk/v6/go)](https://pkg.go.dev/github.com/pulumi/pulumi-azure/sdk/v6/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-azure/blob/master/LICENSE)



  > **_NOTE:_** We recommend using the [Azure Native provider](https://github.com/pulumi/pulumi-azure-native) to provision Azure infrastructure. Azure Native provides complete coverage of Azure resources and same-day access to new resources and resource updates because it’s built and automatically from the Azure Resource Manager API.
  >
  > Azure Classic is based on the Terraform azurerm provider. It has fewer resources and resource options and receives new Azure features more slowly than Azure Native. However, Azure Classic remains fully-supported for existing usage.

  The Azure Classic resource provider for Pulumi lets you use Azure resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/). For a streamlined Pulumi walkthrough, including language runtime installation and Azure configuration, select "Get Started" below.

  <div>
      <a href="https://www.pulumi.com/docs/get-started/azure" title="Get Started">
         <img src="https://www.pulumi.com/images/get-started.svg?" width="120">
      </a>
  </div>



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      npm install @pulumi/azure

  or `yarn`:

      yarn add @pulumi/azure



  To use from Python, install using `pip`:

      pip install pulumi_azure



  To use from Go, use `go get` to grab the latest version of the library

      go get github.com/pulumi/pulumi-azure/sdk/v6



  To use from .NET, install using `dotnet add package`:

      dotnet add package Pulumi.Azure



  The `@pulumi/azure` package provides a strongly-typed means to build cloud applications that create
  and interact closely with Azure resources.  Resources are exposed for the entire Azure surface area,
  including (but not limited to), 'appinsights', 'compute', 'cosmosdb', 'keyvault', and more.



  There are a variety of ways credentials may be configured for the Azure provider, appropriate for
  different use cases. Refer to the [Azure configuration options](
  https://www.pulumi.com/registry/packages/azure-native/installation-configuration/#configuration-options).



  For further information, visit [Azure in the Pulumi Registry](https://www.pulumi.com/registry/packages/azure-native/)
  or for detailed API reference documentation, visit [Azure API Docs in the Pulumi Registry](https://www.pulumi.com/registry/packages/azure-native/api-docs/).


pkgId: ccb29c1f17a2e5d2bf7dc95393d94e5c121306839eeef2abc9156efabcd6209c
name: python-pulumi-azuread-help
arch: noarch
version: 6.0.2
epoch: 0
release: 1
summary: Development documents and examples for pulumi-azuread
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-azuread-6.0.2-1.src.rpm
location_href: Packages/python-pulumi-azuread-help-6.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-azuread/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-azuread/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fazuread.svg)](https://npmjs.com/package/@pulumi/azuread)
  [![NuGet version](https://badge.fury.io/nu/pulumi.azuread.svg)](https://badge.fury.io/nu/pulumi.azured)
  [![Python version](https://badge.fury.io/py/pulumi-azuread.svg)](https://pypi.org/project/pulumi-azuread)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-azuread/sdk/v6/go)](https://pkg.go.dev/github.com/pulumi/pulumi-azuread/sdk/v6/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-azuread/blob/master/LICENSE)



  The Microsoft Azure AD resource provider for Pulumi lets you use Azure Active Directory resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/). For a streamlined Pulumi walkthrough, including language runtime installation and Azure configuration, click "Get Started" below.

  <div>
      <a href="https://www.pulumi.com/docs/get-started/azure" title="Get Started">
         <img src="https://www.pulumi.com/images/get-started.svg?" width="120">
      </a>
  </div>



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      npm install @pulumi/azuread

  or `yarn`:

      yarn add @pulumi/azuread



  To use from Python, install using `pip`:

      pip install pulumi-azuread



  To use from Go, use `go get` to grab the latest version of the library

      go get github.com/pulumi/pulumi-azuread/sdk/v6



  To use from .NET, install using `dotnet add package`:

      dotnet add package Pulumi.Azuread



  The following configuration points are available:

  - `azuread:clientId` - The Client ID which should be used. This can also be sourced from the `ARM_CLIENT_ID` Environment
     Variable.
  - `azuread:tenantId` - The Tenant ID which should be used. This can also be sourced from the `ARM_TENANT_ID` Environment
     Variable.
  - `azuread:clientSecret` - The Client Secret which should be used. This can also be sourced from the `ARM_CLIENT_SECRET`
     Environment Variable.
  - `azuread:certificatePassword` - The password associated with the Client Certificate. This can also be sourced from
     the `ARM_CLIENT_CERTIFICATE_PASSWORD` Environment Variable.
  - `azuread:clientCertificatePath` - The path to the Client Certificate associated with the Service Principal which should
     be used. This can also be sourced from the `ARM_CLIENT_CERTIFICATE_PATH` Environment Variable.
  - `azuread:environment` -  The Cloud Environment which be used. Possible values are public, usgovernment, german and china.
     Defaults to `public`. This can also be sourced from the `ARM_ENVIRONMENT` environment variable.
  - `azuread:msiEndpoint` - The path to a custom endpoint for Managed Service Identity - in most circumstances this should
     be detected automatically. This can also be sourced from the `ARM_MSI_ENDPOINT` Environment Variable.
  - `azuread:useMsi` - Should Managed Service Identity be used for Authentication? This can also be sourced from the
     `ARM_USE_MSI` Environment Variable. Defaults to `false`.



  For further information, please visit [the AzureAD provider docs](https://www.pulumi.com/registry/packages/azuread/) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/registry/packages/azuread/api-docs/).


pkgId: cb21f47040819e42589d4b38205840f8adf62b4576ea13e51ad765f114c97e8c
name: python-pulumi-azuredevops-help
arch: noarch
version: 3.4.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-azuredevops
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-azuredevops-3.4.1-1.src.rpm
location_href: Packages/python-pulumi-azuredevops-help-3.4.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-azuredevops/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-azuredevops/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fazuredevops.svg)](https://www.npmjs.com/package/@pulumi/azuredevops)
  [![Python version](https://badge.fury.io/py/pulumi-azuredevops.svg)](https://pypi.org/project/pulumi-azuredevops)
  [![NuGet version](https://badge.fury.io/nu/pulumi.azuredevops.svg)](https://badge.fury.io/nu/pulumi.azuredevops)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-azuredevops/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-azuredevops/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-azuredevops/blob/master/LICENSE)



  The Azure DevOps resource provider for Pulumi lets you manage Azure DevOps
  resources in your cloud programs. To use this package, please [install the
  Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/azuredevops

  or `yarn`:

      $ yarn add @pulumi/azuredevops



  To use from Python, install using `pip`:

      $ pip install pulumi_azuredevops



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-azuredevops/sdk/v3



  The following configuration points are available:

  * `azuredevops:orgServiceUrl` - (Required) This is the Azure DevOps organization url. It can also be sourced from the `AZDO_ORG_SERVICE_URL` environment variable.
  * `azuredevops:personalAccessToken` - (Required) This is the Azure DevOps organization personal access token. The account corresponding to the token will need "owner" privileges for this organization. It can also be sourced from the `AZDO_PERSONAL_ACCESS_TOKEN` environment variable.



  For further information, please visit [the AzureDevOps provider docs](https://www.pulumi.com/registry/packages/azuredevops/)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/registry/packages/azuredevops/api-docs/).


pkgId: ab018a52c3727bc1f7bc660941fcfdde5a1a6703c2973da6ea10f85241575a0d
name: python-pulumi-civo-help
arch: noarch
version: 2.4.6
epoch: 0
release: 1
summary: Development documents and examples for pulumi-civo
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-civo-2.4.6-1.src.rpm
location_href: Packages/python-pulumi-civo-help-2.4.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-civo/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-civo/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fcivo.svg)](https://www.npmjs.com/package/@pulumi/civo)
  [![Python version](https://badge.fury.io/py/pulumi-civo.svg)](https://pypi.org/project/pulumi-civo)
  [![NuGet version](https://badge.fury.io/nu/pulumi.civo.svg)](https://badge.fury.io/nu/pulumi.civo)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-civo/sdk/v2/go)](https://pkg.go.dev/github.com/pulumi/pulumi-civo/sdk/v2/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-civo/blob/master/LICENSE)



  The Civo Resource Provider lets you manage Civo resources.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/civo

  or `yarn`:

      $ yarn add @pulumi/civo



  To use from Python, install using `pip`:

      $ pip install pulumi_civo



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-civo/sdk/v2



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Civo



  The following configuration points are available:

  - `civo:token` - (Required) This is the Civo API token. It can also be sourced from the `CIVO_TOKEN`
    environment variable.
  - `civo:region` - (Optional) Region in which to create Civo resources.  It can also be sourced from the `CIVO_REGION`
    environment variable.
  - `civo:credentialsFile - Path to the Civo credentials file. Can be specified using `CIVO_CREDENTIAL_FILE`
    environment variable.

  Other: `apiEndpoint`



  The format of the credentials file is as follows:

  ```
  {
      "apikeys": {
          "tf_key": "write-your-token-here"
      },
      "meta": {
          "current_apikey": "tf_key"
      }
  }
  ```
  You will then need to configure the credentials_file input to the correct location, for example:
  ```
  credentialsFile = "/secure/path/civo.json"
  ```



  For further information, please visit [the Civo provider docs](https://www.pulumi.com/docs/intro/cloud-providers/civo)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/civo).


pkgId: 0d6a1eaf5769f96297c7a41ed569feef88a615f64659f9c36613fca1ae3db40e
name: python-pulumi-cloudamqp-help
arch: noarch
version: 3.20.2
epoch: 0
release: 1
summary: Development documents and examples for pulumi-cloudamqp
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-cloudamqp-3.20.2-1.src.rpm
location_href: Packages/python-pulumi-cloudamqp-help-3.20.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-cloudamqp/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-cloudamqp/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fcloudamqp.svg)](https://www.npmjs.com/package/@pulumi/cloudamqp)
  [![Python version](https://badge.fury.io/py/pulumi-cloudamqp.svg)](https://pypi.org/project/pulumi-cloudamqp)
  [![NuGet version](https://badge.fury.io/nu/pulumi.cloudamqp.svg)](https://badge.fury.io/nu/pulumi.cloudamqp)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-cloudamqp/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-cloudamqp/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-cloudamqp/blob/master/LICENSE)



  The CloudAMQP resource provider for Pulumi lets you manage CloudAMQP resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/cloudamqp

  or `yarn`:

      $ yarn add @pulumi/cloudamqp



  To use from Python, install using `pip`:

      $ pip install pulumi_cloudamqp



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-cloudamqp/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.cloudamqp



  The following configuration points are available:

  - `cloudamqp:apikey` - (Required) Key used to authentication to the CloudAMQP Customer API. May be set via the `CLOUDAMQP_APIKEY` environment variable.
  - `cloudamqp:baseurl` - (Optional) Base URL to CloudAMQP Customer website. Default is `https://customer.cloudamqp.com`.



  For further information, please visit [the CloudAMQP provider docs](https://www.pulumi.com/docs/intro/cloud-providers/cloudamqp) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/cloudamp).


pkgId: 8a9b14eacc0eac810ef98990c857b59b43107cc25f55bcff59c6a6fe915e1eb6
name: python-pulumi-cloudflare-help
arch: noarch
version: 5.45.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-cloudflare
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-cloudflare-5.45.0-1.src.rpm
location_href: Packages/python-pulumi-cloudflare-help-5.45.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-cloudflare/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-cloudflare/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fcloudflare.svg)](https://www.npmjs.com/package/@pulumi/cloudflare)
  [![Python version](https://badge.fury.io/py/pulumi-cloudflare.svg)](https://pypi.org/project/pulumi-cloudflare)
  [![NuGet version](https://badge.fury.io/nu/pulumi.cloudflare.svg)](https://badge.fury.io/nu/pulumi.cloudflare)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-cloudflare/sdk/v5/go/cloudflare)](https://pkg.go.dev/github.com/pulumi/pulumi-cloudflare/sdk/v5/go/cloudflare)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-cloudflare/blob/master/LICENSE)



  The Cloudflare resource provider for Pulumi lets you use Cloudflare resources
  in your cloud programs. To use this package, please [install the Pulumi CLI
  first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/cloudflare

  or `yarn`:

      $ yarn add @pulumi/cloudflare



  To use from Python, install using `pip`:

      $ pip install pulumi_cloudflare



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-cloudflare/sdk/v5



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Cloudflare



  The following configuration points are available:

  - `cloudflare:apiBasePath` - (Optional) Configure the base path used by the API client. Alternatively, can be configured using the `CLOUDFLARE_API_BASE_PATH` environment variable.
  - `cloudflare:apiClientLogging` - (Optional) Whether to print logs from the API client (using the default log library logger). Alternatively, can be configured using the `CLOUDFLARE_API_CLIENT_LOGGING` environment variable.
  - `cloudflare:apiHostname` - (Optional) Configure the hostname used by the API client. Alternatively, can be configured using the `CLOUDFLARE_API_HOSTNAME` environment variable.
  - `cloudflare:apiKey` - (Optional) The API key for operations. Alternatively, can be configured using the `CLOUDFLARE_API_KEY` environment variable. API keys are now considered legacy by Cloudflare, API tokens should be used instead. Must provide only one of `cloudflare:apiKey`, `cloudflare:apiToken`, `cloudflare:apiUserServiceKey`.
  - `cloudflare:apiKey` - (Optional) The Cloudflare API key. May be set via the `CLOUDFLARE_API_KEY` environment variable.
  - `cloudflare:apiToken` - (Optional) The API Token for operations. Alternatively, can be configured using the `CLOUDFLARE_API_TOKEN` environment variable. Must provide only one of `cloudflare:apiKey`, `cloudflare:apiToken`, `cloudflare:apiUserServiceKey`.
  - `cloudflare:apiUserServiceKey` - (Optional) A special Cloudflare API key good for a restricted set of endpoints. Alternatively, can be configured using the `CLOUDFLARE_API_USER_SERVICE_KEY` environment variable. Must provide only one of `cloudflare:apiKey`, `cloudflare:apiToken`, `cloudflare:apiUserServiceKey`.
  - `cloudflare:email` - (Optional) A registered Cloudflare email address. Alternatively, can be configured using the `CLOUDFLARE_EMAIL` environment variable. Required when using `cloudflare:apiKey`. Conflicts with `cloudflare:apiToken`.
  - `cloudflare:maxBackoff` - (Optional) Maximum backoff period in seconds after failed API calls. Default: `30`. May be set via the `CLOUDFLARE_MAX_BACKOFF` environment variable.
  - `cloudflare:minBackoff` - (Optional) Minimum backoff period in seconds after failed API calls. Default: `1`. May be set via the `CLOUDFLARE_MIN_BACKOFF` environment variable.
  - `cloudflare:retries` - (Optional) Maximum number of retries to perform when an API request fails. Default: `3`. May be set via the `CLOUDFLARE_RETRIES` environment variable.
  - `cloudflare:rps` - (Optional) RPS limit to apply when making calls to the API. Default: `4`. May be set via the `CLOUDFLARE_RPS` environment variable.
  - `cloudflare:userAgentOperatorSuffix` - (Optional) A value to append to the HTTP User Agent for all API calls. This value is not something most users need to modify however, if you are using a non-standard provider or operator configuration, this is recommended to assist in uniquely identifying your traffic. **Setting this value will remove the Pulumi version from the HTTP User Agent string and may have unintended consequences.** Alternatively, can be configured using the `CLOUDFLARE_USER_AGENT_OPERATOR_SUFFIX` environment variable.



  For further information, please visit [the Cloudflare provider docs](https://www.pulumi.com/docs/intro/cloud-providers/cloudflare) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/cloudflare).


pkgId: 80337f488af4b71d4dd3625f7535def07a0fce3de11d2e99c42fc0f4811cd088
name: python-pulumi-cloudinit-help
arch: noarch
version: 1.4.9
epoch: 0
release: 1
summary: Development documents and examples for pulumi-cloudinit
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-cloudinit-1.4.9-1.src.rpm
location_href: Packages/python-pulumi-cloudinit-help-1.4.9-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-cloudinit/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-cloudinit/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fcloudinit.svg)](https://npmjs.com/package/@pulumi/cloudinit)
  [![NuGet version](https://badge.fury.io/nu/pulumi.cloudinit.svg)](https://badge.fury.io/nu/pulumi.cloudinit)
  [![Python version](https://badge.fury.io/py/pulumi-cloudinit.svg)](https://pypi.org/project/pulumi-cloudinit)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-cloudinit/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-cloudinit/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-cloudinit/blob/master/LICENSE)



  Provider for rendering [cloud-init](https://cloudinit.readthedocs.io/) configurations.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/cloudinit

  or `yarn`:

      $ yarn add @pulumi/cloudinit



  To use from Python, install using `pip`:

      $ pip install pulumi_cloudinit



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-cloudinit/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.CloudInit



  For further information, please visit [the CloudInit provider docs](https://www.pulumi.com/docs/intro/cloud-providers/cloudinit) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/cloudinit).


pkgId: d5b5e74409f225bc65b8f96a6f3ed1c7e54608ba278e63270d1966d3ffdf4178
name: python-pulumi-cloudngfwaws-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for pulumi-cloudngfwaws
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-cloudngfwaws-0.0.3-1.src.rpm
location_href: Packages/python-pulumi-cloudngfwaws-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  The Palo Alto Networks Cloud NGFW for AWS Resource Provider lets you manage  Palo Alto Networks Cloud NGFW for AWS resources.



  This package is available for several languages/platforms:

  - JavaScript/TypeScript: [`@pulumi/cloudngfwaws`](https://www.npmjs.com/package/@pulumi/cloudngfwaws)
  - Python: [`pulumi-cloudngfwaws`](https://pypi.org/project/pulumi-cloudngfwaws/)
  - Go: [`github.com/pulumi/pulumi-cloudngfwaws/sdk/go/cloudngfwaws`](https://pkg.go.dev/github.com/pulumi/pulumi-cloudngfwaws/sdk/go/cloudngfwaws)
  - .NET: [`Pulumi.CloudNgfwAws`](https://www.nuget.org/packages/Pulumi.CloudNgfwAws)



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/cloudngfwaws
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/cloudngfwaws
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi-cloudngfwaws
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pulumi/pulumi-cloudngfwaws/sdk/go/cloudngfwaws
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.CloudNgfwAws
  ```



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/meraki/api-docs/).


pkgId: 235950b2b4f49b3f64a8284f3ab1c459e76c273075821f07eadfadff378a0119
name: python-pulumi-command-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-command
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-command-1.0.1-1.src.rpm
location_href: Packages/python-pulumi-command-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-command/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-command/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fcommand.svg)](https://www.npmjs.com/package/@pulumi/command)
  [![Python version](https://badge.fury.io/py/pulumi-command.svg)](https://pypi.org/project/pulumi-command)
  [![NuGet version](https://badge.fury.io/nu/pulumi.command.svg)](https://badge.fury.io/nu/pulumi.command)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-command/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-command/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-command/blob/master/LICENSE)



  The Pulumi Command Provider enables you to execute commands and scripts either locally or remotely as part of the Pulumi resource model.  Resources in the command package support running scripts on `create` and `destroy` operations, supporting stateful local and remote command execution.

  There are many scenarios where the Command package can be useful:

  * Running a command locally after creating a resource, to register it with an external service
  * Running a command locally before deleting a resource, to deregister it with an external service
  * Running a command remotely on a remote host immediately after creating it
  * Copying a file to a remote host after creating it (potentially as a script to be executed afterwards)
  * As a simple alternative to some use cases for Dynamic Providers (especially in languages which do not yet support Dynamic Providers).

  Some users may have experience with Terraform "provisioners", and the Command package offers support for similar scenarios.  However, the Command package is provided as independent resources which can be combined with other resources in many interesting ways. This has many strengths, but also some differences, such as the fact that a Command resource failing does not cause a resource it is operating on to fail.

  You can use the Command package from a Pulumi program written in any Pulumi language: C#, Go, JavaScript/TypeScript, Python, and YAML.
  You'll need to [install and configure the Pulumi CLI](https://pulumi.com/docs/get-started/install) if you haven't already.


  > **NOTE**: The Command package is in preview.  The API design may change ahead of general availability based on [user feedback](https://github.com/pulumi/pulumi-command/issues).





  The simplest use case for `local.Command` is to just run a command on `create`, which can return some value which will be stored in the state file, and will be persistent for the life of the stack (or until the resource is destroyed or replaced).  The example below uses this as an alternative to the `random` package to create some randomness which is stored in Pulumi state.

  ```ts
  import { local } from "@pulumi/command";

  const random = new local.Command("random", {
      create: "openssl rand -hex 16",
  });

  export const output = random.stdout;
  ```

  ```go
  package main

  import (
  	"github.com/pulumi/pulumi-command/sdk/go/command/local"
  	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
  )

  func main() {
  	pulumi.Run(func(ctx *pulumi.Context) error {

  		random, err := local.NewCommand(ctx, "my-bucket", &local.CommandInput{
  			Create: pulumi.String("openssl rand -hex 16"),
  		})
  		if err != nil {
  			return err
  		}

  		ctx.Export("output", random.Stdout)
  		return nil
  	})
  }
  ```



  This example creates and EC2 instance, and then uses `remote.Command` and `remote.CopyFile` to run commands and copy files to the remote instance (via SSH). Similar things are possible with Azure, Google Cloud and other cloud provider virtual machines.  Support for Windows-based VMs is being tracked [here](https://github.com/pulumi/pulumi-command/issues/15).

  Note that implicit and explicit (`dependsOn`) dependencies can be used to control the order that these `Command` and `CopyFile` resources are constructed relative to each other and to the cloud resources they depend on.  This ensures that the `create` operations run after all dependencies are created, and the `delete` operations run before all dependencies are deleted.

  Because the `Command` and `CopyFile` resources replace on changes to their connection, if the EC2 instance is replaced, the commands will all re-run on the new instance (and the `delete` operations will run on the old instance).

  Note also that `deleteBeforeReplace` can be composed with `Command` resources to ensure that the `delete` operation on an "old" instance is run before the `create` operation of the new instance, in case a scarce resource is managed by the command.  Similarly, other resource options can naturally be applied to `Command` resources, like `ignoreChanges`.

  ```ts
  import { interpolate, Config } from "@pulumi/pulumi";
  import { local, remote, types } from "@pulumi/command";
  import * as aws from "@pulumi/aws";
  import * as fs from "fs";
  import * as os from "os";
  import * as path from "path";
  import { size } from "./size";

  const config = new Config();
  const keyName = config.get("keyName") ?? new aws.ec2.KeyPair("key", { publicKey: config.require("publicKey") }).keyName;
  const privateKeyBase64 = config.get("privateKeyBase64");
  const privateKey = privateKeyBase64 ? Buffer.from(privateKeyBase64, 'base64').toString('ascii') : fs.readFileSync(path.join(os.homedir(), ".ssh", "id_rsa")).toString("utf8");

  const secgrp = new aws.ec2.SecurityGroup("secgrp", {
      description: "Foo",
      ingress: [
          { protocol: "tcp", fromPort: 22, toPort: 22, cidrBlocks: ["0.0.0.0/0"] },
          { protocol: "tcp", fromPort: 80, toPort: 80, cidrBlocks: ["0.0.0.0/0"] },
      ],
  });

  const ami = aws.ec2.getAmiOutput({
      owners: ["amazon"],
      mostRecent: true,
      filters: [{
          name: "name",
          values: ["amzn2-ami-hvm-2.0.????????-x86_64-gp2"],
      }],
  });

  const server = new aws.ec2.Instance("server", {
      instanceType: size,
      ami: ami.id,
      keyName: keyName,
      vpcSecurityGroupIds: [secgrp.id],
  }, { replaceOnChanges: ["instanceType"] });

  // Now set up a connection to the instance and run some provisioning operations on the instance.

  const connection: types.input.remote.ConnectionInput = {
      host: server.publicIp,
      user: "ec2-user",
      privateKey: privateKey,
  };

  const hostname = new remote.Command("hostname", {
      connection,
      create: "hostname",
  });

  new remote.Command("remotePrivateIP", {
      connection,
      create: interpolate`echo ${server.privateIp} > private_ip.txt`,
      delete: `rm private_ip.txt`,
  }, { deleteBeforeReplace: true });

  new local.Command("localPrivateIP", {
      create: interpolate`echo ${server.privateIp} > private_ip.txt`,
      delete: `rm private_ip.txt`,
  }, { deleteBeforeReplace: true });

  const sizeFile = new remote.CopyFile("size", {
      connection,
      localPath: "./size.ts",
      remotePath: "size.ts",
  })

  const catSize = new remote.Command("checkSize", {
      connection,
      create: "cat size.ts",
  }, { dependsOn: sizeFile })

  export const confirmSize = catSize.stdout;
  export const publicIp = server.publicIp;
  export const publicHostName = server.publicDns;
  export const hostnameStdout = hostname.stdout;
  ```



  There may be cases where it is useful to run some code within an AWS Lambda or other serverless function during the deployment.  For example, this may allow running some code from within a VPC, or with a specific role, without needing to have persistent compute available (such as the EC2 example above).

  Note that the Lambda function itself can be created within the same Pulumi program, and then invoked after creation.

  The example below simply creates some random value within the Lambda, which is a very roundabout way of doing the same thing as the first "random" example above, but this pattern can be used for more complex scenarios where the Lambda does things a local script could not.

  ```ts
  import { local } from "@pulumi/command";
  import * as aws from "@pulumi/aws";
  import * as crypto from "crypto";

  const f = new aws.lambda.CallbackFunction("f", {
      publish: true,
      callback: async (ev: any) => {
          return crypto.randomBytes(ev.len/2).toString('hex');
      }
  });

  const rand = new local.Command("execf", {
      create: `aws lambda invoke --function-name "$FN" --payload '{"len": 10}' --cli-binary-format raw-in-base64-out out.txt >/dev/null && cat out.txt | tr -d '"'  && rm out.txt`,
      environment: {
          FN: f.qualifiedArn,
          AWS_REGION: aws.config.region!,
          AWS_PAGER: "",
      },
  })

  export const output = rand.stdout;
  ```



  This example uses `local.Command` to create a simple resource provider for managing GitHub labels, by invoking `curl` commands on `create` and `delete` commands against the GitHub REST API. A similar approach could be applied to build other simple providers against any REST API directly from within Pulumi programs in any language. This approach is somewhat limited by the fact that `local.Command` does not yet support `diff`/`read`. Support for [Read](https://github.com/pulumi/pulumi-command/issues/432) and [Diff](https://github.com/pulumi/pulumi-command/issues/433) may be added in the future.

  This example also shows how `local.Command` can be used as an implementation detail inside a nicer abstraction, like the `GitHubLabel` component defined below.

  ```ts
  import * as pulumi from "@pulumi/pulumi";
  import * as random from "@pulumi/random";
  import { local } from "@pulumi/command";

  interface LabelArgs {
      owner: pulumi.Input<string>;
      repo: pulumi.Input<string>;
      name: pulumi.Input<string>;
      githubToken: pulumi.Input<string>;
  }

  class GitHubLabel extends pulumi.ComponentResource {
      public url: pulumi.Output<string>;

      constructor(name: string, args: LabelArgs, opts?: pulumi.ComponentResourceOptions) {
          super("example:github:Label", name, args, opts);

          const label = new local.Command("label", {
              create: "./create_label.sh",
              delete: "./delete_label.sh",
              environment: {
                  OWNER: args.owner,
                  REPO: args.repo,
                  NAME: args.name,
                  GITHUB_TOKEN: args.githubToken,
              }
          }, { parent: this });

          const response = label.stdout.apply(JSON.parse);
          this.url = response.apply((x: any) => x.url as string);
      }
  }

  const config = new pulumi.Config();
  const rand = new random.RandomString("s", { length: 10, special: false });

  const label = new GitHubLabel("l", {
      owner: "pulumi",
      repo: "pulumi-command",
      name: rand.result,
      githubToken: config.requireSecret("githubToken"),
  });

  export const labelUrl = label.url;
  ```

  ```sh

  curl \
    -s \
    -X POST \
    -H "authorization: Bearer $GITHUB_TOKEN" \
    -H "Accept: application/vnd.github.v3+json" \
    https://api.github.com/repos/$OWNER/$REPO/labels \
    -d "{\"name\":\"$NAME\"}"
  ```

  ```sh

  curl \
    -s \
    -X DELETE \
    -H "authorization: Bearer $GITHUB_TOKEN" \
    -H "Accept: application/vnd.github.v3+json" \
    https://api.github.com/repos/$OWNER/$REPO/labels/$NAME
  ```



  There are cases where it's important to run some cleanup operation before destroying a resource such as when destroying the resource does not properly handle orderly cleanup.  For example, destroying an EKS Cluster will not ensure that all Kubernetes object finalizers are run, which may lead to leaking external resources managed by those Kubernetes resources.  This example shows how we can use a `delete`-only `Command` to ensure some cleanup is run within a cluster before destroying it.

  ```yaml
  resources:
    cluster:
      type: eks:Cluster

    cleanupKubernetesNamespaces:
      
      
      type: command:local:Command
      properties:
        
        
        
        delete: |
          kubectl --kubeconfig <(echo "$KUBECONFIG_DATA") delete namespace nginx
        
        interpreter: ["/bin/bash", "-c"]
        environment:
          KUBECONFIG_DATA: "${cluster.kubeconfigJson}"
  ```

  ```ts
  import * as pulumi from "@pulumi/pulumi";
  import * as command from "@pulumi/command";
  import * as eks from "@pulumi/eks";

  const cluster = new eks.Cluster("cluster", {});

  // We could also use `RemoteCommand` to run this from within a node in the cluster
  const cleanupKubernetesNamespaces = new command.local.Command("cleanupKubernetesNamespaces", {
      // This will run before the cluster is destroyed.  Everything else will need to
      // depend on this resource to ensure this cleanup doesn't happen too early.
      "delete": "kubectl --kubeconfig <(echo \"$KUBECONFIG_DATA\") delete namespace nginx\n",
      // Process substitution "<()" doesn't work in the default interpreter sh.
      interpreter: [
          "/bin/bash",
          "-c",
      ],
      environment: {
          KUBECONFIG_DATA: cluster.kubeconfigJson,
      },
  });
  ```



  When a local command creates assets as part of its execution, these can be captured by specifying `assetPaths` or `archivePaths`.

  ```typescript
  const lambdaBuild = local.runOutput({
      dir: "../my-function",
      command: `yarn && yarn build`,
      archivePaths: ["dist/**"],
  });

  new aws.lambda.Function("my-function", {
      code: lambdaBuild.archive,
     // ...
  });
  ```

  When using the `assetPaths` and `archivePaths`, they take a list of 'globs'.
  - We only include files not directories for assets and archives.
  - Path separators are `/` on all platforms - including Windows.
  - Patterns starting with `!` are 'exclude' rules.
  - Rules are evaluated in order, so exclude rules should be after inclusion rules.
  - `*` matches anything except `/`
  - `**` matches anything, _including_ `/`
  - All returned paths are relative to the working directory (without leading `./`) e.g. `file.text` or `subfolder/file.txt`.
  - For full details of the globbing syntax, see [github.com/gobwas/glob](https://github.com/gobwas/glob)



  Given the rules:
  ```yaml
  - "assets/**"
  - "src/**.js"
  - "!**secret.*"
  ```

  When evaluating against this folder:

  ```yaml
  - assets/
    - logos/
      - logo.svg
  - src/
    - index.js
    - secret.js
  ```

  The following paths will be returned:

  ```yaml
  - assets/logos/logo.svg
  - src/index.js
  ```





  - Go 1.17
  - NodeJS 10.X.X or later
  - Python 3.6 or later
  - .NET Core 3.1

  Please refer to [Contributing to Pulumi](https://github.com/pulumi/pulumi/blob/master/CONTRIBUTING.md) for installation
  guidance.



  Run the following commands to install Go modules, generate all SDKs, and build the provider:

  ```
  $ make ensure
  $ make build
  $ make install
  ```

  Add the `bin` folder to your `$PATH` or copy the `bin/pulumi-resource-command` file to another location in your `$PATH`.



  Navigate to the simple example and run Pulumi:

  ```
  $ cd examples/simple
  $ yarn link @pulumi/command
  $ yarn install
  $ pulumi up
  ```


pkgId: 2444841090b89223787d8c85b425d7552b85d85defdbfe58a362c79a902ab4ce
name: python-pulumi-confluentcloud-help
arch: noarch
version: 2.12.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-confluentcloud
url: https://www.pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-confluentcloud-2.12.0-1.src.rpm
location_href: Packages/python-pulumi-confluentcloud-help-2.12.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-confluentcloud/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-confluentcloud/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fconfluentcloud.svg)](https://www.npmjs.com/package/@pulumi/confluentcloud)
  [![Python version](https://badge.fury.io/py/pulumi-confluentcloud.svg)](https://pypi.org/project/pulumi-confluentcloud)
  [![NuGet version](https://badge.fury.io/nu/pulumi.confluentcloud.svg)](https://badge.fury.io/nu/pulumi.confluentcloud)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-confluentcloud/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-confluentcloud/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-confluentcloud/blob/master/LICENSE)



  The Confluent Resource Provider lets you manage [Confluent](https://confluent.cloud/) resources.

  Please Note:
  This provider is built from the ConfluentInc official Terraform Provider - https://github.com/confluentinc/terraform-provider-confluent



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/confluentcloud
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/confluentcloud
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi_confluentcloud
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pulumi/pulumi-confluentcloud/sdk
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.ConfluentCloud
  ```



  The following configuration points are available for the `confluent cloud` provider:

  - `confluentcloud:cloudApiKey` (environment: `CONFLUENT_CLOUD_API_KEY`) - the API key for `Confluent Cloud`
  - `confluentcloud:cloudApiSecret` (environment: `CONFLUENT_CLOUD_API_SECRET`) - the API secret for `Confluent Cloud`



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/confluentcloud/api-docs/).


pkgId: 2923a3158e9ace5ce6acee247d0168367f615af2a5a4b2d0b27e4bd08e56e0a6
name: python-pulumi-consul-help
arch: noarch
version: 3.12.3
epoch: 0
release: 1
summary: Development documents and examples for pulumi-consul
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-consul-3.12.3-1.src.rpm
location_href: Packages/python-pulumi-consul-help-3.12.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-consul/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-consul/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fconsul.svg)](https://www.npmjs.com/package/@pulumi/consul)
  [![Python version](https://badge.fury.io/py/pulumi-consul.svg)](https://pypi.org/project/pulumi-consul)
  [![NuGet version](https://badge.fury.io/nu/pulumi.consul.svg)](https://badge.fury.io/nu/pulumi.consul)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-consul/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-consul/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-consul/blob/master/LICENSE)



  The Consul resource provider for Pulumi lets you manage Consul resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/consul

  or `yarn`:

      $ yarn add @pulumi/consul



  To use from Python, install using `pip`:

      $ pip install pulumi_consul



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-consul/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Consul



  The following configuration points are available:

  - `consul:address` - (Optional) The HTTP(S) API address of the agent to use. Defaults to `127.0.0.1:8500`.
  - `consul:scheme` - (Optional) The URL scheme of the agent to use (`http` or `https`). Defaults to `http`.
  - `consul:httpAuth` - (Optional) HTTP Basic Authentication credentials to be used when communicating with Consul, in the
    format of either user or user:pass. This may also be specified using the `CONSUL_HTTP_AUTH` environment variable.
  - `consul:datacenter` - (Optional) The datacenter to use. Defaults to that of the agent.
  - `consul:token` - (Optional) The ACL token to use by default when making requests to the agent. Can also be specified
    with `CONSUL_HTTP_TOKEN` or `CONSUL_TOKEN` as an environment variable.
  - `consul:caFile` - (Optional) A path to a PEM-encoded certificate authority used to verify the remote agent's certificate.
  - `consul:certFile` - (Optional) A path to a PEM-encoded certificate provided to the remote agent; requires use of `keyFile`.
  - `consul:keyFile` - (Optional) A path to a PEM-encoded private key, required if `certFile` is specified.
  - `consul:caPath` - (Optional) A path to a directory of PEM-encoded certificate authority files to use to check the
    authenticity of client and server connections. Can also be specified with the `CONSUL_CAPATH` environment variable.
  - `consul:insecureHttps` - (Optional) Boolean value to disable SSL certificate verification; setting this value to true
    is not recommended for production use. Only use this with scheme set to `https`.



  For further information, please visit [the Consul provider docs](https://www.pulumi.com/docs/intro/cloud-providers/consul) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/consul).


pkgId: 8a8975ac272cc49750f2b3931f9389a12830bf9a048258a13371bc5b8be83a57
name: python-pulumi-databricks-help
arch: noarch
version: 1.56.2
epoch: 0
release: 1
summary: Development documents and examples for pulumi-databricks
url: https://www.pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-databricks-1.56.2-1.src.rpm
location_href: Packages/python-pulumi-databricks-help-1.56.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-databricks/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-databricks/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fdatabricks.svg)](https://www.npmjs.com/package/@pulumi/databricks)
  [![Python version](https://badge.fury.io/py/pulumi-databricks.svg)](https://pypi.org/project/pulumi-databricks)
  [![NuGet version](https://badge.fury.io/nu/pulumi.databricks.svg)](https://badge.fury.io/nu/pulumi.databricks)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-databricks/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-databricks/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-databricks/blob/master/LICENSE)



  The Databricks Resource Provider lets you manage Databricks resources.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/databricks

  or `yarn`:

      $ yarn add @pulumi/databricks



  To use from Python, install using `pip`:

      $ pip install pulumi_databricks



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-databricks/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Databricks



  The following configuration points are available:

  * `databricks:host` - (optional) This is the host of the Databricks workspace. It is a URL that you use to login to your workspace.
    Alternatively, you can provide this value as an environment variable `DATABRICKS_HOST`.
  * `databricks:token` - (optional) This is the API token to authenticate into the workspace. Alternatively, you can provide
    this value as an environment variable `DATABRICKS_TOKEN`.
  * `databricks:username` - (optional) This is the username of the user that can log into the workspace. Alternatively,
    you can provide this value as an environment variable `DATABRICKS_USERNAME`.
  * `databricks:password` - (optional) This is the user's password that can log into the workspace. Alternatively, you can
    provide this value as an environment variable `DATABRICKS_PASSWORD`.
  * `databricks:configFile` - (optional) Location of the Databricks CLI credentials file created by `databricks configure --token`
    command (`~/.databrickscfg` by default). Check [Databricks CLI documentation](https://docs.databricks.com/dev-tools/cli/index.html#set-up-authentication) for more details.
    The provider uses configuration file credentials when you don't specify host/token/username/password/azure attributes.
    Alternatively, you can provide this value as an environment variable `DATABRICKS_CONFIG_FILE`. This field defaults to `~/.databrickscfg`.
  * `databricks:profile` - (optional) Connection profile specified within `~/.databrickscfg`. Please check
    [connection profiles section](https://docs.databricks.com/dev-tools/cli/index.html#connection-profiles) for more details. This field defaults to `DEFAULT`.
  * `databricks:accountId` - (optional) Account Id that could be found in the bottom left corner of
    [Accounts Console](https://accounts.cloud.databricks.com/). Alternatively, you can provide this value as an environment
    variable `DATABRICKS_ACCOUNT_ID`. Only has effect when `host = "https://accounts.cloud.databricks.com/"` and currently used to provision account admins via `databricks_user`.
    In the future releases of the provider this property will also be used specify account for `databricks_mws_*` resources as well.
  * `databricks:authType` - (optional) enforce specific auth type to be used in very rare cases, where a single provider state
    manages Databricks workspaces on more than one cloud and `More than one authorization method configured` error is a false positive. Valid values are `pat`, `basic`, `azure-client-secret`, `azure-msi`, `azure-cli`, and `databricks-cli`.



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/databricks/api-docs/).



  This package was originally built by the development team at [https://www.ingenii.io/](https://www.ingenii.io/). Pulumi thanks them for their continued contributions to the project.


pkgId: fb3c64cdf61d2eaed7d30758059ea1f5f3095b35633473912608d7f9c435dea8
name: python-pulumi-datadog-help
arch: noarch
version: 4.37.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-datadog
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-datadog-4.37.0-1.src.rpm
location_href: Packages/python-pulumi-datadog-help-4.37.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-datadog/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-datadog/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fdatadog.svg)](https://www.npmjs.com/package/@pulumi/datadog)
  [![Python version](https://badge.fury.io/py/pulumi-datadog.svg)](https://pypi.org/project/pulumi-datadog)
  [![NuGet version](https://badge.fury.io/nu/pulumi.datadog.svg)](https://badge.fury.io/nu/pulumi.datadog)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-datadog/sdk/v4/go)](https://pkg.go.dev/github.com/pulumi/pulumi-datadog/sdk/v4/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-datadog/blob/master/LICENSE)



  The Datadog resource provider for Pulumi lets you configure Datadog resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/datadog

  or `yarn`:

      $ yarn add @pulumi/datadog



  To use from Python, install using `pip`:

      $ pip install pulumi_datadog



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-datadog/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Datadog



  The following configuration points are available:

  * apiKey (Required) - Datadog API key. This can also be set via the `DATADOG_API_KEY` environment variable.
  * appKey (Required) - Datadog APP key. This can also be set via the `DATADOG_APP_KEY` environment variable.
  * apiUrl (Optional) - The API Url. This can be also be set via the DATADOG_HOST environment variable.
    Note that this URL must not end with the `/api/` path. For example, `https://api.datadoghq.com/` is a correct value,
    while `https://api.datadoghq.com/api/` is not.





  For further information, please visit [the Datadog provider docs](https://www.pulumi.com/docs/intro/cloud-providers/datadog) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/datadog).


pkgId: 5ba919046db9561287feb64b8ed32da40713cd97a39efe5bcaca85f31641e204
name: python-pulumi-dbtcloud-help
arch: noarch
version: 0.1.25
epoch: 0
release: 1
summary: Development documents and examples for pulumi-dbtcloud
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-dbtcloud-0.1.25-1.src.rpm
location_href: Packages/python-pulumi-dbtcloud-help-0.1.25-1.noarch.rpm
checksum_type: sha256
description:
  The dbt Cloud Resource Provider lets you manage dbt Cloud resources.



  This package is available for several languages/platforms:

  - JavaScript/TypeScript: [`@pulumi/dbtcloud`](https://www.npmjs.com/package/@pulumi/dbtcloud)
  - Python: [`pulumi-dbtcloud`](https://pypi.org/project/pulumi-dbtcloud/)
  - Go: [`github.com/pulumi/pulumi-dbtcloud/sdk/go/dbtcloud`](https://pkg.go.dev/github.com/pulumi/pulumi-dbtcloud/sdk/go/dbtcloud)
  - .NET: [`Pulumi.Dbtcloud`](https://www.nuget.org/packages/Pulumi.DbtCloud)



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/dbtcloud
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/dbtcloud
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi-dbtcloud
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pulumi/pulumi-dbtcloud/sdk/go/dbtcloud
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.DbtCloud
  ```



  Use `pulumi config set dbtcloud:<option> (--secret)`.

  | Option     | Environment Variable   | Required/Optional | Default                                                      | Description                             |
  |------------|------------------------|-------------------|--------------------------------------------------------------|-----------------------------------------|
  | `token`    | `DBT_CLOUD_TOKEN`      | Required          |                                                              | The API token for your dbt Cloud user   |
  | `accountId`| `DBT_CLOUD_ACCOUNT_ID` | Required          |                                                              | The ID for your dbt Cloud account       |
  | `hostUrl`  | `DBT_CLOUD_HOST_URL`   | Optional          | [https://cloud.getdbt.com/api](https://cloud.getdbt.com/api) | The host URL for your dbt Cloud account |


pkgId: 889bdc73a173abec18cc3aeb56a099c8301dd3edeaa47704ac204b953aeb8f9b
name: python-pulumi-digitalocean-help
arch: noarch
version: 4.36.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-digitalocean
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-digitalocean-4.36.0-1.src.rpm
location_href: Packages/python-pulumi-digitalocean-help-4.36.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-digitalocean/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-digitalocean/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fdigitalocean.svg)](https://www.npmjs.com/package/@pulumi/digitalocean)
  [![Python version](https://badge.fury.io/py/pulumi-digitalocean.svg)](https://pypi.org/project/pulumi-digitalocean)
  [![NuGet version](https://badge.fury.io/nu/pulumi.digitalocean.svg)](https://badge.fury.io/nu/pulumi.digitalocean)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-digitalocean/sdk/v4/go)](https://pkg.go.dev/github.com/pulumi/pulumi-digitalocean/sdk/v4/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-digitalocean/blob/master/LICENSE)



  The DigitalOcean resource provider for Pulumi lets you use DigitalOcean resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/digitalocean

  or `yarn`:

      $ yarn add @pulumi/digitalocean



  To use from Python, install using `pip`:

      $ pip install pulumi_digitalocean



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-digitalocean/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Digitalocean



  The following configuration points are available:

  - `digitalocean:token` - (Required) This is the DO API token. Alternatively, this can also be specified using environment
    variables, ordered by precedence, `DIGITALOCEAN_TOKEN` or `DIGITALOCEAN_ACCESS_TOKEN`.
  - `digitalocean:spacesAccessId` - (Optional) The access key ID used for Spaces API operations. May be set via the
    `SPACES_ACCESS_KEY_ID` environment variable.
  - `digitalocean:spacesSecretKey` - (Optional) The secret key used for Spaces API operations. May be set via the
    `SPACES_SECRET_ACCESS_KEY` environment variable.
  - `digitalocean:apiEndpoint` - (Optional) This can be used to override the base URL for DigitalOcean API requests. May
    be set via the `DIGITALOCEAN_API_URL` environment variable. Default is `https://api.digitalocean.com`.



  The `@pulumi/digitalocean` package provides a strongly-typed means to create cloud applications that create and interact
  closely with DigitalOcean resources.  Resources are exposed for the entirety of DigitalOcean resources and their
  properties, including (but not limited to), 'droplet', 'floatingIp', 'firewalls', etc.  Many convenience APIs have also
  been added to make development easier and to help avoid common mistakes, and to get stronger typing.



  For further information, please visit [the DigitalOcean provider docs](https://www.pulumi.com/docs/intro/cloud-providers/digitalocean) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/digitalocean).


pkgId: 7990d507f1414ab428d22fd26cddd27adadd9fdfce41229a94c30851062c00cb
name: python-pulumi-dnsimple-help
arch: noarch
version: 4.2.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-dnsimple
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-dnsimple-4.2.0-1.src.rpm
location_href: Packages/python-pulumi-dnsimple-help-4.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-dnsimple/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-dnsimple/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fdnsimple.svg)](https://www.npmjs.com/package/@pulumi/dnsimple)
  [![Python version](https://badge.fury.io/py/pulumi-dnsimple.svg)](https://pypi.org/project/pulumi-dnsimple)
  [![NuGet version](https://badge.fury.io/nu/pulumi.dnsimple.svg)](https://badge.fury.io/nu/pulumi.dnsimple)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-dnsimple/sdk/v4/go)](https://pkg.go.dev/github.com/pulumi/pulumi-dnsimple/sdk/v4/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-dnsimple/blob/master/LICENSE)



  The dnsimple resource provider for Pulumi lets you manage dnsimple resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/dnsimple

  or `yarn`:

      $ yarn add @pulumi/dnsimple



  To use from Python, install using `pip`:

      $ pip install pulumi_dnsimple



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-dnsimple/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Dnsimple



  The following configuration points are available:

  - `dnsimple:token` - (required) The DNSimple API v2 token. Please note that this must be an API v2 token. You can use
     either an User or Account token, but an Account token is recommended. Can be sourced from `DNSIMPLE_TOKEN` environment
     variable.
  - `dnsimple:account` - (required) The ID of the account associated with the token. Can be sourced from `DNSIMPLE_ACCOUNT`
     environment variable.



  For further information, please visit [the dnsimple provider docs](https://www.pulumi.com/docs/intro/cloud-providers/dnsimple) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/dnsimple).


pkgId: 74663692a78e5bfa225c6ccba2db8016f95fa525dfe98ef83d777f70160ed83e
name: python-pulumi-docker-help
arch: noarch
version: 4.5.8
epoch: 0
release: 1
summary: Development documents and examples for pulumi-docker
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-docker-4.5.8-1.src.rpm
location_href: Packages/python-pulumi-docker-help-4.5.8-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-docker/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-docker/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fdocker.svg)](https://www.npmjs.com/package/@pulumi/docker)
  [![Python version](https://badge.fury.io/py/pulumi-docker.svg)](https://pypi.org/project/pulumi-docker)
  [![NuGet version](https://badge.fury.io/nu/pulumi.docker.svg)](https://badge.fury.io/nu/pulumi.docker)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-docker/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-docker/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-docker/blob/master/LICENSE)



  The Docker resource provider for Pulumi lets you manage Docker resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/docker

  or `yarn`:

      $ yarn add @pulumi/docker



  To use from Python, install using `pip`:

      $ pip install pulumi_docker



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-docker/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Docker



  For further information, please visit [the Docker provider docs](https://www.pulumi.com/docs/intro/cloud-providers/docker) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/docker).


pkgId: 45714ae8e41db203a776ba1dd54bb45a974926f27676d6e5fcbb899a7d28c10e
name: python-pulumi-ec-help
arch: noarch
version: 0.10.4
epoch: 0
release: 1
summary: Development documents and examples for pulumi-ec
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-ec-0.10.4-1.src.rpm
location_href: Packages/python-pulumi-ec-help-0.10.4-1.noarch.rpm
checksum_type: sha256
description:
  The Elastic Cloud Resource Provider lets you manage [Elastic Cloud](https://www.elastic.co/cloud/) resources.



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/ec
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/ec
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi_ec
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pulumi/pulumi-ec/sdk
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.ElasticCloud
  ```



  The following configuration points are available for the `ec` provider:

  - `ec:endpoint`: The Elastic Cloud endpoint to which requests should be sent.  This value should be specified only when using the Elastic Cloud provider with an ECE installation or ESS Private.
  - `ec:apikey`: The Elastic Cloud API key, recommended over `username` and `password` to authenticate against the Elastic Cloud API.  May also be sourced from environment variable `EC_API_KEY`.
  - `ec:username`: The Elastic Cloud username.  May also be sourced from environment variable `EC_USER` or `EC_USERNAME`.  Conflicts with `ec:apiKey`.  Not recommened - prefer using `ec:apikey` over `ec:username` and `ec:password`.
  - `ec:password`: The Elastic Cloud user's password.  May also be sourced from environment variable `EC_PASS` or `EC_PASSWORD`.  Conflicts with `ec:apiKey`.  Not recommened - prefer using `ec:apikey` over `ec:username` and `ec:password`.
  - `ec:insecure`: If `true`, allows the provider to skip TLS verification (not recommended).  Defaults to `false`.
  - `ec:timeout`: Allows the user to set a custom timeout in the individual HTTP request level. Defaults to 1 minute (`"1m"`), but can be extended if timeouts are experienced.
  - `ec:verbose`: When set to true, it writes a requests.json file in the folder where Terraform runs with all the outgoing HTTP requests and responses. Defaults to false.
  - `ec:verboseCredentials`: If set to `true` and `ec:verbose` is set to `true`, the contents of the Authorization header will not be redacted.  Defaults to `false`.
  - `ec:verboseFile`: Sets the name of the file to which verbose request and response HTTP flow will be written. Defaults to `request.log`.

  Either `ec:endpoint` or (`ec:username` and `ec:password`) must be specified.  All other parameters are optional:



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/ec/api-docs/).


pkgId: 9483b007b4e8db061087b3505ac410f3d4dc9a9aa8f813c7895f028dadd3dbe7
name: python-pulumi-eks-help
arch: noarch
version: 3.5.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-eks
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-eks-3.5.0-1.src.rpm
location_href: Packages/python-pulumi-eks-help-3.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/pulumi/pulumi-eks/actions/workflows/master.yml/badge.svg)](https://github.com/pulumi/pulumi-eks/actions/workflows/master.yml)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![npm version](https://badge.fury.io/js/@pulumi%2Feks.svg)](https://badge.fury.io/js/@pulumi%2Feks)
  [![Python version](https://badge.fury.io/py/pulumi-eks.svg)](https://pypi.org/project/pulumi-eks)
  [![NuGet version](https://badge.fury.io/nu/pulumi.eks.svg)](https://badge.fury.io/nu/pulumi.eks)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-eks/sdk/go/eks)](https://pkg.go.dev/github.com/pulumi/pulumi-eks/sdk/go/eks)



  The Pulumi EKS library provides a Pulumi component that creates and manages the resources necessary to run an EKS Kubernetes cluster in AWS. This component exposes the Crosswalk for AWS functionality documented in the [Pulumi Elastic Kubernetes Service guide](https://www.pulumi.com/docs/guides/crosswalk/aws/eks/) as a package available in all Pulumi languages.


  This includes:
  - The EKS cluster control plane.
  - The cluster's worker nodes configured as node groups, which are managed by an auto scaling group.
  - The AWS CNI Plugin [`aws-k8s-cni`](https://github.com/aws/amazon-vpc-cni-k8s/) to manage pod networking in Kubernetes.


  <div>
      <a href="https://www.pulumi.com/templates/kubernetes/aws/" title="Get Started">
         <img src="https://www.pulumi.com/images/get-started.svg?" width="120">
      </a>
  </div>



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install it using either `npm`:

  ```bash
  $ npm install @pulumi/eks
  ```

   or `yarn`:

  ```bash
  $ yarn add @pulumi/eks
  ```



  To use from Python, install using `pip`:

      $ pip install pulumi_eks



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-eks/sdk/go



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Eks



  * [Tutorial](https://www.pulumi.com/blog/easily-create-and-manage-aws-eks-kubernetes-clusters-with-pulumi/)
  * [Reference Documentation](https://www.pulumi.com/registry/packages/eks/api-docs/)
  * [Examples](./examples)
  * [Crosswalk for AWS - EKS Guide](https://www.pulumi.com/docs/guides/crosswalk/aws/eks/)



  If you are interested in contributing, please see the [contributing docs][contributing].



  Please follow the [code of conduct][code-of-conduct].

  [contributing]: CONTRIBUTING.md
  [code-of-conduct]: CODE-OF-CONDUCT.md


pkgId: ab96a0dbc6f6663793db86462735b13485f2bfbeef2dc28aced4392ff48f8d81
name: python-pulumi-equinix-help
arch: noarch
version: 0.20.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-equinix
url: https://deploy.equinix.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-equinix-0.20.0-1.src.rpm
location_href: Packages/python-pulumi-equinix-help-0.20.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/equinix/pulumi-equinix/workflows/main/badge.svg)](https://github.com/equinix/pulumi-equinix/actions)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fequinix.svg)](https://www.npmjs.com/package/@equinix-labs/pulumi-equinix)
  [![Python version](https://badge.fury.io/py/pulumi-equinix.svg)](https://pypi.org/project/pulumi-equinix)
  [![NuGet version](https://badge.fury.io/nu/pulumi.equinix.svg)](https://badge.fury.io/nu/pulumi.equinix)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/equinix/pulumi-equinix/sdk/go)](https://pkg.go.dev/github.com/equinix/pulumi-equinix/sdk/go)
  [![License](https://img.shields.io/github/license/equinix/pulumi-equinix)](https://github.com/equinix/pulumi-equinix/blob/main/LICENSE)



  **PLEASE NOTE:** *This provider supercedes the [Pulumi Equinix Metal provider](https://www.pulumi.com/registry/packages/equinix-metal/).

  The Equinix Resource Provider lets you manage [Equinix](http://deploy.equinix.com) resources (Metal, Fabric, and Network Edge).



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @equinix-labs/pulumi-equinix
  ```

  or `yarn`:

  ```bash
  yarn add @equinix-labs/pulumi-equinix
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi_equinix
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/equinix/pulumi-equinix/sdk/go/...
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.Equinix
  ```



  **PLEASE NOTE:** Java is currently in preview. For more details check out [pulumi java documentation](https://www.pulumi.com/docs/intro/languages/java/#how-to-use-java-with-pulumi).

  To use from Java, add the dependency below to your `pom.xml` file:

  ```
  <dependency>
      <groupId>com.equinix.pulumi</groupId>
      <artifactId>equinix</artifactId>
      <version>[0.1.0,)</version>
  </dependency>
  ```



  For information about obtaining API key and secret required for Equinix Fabric and Network Edge refer to [Generating Client ID and Client Secret key](https://developer.equinix.com/dev-docs/fabric/getting-started/getting-access-token#generating-client-id-and-client-secret) from [Equinix Developer Platform portal](https://developer.equinix.com/).

  Interacting with Equinix Metal requires an API auth token that can be generated at Project-level or User-level. User API keys can be obtained by creating them in the [Equinix Metal Portal](https://console.equinix.com/) or by using the [Create a User API Key](https://deploy.equinix.com/developers/api/metal/#operation/createAPIKey) endpoint. Project API keys can also be obtained by creating them in the [Equinix Metal Portal](https://console.equinix.com/) or by using the [Create a Project API Key](https://deploy.equinix.com/developers/api/metal/#operation/createProjectAPIKey) endpoint.

  If you are only using Equinix Metal resources, you may omit the Client ID and Client Secret provider configuration parameters needed to access other Equinix resource types (Network Edge, Fabric, etc).

  The following configuration points are available for the `equinix` provider:

  - `equinix:authToken` (environment: `METAL_AUTH_TOKEN`) - (Optional) the Equinix Metal API auth key for API operations.
  - `equinix:clientId` (environment: `EQUINIX_API_CLIENTID`) - (Optional) API Consumer Key available under My Apps section in Equinix developer portal.
  - `equinix:clientSecret` (environment: `EQUINIX_API_CLIENTSECRET`) - (Optional) API Consumer secret available under My Apps section in Equinix developer portal.

  Advanced configuration points:

  - `equinix:token` (environment: `EQUINIX_API_TOKEN`) - (Optional) API token from the developer sandbox. Token's can be generated for the API Client using the OAuth2 Token features described in the [OAuth2 API](https://developer.equinix.com/catalog/accesstokenv1#operation/GetOAuth2AccessToken) documentation. The `client_id` and `client_secret` arguments will be ignored in the presence of a token argument.
  - `equinix:endpoint` (environment: `EQUINIX_API_ENDPOINT`) - (Optional) the Equinix API base URL to point out desired environmen. Defaults to `https://api.equinix.com`.
  - `equinix:maxRetries` - (Optional) the maximum number of retries in case of network failure.
  - `equinix:maxRetryWaitSeconds` - (Optional) the maximum time to wait in case of network failure.
  - `equinix:requestTimeout` - (Optional) the duration of time, in seconds, that the Equinix Platform API Client should wait before canceling an API request. Defaults to 30.
  - `equinix:responseMaxPageSize` - (Optional) the maximum number of records in a single response for REST queries that produce paginated responses.



  For detailed reference documentation, please visit [Equinix API Docs in th Pulumi Registry](https://www.pulumi.com/registry/packages/equinix/api-docs/).


pkgId: e18d29bd2073a933db856929376f9b4a3984d9b821e728200d8f3e03b136f4ef
name: python-pulumi-external-help
arch: noarch
version: 0.0.11
epoch: 0
release: 1
summary: Development documents and examples for pulumi-external
url: https://www.pulumi.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-external-0.0.11-1.src.rpm
location_href: Packages/python-pulumi-external-help-0.0.11-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-external/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-external/actions)
  [![NPM version](https://img.shields.io/npm/v/@pulumi/external)](https://www.npmjs.com/package/@pulumi/external)
  [![Python version](https://img.shields.io/pypi/v/pulumi_external)](https://pypi.org/project/pulumi_external)
  [![NuGet version](https://img.shields.io/nuget/v/Pulumi.External)](https://www.nuget.org/packages/Pulumi.External)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-external/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-external/sdk/go)
  [![License](https://img.shields.io/github/license/pulumi/pulumi-external)](https://github.com/pulumi/pulumi-external/blob/master/LICENSE)



  This provider is mainly used for ease of converting terraform programs to Pulumi.
  When using standard Pulumi programs, you would not need to use this provider.

  The External resource provider for Pulumi lets you use External resources in your cloud programs.
  To use this package, please [install the Pulumi CLI first](https://www.pulumi.com/docs/install/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/external

  or `yarn`:

      $ yarn add @pulumi/external



  To use from Python, install using `pip`:

      $ pip install pulumi_external



  To use from Go, use `go get` to grab the latest version of the library:

      $ go get github.com/pulumi/pulumi-external/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.External

  <!-- If your provider has configuration, remove this comment and the comment tags below, updating the documentation. -->
  <!--



  The following Pulumi configuration can be used:

  - `external:token` - (Required) The API token to use with External. When not set, the provider will use the `EXTERNAL_TOKEN` environment variable.

  -->

  <!-- If your provider has reference material available elsewhere, remove this comment and the comment tags below, updating the documentation. -->
  <!--



  For further information, please visit [External reference documentation](https://example.com/external).

  -->


pkgId: 424e6c27d5b2f7c73d782b4781dde035bf99f795216422580f76641fa0e1061f
name: python-pulumi-f5bigip-help
arch: noarch
version: 3.17.7
epoch: 0
release: 1
summary: Development documents and examples for pulumi-f5bigip
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-f5bigip-3.17.7-1.src.rpm
location_href: Packages/python-pulumi-f5bigip-help-3.17.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-f5bigip/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-f5bigip/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Ff5bigip.svg)](https://www.npmjs.com/package/@pulumi/f5bigip)
  [![Python version](https://badge.fury.io/py/pulumi-f5bigip.svg)](https://pypi.org/project/pulumi-f5bigip)
  [![NuGet version](https://badge.fury.io/nu/pulumi.f5bigip.svg)](https://badge.fury.io/nu/pulumi.f5bigip)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-f5bigip/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-f5bigip/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-f5bigip/blob/master/LICENSE)



  This provider allows management of F5 BigIP resources using Pulumi. This provider uses the iControlREST API to
  perform management tasks, so it will need to be installed and enabled on your F5 device before proceeding.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/f5bigip

  or `yarn`:

      $ yarn add @pulumi/f5bigip



  To use from Python, install using `pip`:

      $ pip install pulumi_f5bigip



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-f5bigip/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.F5bigip



  The following configuration points are available:

  - `f5bigip:address` - Domain name/IP of the BigIP. May be set via the `BIGIP_HOST` environment variable.
  - `f5bigip:port` - Management Port to connect to BigIP.
  - `f5bigip:username` - Username with API access to the BigIP. May be set via the `BIGIP_USER` environment variable.
  - `f5bigip:password` - Password for API access to the BigIP. May be set via the `BIGIP_PASSWORD` environment variable.
  - `f5bigip:tokenAuth` - Enable to use an external authentication source (LDAP, TACACS, etc). May be set via the `BIGIP_TOKEN_AUTH` environment variable.
  - `f5bigip:tokenAuth` - Enable to use an external authentication source (LDAP, TACACS, etc). May be set via the `BIGIP_TOKEN_AUTH` environment variable.
  - `f5bigip:loginRef` - Login reference for token authentication (see BIG-IP REST docs for details) May be set via the `BIGIP_LOGIN_REF` environment variable.



  For further information, please visit [the F5bigip provider docs](https://www.pulumi.com/docs/intro/cloud-providers/f5bigip) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/f5bigip).


pkgId: 6c7ecd15374d52df0dbe6e5f96588b2c7e8139b2d40bb3ec2862fd7d19176de0
name: python-pulumi-fastly-help
arch: noarch
version: 8.13.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-fastly
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-fastly-8.13.0-1.src.rpm
location_href: Packages/python-pulumi-fastly-help-8.13.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-fastly/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-fastly/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Ffastly.svg)](https://www.npmjs.com/package/@pulumi/fastly)
  [![Python version](https://badge.fury.io/py/pulumi-fastly.svg)](https://pypi.org/project/pulumi-fastly)
  [![NuGet version](https://badge.fury.io/nu/pulumi.fastly.svg)](https://badge.fury.io/nu/pulumi.fastly)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-fastly/sdk/v8/go)](https://pkg.go.dev/github.com/pulumi/pulumi-fastly/sdk/v8/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-fastly/blob/master/LICENSE)



  The Fastly resource provider for Pulumi lets you manage Fastly resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/fastly

  or `yarn`:

      $ yarn add @pulumi/fastly



  To use from Python, install using `pip`:

      $ pip install pulumi_fastly



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-fastly/sdk/v8



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Fastly



  The following configuration points are available:

  - `fastly:apiKey` - (Required) This is the API key. It must be provided, but it can also be sourced from the `FASTLY_API_KEY`
    environment variable
  - `fastly:baseUrl` - (Optional) This is the API server hostname. It is required if using a private instance of the API and
    otherwise defaults to the public Fastly production service. It can also be sourced from the `FASTLY_API_URL` environment variable



  For further information, please visit [the Fastly provider docs](https://www.pulumi.com/docs/intro/cloud-providers/fastly) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/fastly).


pkgId: 75b236ed2d346dcdef7cd9a2de2833c44bec557ca56f6d4f204f4d6268017a83
name: python-pulumi-gcp-help
arch: noarch
version: 8.10.2
epoch: 0
release: 1
summary: Development documents and examples for pulumi-gcp
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-gcp-8.10.2-1.src.rpm
location_href: Packages/python-pulumi-gcp-help-8.10.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-gcp/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-gcp/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fgcp.svg)](https://npmjs.com/package/@pulumi/gcp)
  [![NuGet version](https://badge.fury.io/nu/pulumi.gcp.svg)](https://badge.fury.io/nu/pulumi.gcp)
  [![Python version](https://badge.fury.io/py/pulumi-gcp.svg)](https://pypi.org/project/pulumi-gcp)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-gcp/sdk/v6/go)](https://pkg.go.dev/github.com/pulumi/pulumi-gcp/sdk/v6/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-gcp/blob/master/LICENSE)



  The Google Cloud Platform (GCP) resource provider for Pulumi lets you use GCP resources in your cloud programs. To use
  this package, [install the Pulumi CLI](https://www.pulumi.com/docs/get-started/install/). For a streamlined Pulumi walkthrough, including language runtime installation and GCP configuration, select "Get Started" below.

  <div>
      <a href="https://www.pulumi.com/docs/get-started/gcp" title="Get Started">
         <img src="https://www.pulumi.com/images/get-started.svg?" width="120">
      </a>
  </div>



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/gcp

  or `yarn`:

      $ yarn add @pulumi/gcp



  To use from Python, install using `pip`:

      $ pip install pulumi_gcp



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-gcp/sdk/v6



  To use from .NET, install using `dotnet add package`:

     $ dotnet add package Pulumi.Gcp



  For further information, visit [GCP in the Pulumi Registry](https://www.pulumi.com/registry/packages/gcp/)
  or for detailed API reference documentation, visit [GCP API Docs in the Pulumi Registry](https://www.pulumi.com/registry/packages/gcp/api-docs/).


pkgId: c6365345ef77953b25e10e63e6221c93feccd7fb68103314ca96bf29ed328713
name: python-pulumi-github-help
arch: noarch
version: 6.4.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-github
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-github-6.4.0-1.src.rpm
location_href: Packages/python-pulumi-github-help-6.4.0-1.noarch.rpm
checksum_type: sha256
description:
  The GitHub resource provider for Pulumi lets you use GitHub resources in your infrastructure programs.
  To use this package, please [install the Pulumi CLI first](https://pulumi.io/reference/cli/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/github

  or `yarn`:

      $ yarn add @pulumi/github



  To use from Python, install using `pip`:

      $ pip install pulumi-github



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-github/sdk/v6



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Github



  The following configuration points are available:

  - `github:token` - (Optional) This is the GitHub personal access token. It can also be sourced from the `GITHUB_TOKEN`
    environment variable. If anonymous is false, token is required.
  - `github:baseUrl` - (Optional) This is the target GitHub base API endpoint. Providing a value is a requirement when
    working with GitHub Enterprise. It is optional to provide this value and it can also be sourced from the `GITHUB_BASE_URL`
    environment variable. The value must end with a slash, and generally includes the API version, for instance
    `https://github.someorg.example/api/v3/`.
  - `github:owner` - (Optional) This is the target GitHub organization or individual user account to manage. For example,
    `torvalds` and `github` are valid owners. It is optional to provide this value and it can also be sourced from the
    `GITHUB_OWNER` environment variable. When not provided and a token is available, the individual user account owning
    the token will be used. When not provided and no token is available, the provider may not function correctly.
  - `github:organization` - (Deprecated) This behaves the same as owner, which should be used instead. This value can also
    be sourced from the `GITHUB_ORGANIZATION` environment variable.



  For further information, please visit [the GitHub provider docs](https://www.pulumi.com/docs/intro/cloud-providers/github)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/github).


pkgId: 6fc2afdb855fa290a18efec71d9ba8191c8cbcf34bb671f652d6482614a3abe1
name: python-pulumi-gitlab-help
arch: noarch
version: 8.6.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-gitlab
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-gitlab-8.6.1-1.src.rpm
location_href: Packages/python-pulumi-gitlab-help-8.6.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-gitlab/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-gitlab/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fgitlab.svg)](https://www.npmjs.com/package/@pulumi/gitlab)
  [![Python version](https://badge.fury.io/py/pulumi-gitlab.svg)](https://pypi.org/project/pulumi-gitlab)
  [![NuGet version](https://badge.fury.io/nu/pulumi.gitlab.svg)](https://badge.fury.io/nu/pulumi.gitlab)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-gitlab/sdk/v6/go)](https://pkg.go.dev/github.com/pulumi/pulumi-gitlab/sdk/v6/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-gitlab/blob/master/LICENSE)



  The GitLab resource provider for Pulumi lets you use GitLab resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/gitlab

  or `yarn`:

      $ yarn add @pulumi/gitlab



  To use from Python, install using `pip`:

      $ pip install pulumi_gitlab



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-gitlab/sdk/v7



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Gitlab



  The `@pulumi/gitlab` package provides a strongly-typed means to create cloud applications that create and interact
  closely with GitLab resources.



  The following configuration points are available:

  * token (Optional) - This is the GitLab personal access token. It must be provided but can also be sourced via `GITLAB_TOKEN`.

  * baseUrl (Optional) - This is the target GitLab base API endpoint. Providing a value is a requirement when working with GitLab CE or GitLab Enterprise e.g. https://my.gitlab.server/api/v4/. It is optional to provide this value and it can also be sourced from the GITLAB_BASE_URL environment variable. The value must end with a slash.

  * cacertFile (Optional) - This is a file containing the ca cert to verify the gitlab instance. This is available for use when working with GitLab CE or Gitlab Enterprise with a locally-issued or self-signed certificate chain.

  * insecure (Optional) - When set to true this disables SSL verification of the connection to the GitLab instance. Defaults to `false`.




  For further information, please visit [the GitLab provider docs](https://www.pulumi.com/docs/intro/cloud-providers/gitlab) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/gitlab).


pkgId: cd2508d69796885a31e2ddb3ff18d2a3b52bbd1debf60b1480d241aadd45a5a9
name: python-pulumi-harness-help
arch: noarch
version: 0.4.6
epoch: 0
release: 1
summary: Development documents and examples for pulumi-harness
url: https://www.pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-harness-0.4.6-1.src.rpm
location_href: Packages/python-pulumi-harness-help-0.4.6-1.noarch.rpm
checksum_type: sha256
description:
  The Harness resource provider for Pulumi lets you create resources in [Harness](https://www.harness.io). To use
  this package, please [install the Pulumi CLI first](https://pulumi.com/).



  This package is available in many languages in standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```
  $ npm install @pulumi/harness
  ```

  or `yarn`:

  ```
  $ yarn add @pulumi/harness
  ```



  To use from Python, install using `pip`:

  ```
  $ pip install pulumi-harness
  ```



  To use from Go, use `go get` to grab the latest version of the library

  ```
  $ go get github.com/pulumi/pulumi-harness/sdk/go/...
  ```



  To use from Dotnet, use `dotnet add package` to install into your project. You must specify the version if it is a pre-release version.


  ```
  $ dotnet add package Pulumi.Harness
  ```



  See the Pulumi registry for API docs:

  https://www.pulumi.com/registry/packages/Harness/api-docs/


pkgId: 5057c47a4c18fe8237bfc66bf8cbcd5aef160101f6c7d8bd8e9083da838766f5
name: python-pulumi-hcloud-help
arch: noarch
version: 1.21.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-hcloud
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-hcloud-1.21.1-1.src.rpm
location_href: Packages/python-pulumi-hcloud-help-1.21.1-1.noarch.rpm
checksum_type: sha256
description:
  The HCloud resource provider for Pulumi lets you use Hetzner Cloud resources in your infrastructure
  programs. To use this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/hcloud

  or `yarn`:

      $ yarn add @pulumi/hcloud



  To use from Python, install using `pip`:

      $ pip install pulumi-hcloud



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-hcloud/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.HCloud



  The following configuration points are available:

  - `hcloud:token` - (Optional) This is the Hetzner Cloud API Token, can also be specified with the `HCLOUD_TOKEN` environment variable.
  - `hcloud:endpoint` - (Optional) Hetzner Cloud API endpoint, can be used to override the default API Endpoint `https://api.hetzner.cloud/v1`.
  - `hcloud:pollInterval` - (Optional) Configures the interval in which actions are polled by the client. Default `500ms`. Increase this interval if you run into rate limiting errors.




  For further information, please visit [the HCloud provider docs](https://www.pulumi.com/docs/intro/cloud-providers/hcloud) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/hcloud).


pkgId: b14e4f838d4c9a477f5f0501002937224e19194c37a89cca4ad2973c5f1b688f
name: python-pulumi-http-help
arch: noarch
version: 0.0.10
epoch: 0
release: 1
summary: Development documents and examples for pulumi-http
url: https://www.pulumi.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-http-0.0.10-1.src.rpm
location_href: Packages/python-pulumi-http-help-0.0.10-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-http/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-http/actions)
  [![NPM version](https://img.shields.io/npm/v/@pulumi/http)](https://www.npmjs.com/package/@pulumi/http)
  [![Python version](https://img.shields.io/pypi/v/pulumi_http)](https://pypi.org/project/pulumi_http)
  [![NuGet version](https://img.shields.io/nuget/v/Pulumi.Http)](https://www.nuget.org/packages/Pulumi.Http)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-http/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-http/sdk/go)
  [![License](https://img.shields.io/github/license/pulumi/pulumi-http)](https://github.com/pulumi/pulumi-http/blob/master/LICENSE)



  This provider is mainly used for ease of converting terraform programs to Pulumi.
  For standard use in Pulumi programs, please use your programming language's standard http library.

  The HTTP resource provider for Pulumi lets you use HTTP resources in your cloud programs.
  To use this package, please [install the Pulumi CLI first](https://www.pulumi.com/docs/install/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/http

  or `yarn`:

      $ yarn add @pulumi/http



  To use from Python, install using `pip`:

      $ pip install pulumi_http



  To use from Go, use `go get` to grab the latest version of the library:

      $ go get github.com/pulumi/pulumi-http/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Http

  <!-- If your provider has configuration, remove this comment and the comment tags below, updating the documentation. -->
  <!--



  The following Pulumi configuration can be used:

  - `http:token` - (Required) The API token to use with HTTP. When not set, the provider will use the `HTTP_TOKEN` environment variable.

  -->

  <!-- If your provider has reference material available elsewhere, remove this comment and the comment tags below, updating the documentation. -->
  <!--



  For further information, please visit [HTTP reference documentation](https://example.com/http).

  -->


pkgId: c46f809f01348888b8f21ee6eb8ce6323b882ece3404085b65d3cc912184b1a4
name: python-pulumi-ise-help
arch: noarch
version: 0.1.12
epoch: 0
release: 1
summary: Development documents and examples for pulumi-ise
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-ise-0.1.12-1.src.rpm
location_href: Packages/python-pulumi-ise-help-0.1.12-1.noarch.rpm
checksum_type: sha256
description:
  A Pulumi package for managing resources on a [Cisco ISE](https://www.pulumi.com/registry/packages/ise/) (Identity Service Engine) instance.



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/ise
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/ise
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi_ise
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pulumi/pulumi-ise/sdk/go/...
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.Ise
  ```



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/ise/api-docs/).


pkgId: 30e8f20412d2761db06bcb9e08cd9648e897ee514295f9eeed16c4a62b230450
name: python-pulumi-juniper-mist-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for pulumi-juniper-mist
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-juniper-mist-0.1.3-1.src.rpm
location_href: Packages/python-pulumi-juniper-mist-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  The Juniper Mist Resource Provider lets you manage Juniper Mist resources.



  This package is available for several languages/platforms:

  - JavaScript/TypeScript: [`@pulumi/juniper-mist`](https://www.npmjs.com/package/@pulumi/juniper-mist)
  - Python: [`pulumi-juniper-mist`](https://pypi.org/project/pulumi-juniper-mist/)
  - Go: [`github.com/pulumi/pulumi-juniper-mist/sdk/go/junipermist`](https://pkg.go.dev/github.com/pulumi/pulumi-junipermist/sdk/go/junipermist)
  - .NET: [`Pulumi.JuniperMist`](https://www.nuget.org/packages/Pulumi.JuniperMist)



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/juniper-mist
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/juniper-mist
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi-juniper-mist
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pulumi/pulumi-junipermist/sdk/go/junipermist
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.JuniperMist
  ```


pkgId: 39e9aed5ad693db516bd4c0eb4b1b4070df59e125006242a9b8bf4ebdb70c31a
name: python-pulumi-kafka-help
arch: noarch
version: 3.8.2
epoch: 0
release: 1
summary: Development documents and examples for pulumi-kafka
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-kafka-3.8.2-1.src.rpm
location_href: Packages/python-pulumi-kafka-help-3.8.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-kafka/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-kafka/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fkafka.svg)](https://www.npmjs.com/package/@pulumi/kafka)
  [![Python version](https://badge.fury.io/py/pulumi-kafka.svg)](https://pypi.org/project/pulumi-kafka)
  [![NuGet version](https://badge.fury.io/nu/pulumi.kafka.svg)](https://badge.fury.io/nu/pulumi.kafka)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-kafka/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-kafka/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-kafka/blob/master/LICENSE)



  The Kafka resource provider for Pulumi lets you manage Kafka resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/kafka

  or `yarn`:

      $ yarn add @pulumi/kafka



  To use from Python, install using `pip`:

      $ pip install pulumi_kafka



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-kafka/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Kafka



  The following configuration points are available:

  * kafka:bootstrapServers - (Required) A list of host:port addresses that will be used to discover the full set of alive brokers.
  * kafka:caCert - (Optional) The CA certificate or path to a CA certificate file to validate the server's certificate.
  * kafka:clientCert - (Optional) The client certificate or path to a file containing the client certificate -- Use for Client authentication to Kafka.
  * kafka:clientKey - (Optional) The private key or path to a file containing the private key that the client certificate was issued for.
  * kafka:skipTlsVerify - (Optional) Skip TLS verification. Default `false`.
  * kafka:tlsEnabled - (Optional) Enable communication with the Kafka Cluster over TLS. Default `false`.
  * kafka:saslUsername - (Optional) Username for SASL authentication.
  * kafka:saslPassword - (Optional) Password for SASL authentication.
  * kafka:saslMechanism - (Optional) Mechanism for SASL authentication. Allowed values are `plain`, `scram-sha512` and `scram-sha256`. Default `plain`.
  * kafka:timeout - (Optional) Timeout in seconds. Default `120`.



  For further information, please visit [the Kafka provider docs](https://www.pulumi.com/docs/intro/cloud-providers/kafka) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/kafka).


pkgId: 324ec59097284c5efc099a36f05fea31f3c0baa0d1498dce7b52225bccf4637b
name: python-pulumi-keycloak-help
arch: noarch
version: 5.4.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-keycloak
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-keycloak-5.4.0-1.src.rpm
location_href: Packages/python-pulumi-keycloak-help-5.4.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-keycloak/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-keycloak/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fkeycloak.svg)](https://www.npmjs.com/package/@pulumi/keycloak)
  [![Python version](https://badge.fury.io/py/pulumi-keycloak.svg)](https://pypi.org/project/pulumi-keycloak)
  [![NuGet version](https://badge.fury.io/nu/pulumi.keycloak.svg)](https://badge.fury.io/nu/pulumi.keycloak)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-keycloak/sdk/v5/go)](https://pkg.go.dev/github.com/pulumi/pulumi-keycloak/sdk/v5/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-keycloak/blob/master/LICENSE)



  The Keycloak resource provider for Pulumi lets you manage Keycloak resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://www.pulumi.com/docs/reference/cli/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/keycloak

  or `yarn`:

      $ yarn add @pulumi/keycloak



  To use from Python, install using `pip`:

      $ pip install pulumi_keycloak



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-keycloak/sdk/v5



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Keycloak



  The following configuration points are available:

  - `keycloak:clientId` - (Required) The client_id for the client that was created in the "Keycloak Setup" section.
    Use the admin-cli client if you are using the password grant. Defaults to the environment variable `KEYCLOAK_CLIENT_ID`.
  - `keycloak:url` - (Required) - The URL of the Keycloak instance, before /auth/admin. Defaults to the environment
    variable `KEYCLOAK_URL`.
  - `keycloak:clientSecret` - (Optional) The secret for the client used by the provider for authentication via the client
    credentials grant. This can be found or changed using the "Credentials" tab in the client settings. Defaults to the
    environment variable `KEYCLOAK_CLIENT_SECRET`. This attribute is required when using the client credentials grant,
    and cannot be set when using the password grant.
  - `keycloak:username`- (Optional) The username of the user used by the provider for authentication via the password grant.
    Defaults to environment variable `KEYCLOAK_USER`. This attribute is required when using the password grant, and cannot
    be set when using the client credentials grant.
  - `keycloak:password`- (Optional) The password of the user used by the provider for authentication via the password grant. Defaults to
    environment variable `KEYCLOAK_PASSWORD`. This attribute is required when using the password grant, and cannot be set when
    using the client credentials grant.
  - `keycloak:realm` - (Optional) The realm used by the provider for authentication. Defaults to environment variable
    `KEYCLOAK_REALM`, or `master` if the environment variable is not specified.
  - `keycloak:initialLogin` - (Optional) Optionally avoid Keycloak login during provider setup, for when Keycloak itself
    is being provisioned by terraform. Defaults to `true`, which is the original method.
  - `keycloak:clientTimeout` - (Optional) Sets the timeout of the client when addressing Keycloak, in seconds. Defaults to `5`.



  For further information, please visit [the Keycloak provider docs](https://www.pulumi.com/docs/intro/cloud-providers/keycloak) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/keycloak).


pkgId: 8dfbc187cbef5f13e61916807377770fb0b28ad689ee27d86a07ffa006bd3fc0
name: python-pulumi-kong-help
arch: noarch
version: 4.5.7
epoch: 0
release: 1
summary: Development documents and examples for pulumi-kong
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-kong-4.5.7-1.src.rpm
location_href: Packages/python-pulumi-kong-help-4.5.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-kong/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-kong/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fkong.svg)](https://www.npmjs.com/package/@pulumi/kong)
  [![Python version](https://badge.fury.io/py/pulumi-kong.svg)](https://pypi.org/project/pulumi-kong)
  [![NuGet version](https://badge.fury.io/nu/pulumi.kong.svg)](https://badge.fury.io/nu/pulumi.kong)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-kong/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-kong/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-kong/blob/master/LICENSE)



  The Kong resource provider for Pulumi lets you manage Kong resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://www.mailgun.com//).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/kong

  or `yarn`:

      $ yarn add @pulumi/kong



  To use from Python, install using `pip`:

      $ pip install pulumi_kong



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-kong/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Kong



  The following configuration points are available:

  - `kong:kongAdminUri` - The url of the kong admin api. May be set via the `KONG_ADMIN_ADDR` environment variable. Defaults to `http://localhost:8001`.
  - `kong:kongAdminUsername` - Username for the kong admin api. May be set via the `KONG_ADMIN_USERNAME` environment variable.
  - `kong:kongAdminPassword` - Password for the kong admin api. May be set via the `KONG_ADMIN_PASSWORD` environment variable.
  - `kong:tlsSkipVerify` - Whether to skip tls certificate verification for the kong api when using https. May be set via the `TLS_SKIP_VERIFY` environment variable. Defaults to `false`.
  - `kong:kongApiKey` - API key used to secure the kong admin API. May be set via the `KONG_API_KEY` environment variable.
  - `kong:kongAdminToken` - API key used to secure the kong admin API in the Enterprise Edition. May be set via the `KONG_ADMIN_TOKEN` environment variable.
  - `kong:strictPluginsMatch` - Should plugins `config_json` field strictly match plugin configuration. May be set via the `STRICT_PLUGINS_MATCH` environment variable. Defaults to `false`.



  For further information, please visit [the Kong provider docs](https://www.pulumi.com/docs/intro/cloud-providers/kong) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/kong).


pkgId: 79dea914b5d810792d88a60958c28e9af5b82063cd11f538c57fad3651aec2ee
name: python-pulumi-kubernetes-cert-manager-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for pulumi-kubernetes-cert-manager
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-kubernetes-cert-manager-0.0.7-1.src.rpm
location_href: Packages/python-pulumi-kubernetes-cert-manager-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  This repo contains the Pulumi Cert Manager component for Kubernetes. This add-on automates the
  management and issuance of TLS certificates from various issuing sources. It ensures certificates
  are valid and up to date periodically, and attempts to renew certificates at an appropriate time
  before expiry.

  This component wraps [the Jetstack Cert Manager Helm Chart](https://github.com/jetstack/cert-manager),
  and offers a Pulumi-friendly and strongly-typed way to manage Cert Manager installations.

  For examples of usage, see [the official documentation](https://cert-manager.io/docs/),
  or refer to [the examples](/examples) in this repo.



  To use this component, first install the Pulumi Package:

  Afterwards, import the library and instantiate it within your Pulumi program:



  This component supports all of the configuration options of the [official Helm chart](
  https://github.com/jetstack/cert-manager/tree/master/deploy/charts/cert-manager), except that these
  are strongly typed so you will get IDE support and static error checking.

  The Helm deployment uses reasonable defaults, including the chart name and repo URL, however,
  if you need to override them, you may do so using the `helmOptions` parameter. Refer to
  [the API docs for the `kubernetes:helm/v3:Release` Pulumi type](
  https://www.pulumi.com/docs/reference/pkg/kubernetes/helm/v3/release/#inputs) for a full set of choices.

  For complete details, refer to the Pulumi Package details within the Pulumi Registry.


pkgId: 9bdc70c7b69625c7c3894489214eba464f40485cb2f185d211bd1c51f1856217
name: python-pulumi-libvirt-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for pulumi-libvirt
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-libvirt-0.5.3-1.src.rpm
location_href: Packages/python-pulumi-libvirt-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-libvirt/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-libvirt/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Flibvirt.svg)](https://www.npmjs.com/package/@pulumi/libvirt)
  [![Python version](https://badge.fury.io/py/pulumi-libvirt.svg)](https://pypi.org/project/pulumi-libvirt)
  [![NuGet version](https://badge.fury.io/nu/pulumi.libvirt.svg)](https://badge.fury.io/nu/pulumi.libvirt)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-libvirt/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-libvirt/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-libvirt/blob/master/LICENSE)



  The libvirt Resource Provider lets you manage libvirt resources.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/libvirt

  or `yarn`:

      $ yarn add @pulumi/libvirt



  To use from Python, install using `pip`:

      $ pip install pulumi_libvirt



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-libvirt/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Libvirt



  The following configuration points are available:

  - `libvirt:uri` - (Required) The [connection URI](https://libvirt.org/uri.html) used to connect to the libvirt host.
    It can also be sourced from the `LIBVIRT_DEFAULT_URI` environment variable.



  For further information, please visit [the libvirt provider docs](https://www.pulumi.com/docs/intro/cloud-providers/libvirt)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/libvirt).


pkgId: beb7ebac2245a3bcfdf4326b96a1e5e979f11680376d55f0c42f296b70576d2e
name: python-pulumi-linode-help
arch: noarch
version: 4.30.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-linode
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-linode-4.30.1-1.src.rpm
location_href: Packages/python-pulumi-linode-help-4.30.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-linode/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-linode/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Flinode.svg)](https://www.npmjs.com/package/@pulumi/linode)
  [![Python version](https://badge.fury.io/py/pulumi-linode.svg)](https://pypi.org/project/pulumi-linode)
  [![NuGet version](https://badge.fury.io/nu/pulumi.linode.svg)](https://badge.fury.io/nu/pulumi.linode)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-linode/sdk/v4/go)](https://pkg.go.dev/github.com/pulumi/pulumi-linode/sdk/v4/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-linode/blob/master/LICENSE)



  The Linode resource provider for Pulumi lets you use Linode resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/linode

  or `yarn`:

      $ yarn add @pulumi/linode



  To use from Python, install using `pip`:

      $ pip install pulumi_linode



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-linode/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Linode



  The following configuration points are available:

  - `linode:token` - (Required) This is your Linode APIv4 Token. May be specified using the `LINODE_TOKEN` environment variable.
  - `linode:url` - (Optional) The HTTP(S) API address of the Linode API to use. May be specified using the `LINODE_URL` environment variable.
  - `linode:uaPrefix` - (Optional) An HTTP User-Agent Prefix to prepend in API requests. May be specified using the `LINODE_UA_PREFIX` environment variable.



  For further information, please visit [the Linode provider docs](https://www.pulumi.com/docs/intro/cloud-providers/linode) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/linode).


pkgId: b18dbe73abc31e8e0376e2b9ada5db3dcae163891da747928c4d8c290a5f8002
name: python-pulumi-mailgun-help
arch: noarch
version: 3.5.7
epoch: 0
release: 1
summary: Development documents and examples for pulumi-mailgun
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-mailgun-3.5.7-1.src.rpm
location_href: Packages/python-pulumi-mailgun-help-3.5.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-mailgun/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-mailgun/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fmailgun.svg)](https://www.npmjs.com/package/@pulumi/mailgun)
  [![Python version](https://badge.fury.io/py/pulumi-mailgun.svg)](https://pypi.org/project/pulumi-mailgun)
  [![NuGet version](https://badge.fury.io/nu/pulumi.mailgun.svg)](https://badge.fury.io/nu/pulumi.mailgun)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-mailgun/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-mailgun/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-mailgun/blob/master/LICENSE)



  The Mailgun resource provider for Pulumi lets you manage Mailgun resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://www.mailgun.com//).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/mailgun

  or `yarn`:

      $ yarn add @pulumi/mailgun



  To use from Python, install using `pip`:

      $ pip install pulumi_mailgun



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-mailgun/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Mailgun



  The following configuration points are available:

  - `mailgun:apikey` - (Required) Key used to authentication to the Mailgun API. May be set via the `MAILGUN_API_KEY` environment variable.



  For further information, please visit [the Mailgun provider docs](https://www.pulumi.com/docs/intro/cloud-providers/mailgun) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/mailgun).


pkgId: 97cb70192e9ac9def74f80ae5562b50ad458fbeae59f7bf210e19fcd7ad4645d
name: python-pulumi-meraki-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for pulumi-meraki
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-meraki-0.3.4-1.src.rpm
location_href: Packages/python-pulumi-meraki-help-0.3.4-1.noarch.rpm
checksum_type: sha256
description:
  The Cisco Meraki Resource Provider lets you manage [meraki](https://www.pulumi.com/registry/packages/meraki/) resources.



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/meraki
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/meraki
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi_meraki
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pulumi/pulumi-meraki/sdk/go/...
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.Meraki
  ```



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/meraki/api-docs/).


pkgId: ac6669c1c06913d3421a2ec59e8fca5e3292603c24482924cc54f9c2458f0109
name: python-pulumi-minio-help
arch: noarch
version: 0.16.2
epoch: 0
release: 1
summary: Development documents and examples for pulumi-minio
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-minio-0.16.2-1.src.rpm
location_href: Packages/python-pulumi-minio-help-0.16.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-minio/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-minio/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fminio.svg)](https://www.npmjs.com/package/@pulumi/minio)
  [![Python version](https://badge.fury.io/py/pulumi-minio.svg)](https://pypi.org/project/pulumi-minio)
  [![NuGet version](https://badge.fury.io/nu/pulumi.minio.svg)](https://badge.fury.io/nu/pulumi.minio)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-minio/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-minio/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-minio/blob/master/LICENSE)



  The Minio Resource Provider lets you manage releases in a Minio installation.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/minio

  or `yarn`:

      $ yarn add @pulumi/minio



  To use from Python, install using `pip`:

      $ pip install pulumi_minio



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-minio/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Minio



  The following configuration points are available:

  * `minio:minioServer` - (Required) Minio Host and Port. It must be provided, but
    it can also be sourced from the `MINIO_ENDPOINT` environment variable
  * `minio:minioAccessKey` - (Required) Minio Access Key. It must be provided, but
    it can also be sourced from the `MINIO_ACCESS_KEY` environment variable
  * `minio:minioSecretKey` - (Required) Minio Secret Key. It must be provided, but
    it can also be sourced from the `MINIO_SECRET_KEY` environment variable
  * `minio:minioRegion` - (Optional) Minio Region (`default: us-east-1`).
  * `minio:minioApiVersion` - (Optional) Minio API Version (type: string, options: `v2` or `v4`, default: `v4`).
  * `minio:minioSsl` - (Optional) Minio SSL enabled (default: `false`). It can also be sourced from the
    `MINIO_ENABLE_HTTPS` environment variable




  For further information, please visit [the Minio provider docs](https://www.pulumi.com/docs/intro/cloud-providers/minio)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/minio).


pkgId: 6740982e95f3a01cbd3ce2b52b5fac20ec3a084f9ed356ac4169bb6ee327e75a
name: python-pulumi-mongodbatlas-help
arch: noarch
version: 3.21.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-mongodbatlas
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-mongodbatlas-3.21.0-1.src.rpm
location_href: Packages/python-pulumi-mongodbatlas-help-3.21.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-mongodbatlas/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-mongodbatlas/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fmongodbatlas.svg)](https://www.npmjs.com/package/@pulumi/mongodbatlas)
  [![Python version](https://badge.fury.io/py/pulumi-mongodbatlas.svg)](https://pypi.org/project/pulumi-mongodbatlas)
  [![NuGet version](https://badge.fury.io/nu/pulumi.mongodbatlas.svg)](https://badge.fury.io/nu/pulumi.mongodbatlas)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-mongodbatlas/sdk/v2/go)](https://pkg.go.dev/github.com/pulumi/pulumi-mongodbatlas/sdk/v2/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-mongodbatlas/blob/master/LICENSE)



  The MongoDB Atlas resource provider for Pulumi lets you interact with MongoDB Atlas in your infrastructure
  programs. To use this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/mongodbatlas

  or `yarn`:

      $ yarn add @pulumi/mongodbatlas



  To use from Python, install using `pip`:

      $ pip install pulumi-mongodbatlas



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-mongodbatlas/sdk/v2



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Mongodbatlas



  The following configuration points are available:

  - `mongodbatlas:publicKey` - (Optional) This is the MongoDB Atlas API public_key. It must be provided, but it can also be
    sourced from the `MONGODB_ATLAS_PUBLIC_KEY` environment variable.
  - `mongodbatlas:privateKey` - (Optional) This is the MongoDB Atlas private_key. It must be provided, but it can also be
    sourced from the `MONGODB_ATLAS_PRIVATE_KEY` environment variable.



  For further information, please visit [the MongoDB Atlas provider docs](https://www.pulumi.com/docs/intro/cloud-providers/mongodbatlas) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/mongodbatlas).


pkgId: c30817ec5b15a8e4e4596cc973f0948b8c4dafd495f050d6177a5b9cdfe2f305
name: python-pulumi-mysql-help
arch: noarch
version: 3.2.8
epoch: 0
release: 1
summary: Development documents and examples for pulumi-mysql
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-mysql-3.2.8-1.src.rpm
location_href: Packages/python-pulumi-mysql-help-3.2.8-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-mysql/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-mysql/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fmysql.svg)](https://www.npmjs.com/package/@pulumi/mysql)
  [![Python version](https://badge.fury.io/py/pulumi-mysql.svg)](https://pypi.org/project/pulumi-mysql)
  [![NuGet version](https://badge.fury.io/nu/pulumi.mysql.svg)](https://badge.fury.io/nu/pulumi.mysql)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-mysql/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-mysql/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-mysql/blob/master/LICENSE)



  The MySQL resource provider for Pulumi lets you manage MySQL resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/mysql

  or `yarn`:

      $ yarn add @pulumi/mysql



  To use from Python, install using `pip`:

      $ pip install pulumi_mysql



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-mysql/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Mysql



  The following configuration points are available:

  - `mysql:endpoint` (required) - The address of the MySQL server to use. Most often a "hostname:port" pair, but may also
    be an absolute path to a Unix socket when the host OS is Unix-compatible. Can be set via `MYSQL_ENDPOINT` environment variable.
  - `mysql:username` (required) - Username to use to authenticate with the server. Can be set via `MYSQL_USERNAME` environment variable.
  - `mysql:password` - (optional) Password for the given user, if that user has a password. Can be set via `MYSQL_PASSWORD` environment variable.
  - `mysql:tls` - (optional) The TLS configuration. One of false, true, or skip-verify. Defaults to `false`. Can be set via
    `MYSQL_TLS_CONFIG` environment variable.
  - `mysql:proxy` - (Optional) Proxy socks url, can also be sourced from `ALL_PROXY` or `all_proxy` environment variables.



  For further information, please visit [the MySQL provider docs](https://www.pulumi.com/docs/intro/cloud-providers/mysql) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/mysql).


pkgId: 6998173f64fd416392b52597851e68a2b1030c64a24faa97a1630bb198cc26d4
name: python-pulumi-newrelic-help
arch: noarch
version: 5.37.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-newrelic
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-newrelic-5.37.0-1.src.rpm
location_href: Packages/python-pulumi-newrelic-help-5.37.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-newrelic/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-newrelic/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fnewrelic.svg)](https://www.npmjs.com/package/@pulumi/newrelic)
  [![Python version](https://badge.fury.io/py/pulumi-newrelic.svg)](https://pypi.org/project/pulumi-newrelic)
  [![NuGet version](https://badge.fury.io/nu/pulumi.newrelic.svg)](https://badge.fury.io/nu/pulumi.newrelic)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-newrelic/sdk/v5/go)](https://pkg.go.dev/github.com/pulumi/pulumi-newrelic/sdk/v5/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-newrelic/blob/master/LICENSE)



  The New Relic resource provider for Pulumi lets you use New Relic resources in your cloud programs.
  To use this package, please [install the Pulumi CLI first][1].



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/newrelic

  or `yarn`:

      $ yarn add @pulumi/newrelic



  To use from Python, install using `pip`:

      $ pip install pulumi_newrelic



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-newrelic/sdk/v5




  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Newrelic



  The following configuration points are available:

  - `newrelic:apiKey` - Your New Relic API key. The `NEW_RELIC_API_KEY` environment variable can also be used.
  - `newrelic:adminApiKey` - Your New Relic Admin API key. The `NEW_RELIC_ADMIN_API_KEY` environment variable can also be used.
  - `newrelic:region` - The region for the data center for which your New Relic account is configured. The New Relic region
    can also be set via the environment variable `NEW_RELIC_REGION`. Valid values are `US` or `EU`. Only one region per
    provider block can be configured. If you have accounts in both regions, you must instantiate two providers -
    one for US and one for EU
  - `newrelic:insecureSkipVerify` - Trust self-signed SSL certificates. If omitted, the `NEW_RELIC_API_SKIP_VERIFY` environment
    variable is used.
  - `newrelic:insightsInsertKey` - Your Insights insert key used when inserting Insights events via the `insights.Event` resource.
    Can also use `NEW_RELIC_INSIGHTS_INSERT_KEY` environment variable.
  - `newrelic:insightsInsertUrl` - This argument changes the Insights insert URL (default is `https://insights-collector.newrelic.com/v1/accounts`).
    If the New Relic account is in the EU, the Insights API URL must be set to `https://insights-collector.eu.newrelic.com/v1`.
  - `newrelic:caCerts` - A path to a PEM-encoded certificate authority used to verify the remote agent's certificate. The
    `NEW_RELIC_API_CACERT` environment variable can also be used.



  For further information, please visit [the NewRelic provider docs](https://www.pulumi.com/docs/intro/cloud-providers/newrelic) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/newrelic).


  [1]: https://www.pulumi.com/docs


pkgId: 808a490f042ebea1ee094ef5d84d8d9c15425d9a13779f9d71d76c553cb23e69
name: python-pulumi-nomad-help
arch: noarch
version: 2.4.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-nomad
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-nomad-2.4.1-1.src.rpm
location_href: Packages/python-pulumi-nomad-help-2.4.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-nomad/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-nomad/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fnomad.svg)](https://www.npmjs.com/package/@pulumi/nomad)
  [![Python version](https://badge.fury.io/py/pulumi-nomad.svg)](https://pypi.org/project/pulumi-nomad)
  [![NuGet version](https://badge.fury.io/nu/pulumi.nomad.svg)](https://badge.fury.io/nu/pulumi.nomad)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-nomad/sdk/v2/go)](https://pkg.go.dev/github.com/pulumi/pulumi-nomad/sdk/v2/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-nomad/blob/master/LICENSE)



  The HashiCorp Nomad Resource Provider lets you manage Nomad resources.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/nomad

  or `yarn`:

      $ yarn add @pulumi/nomad



  To use from Python, install using `pip`:

      $ pip install pulumi_nomad



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-nomad/sdk/v2



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Nomad



  The following configuration points are available:

  - `nomad:address` - The HTTP(S) API address of the Nomad agent. This must include the leading protocol (e.g. https://).
    This can also be specified as the `NOMAD_ADDR` environment variable.
  - `nomad:region` - The Nomad region to target. This can also be specified as the `NOMAD_REGION` environment variable.
  - `nomad:httpAuth` - HTTP Basic Authentication credentials to be used when communicating with Nomad, in the format of
    either `user` or `user:pass`. This can also be specified using the `NOMAD_HTTP_AUTH` environment variable.
  - `nomad:caFile` - A local file path to a PEM-encoded certificate authority used to verify the remote agent's
    certificate. This can also be specified as the `NOMAD_CACERT` environment variable.
  - `nomad:caPerm` - PEM-encoded certificate authority used to verify the remote agent's certificate.
  - `nomad:certFile` - A local file path to a PEM-encoded certificate provided to the remote agent. If this is specified,
    key_file or key_pem is also required. This can also be specified as the `NOMAD_CLIENT_CERT` environment variable.
  - `nomad:certPem` - PEM-encoded certificate provided to the remote agent. If this is specified, `keyFile` or `keyPem` is also required.
  - `nomad:keyFile` - A local file path to a PEM-encoded private key. This is required if `certFile` or `certPem` is
    specified. This can also be specified via the `NOMAD_CLIENT_KEY` environment variable.
  - `nomad:keyPem` - PEM-encoded private key. This is required if `certFile` or `certPem` is specified.
  - `nomad:headers` - A configuration block, described below, that provides headers to be sent along with all
    requests to Nomad. This block can be specified multiple times.
  - `nomad:vaultToken` - A Vault token used when submitting the job. This can also be specified as the `VAULT_TOKEN`
    environment variable or using a Vault token helper (see Vault's documentation for more details).
  - `nomad:consulToken` - A Consul token used when submitting the job. This can also be specified as the
    `CONSUL_HTTP_TOKEN` environment variable. See below for strategies when multiple Consul tokens are required.
  - `nomad:secretId` - The Secret ID of an ACL token to make requests with, for ACL-enabled clusters. This can also be
    specified via the `NOMAD_TOKEN` environment variable.

  The `nomad:headers` configuration block accepts the following arguments:

  - `name` - The name of the header.
  - `value` - The value of the header.



  For further information, please visit [the Nomad provider docs](https://www.pulumi.com/docs/intro/cloud-providers/nomad)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/nomad).


pkgId: 62add38767ac9f94f35d588a7c0f7eb592fa280ab098390e8fd3414d2b5f1d7b
name: python-pulumi-ns1-help
arch: noarch
version: 3.4.6
epoch: 0
release: 1
summary: Development documents and examples for pulumi-ns1
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-ns1-3.4.6-1.src.rpm
location_href: Packages/python-pulumi-ns1-help-3.4.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-ns1/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-ns1/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fns1.svg)](https://www.npmjs.com/package/@pulumi/ns1)
  [![Python version](https://badge.fury.io/py/pulumi-ns1.svg)](https://pypi.org/project/pulumi-ns1)
  [![NuGet version](https://badge.fury.io/nu/pulumi.ns1.svg)](https://badge.fury.io/nu/pulumi.ns1)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-ns1/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-ns1/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-ns1/blob/master/LICENSE)



  The NS1 resource provider for Pulumi lets you manage NS1
  resources in your cloud programs. To use this package, please [install the
  Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/ns1

  or `yarn`:

      $ yarn add @pulumi/ns1



  To use from Python, install using `pip`:

      $ pip install pulumi_ns1



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-ns1/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Ns1



  The following configuration points are available:

  * ns1:apikey - (Required) NS1 API token. It must be provided, but it can also be sourced from the `NS1_APIKEY`
    environment variable.
  * ns1:endpoint - (Optional) NS1 API endpoint. For managed clients, this normally should not be set. Can also be sources
    via the `NS1_ENDPOINT` environment variable.
  * ns1:enableDdi - (Optional) This sets the permission schema to a DDI-compatible schema. Users of the managed SaaS
    product should not need to set this. Users of DDI should set this to true if managing teams, users, or API
    keys through this provider.
  * ns1:rateLimitParallelism - (Optional) Integer for parallelism amount (default is `10`). NS1 uses a token-based method
    for rate limiting API requests.



  For further information, please visit [the NS1 provider docs](https://www.pulumi.com/docs/intro/cloud-providers/ns1)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/ns1).


pkgId: a089276ab57664ff8a3eeed7ce6d4d0bf94ac77b510d2cee49b0b565d40b601b
name: python-pulumi-null-help
arch: noarch
version: 0.0.9
epoch: 0
release: 1
summary: Development documents and examples for pulumi-null
url: https://www.pulumi.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-null-0.0.9-1.src.rpm
location_href: Packages/python-pulumi-null-help-0.0.9-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-null/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-null/actions)
  [![NPM version](https://img.shields.io/npm/v/@pulumi/null)](https://www.npmjs.com/package/@pulumi/null)
  [![Python version](https://img.shields.io/pypi/v/pulumi_null)](https://pypi.org/project/pulumi_null)
  [![NuGet version](https://img.shields.io/nuget/v/Pulumi.Null)](https://www.nuget.org/packages/Pulumi.Null)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-null/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-null/sdk/go)
  [![License](https://img.shields.io/github/license/pulumi/pulumi-null)](https://github.com/pulumi/pulumi-null/blob/master/LICENSE)



  This provider is mainly used for ease of converting terraform programs to Pulumi.
  For standard use in Pulumi programs, please use your programming language's implementation of null values.

  The Null resource provider for Pulumi lets you use Null resources in your cloud programs.
  To use this package, please [install the Pulumi CLI first](https://www.pulumi.com/docs/install/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/null

  or `yarn`:

      $ yarn add @pulumi/null



  To use from Python, install using `pip`:

      $ pip install pulumi_null



  To use from Go, use `go get` to grab the latest version of the library:

      $ go get github.com/pulumi/pulumi-null/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Null

  <!-- If your provider has configuration, remove this comment and the comment tags below, updating the documentation. -->
  <!--



  The following Pulumi configuration can be used:

  - `null:token` - (Required) The API token to use with Null. When not set, the provider will use the `NULL_TOKEN` environment variable.

  -->

  <!-- If your provider has reference material available elsewhere, remove this comment and the comment tags below, updating the documentation. -->
  <!--



  For further information, please visit [Null reference documentation](https://example.com/null).

  -->


pkgId: e5a3ac560737dbe5313f97811171f3178b82635ec896e9af8309dd704ef9a7a3
name: python-pulumi-nutanix-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-nutanix
url: https://github.com/pierskarsenbarg/pulumi-nutanix
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-nutanix-0.6.0-1.src.rpm
location_href: Packages/python-pulumi-nutanix-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  The Nutanix Resource Provider lets you manage [Nutanix](https://nutanix.com) resources.



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pierskarsenbarg/pulumi-nutanix
  ```

  or `yarn`:

  ```bash
  yarn add @pierskarsenbarg/pulumi-nutanix
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi_nutanix
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pierskarsenbarg/pulumi-nutanix/sdk/go/...
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package PiersKarsenbarg.Nutanix
  ```



  The following configuration points are available for the `nutanix` provider:

  - `nutanix:apiKey` (environment: `NUTANIX_API_KEY`) - the API key for `nutanix`
  - `nutanix:region` (environment: `NUTANIX_REGION`) - the region in which to deploy resources



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/nutanix/api-docs/).


pkgId: 4a14fb6ed4a5f92e450d34274536a800134d5940abafe9821862dc15b7f6698f
name: python-pulumi-oci-help
arch: noarch
version: 2.19.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-oci
url: https://www.pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-oci-2.19.0-1.src.rpm
location_href: Packages/python-pulumi-oci-help-2.19.0-1.noarch.rpm
checksum_type: sha256
description:
  The Oracle Cloud Infrastructure (OCI) Resource Provider lets you manage [OCI](https://www.oracle.com/cloud/) resources.



  This package is available for several languages/platforms:



  To use with JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pulumi/oci
  ```

  or `yarn`:

  ```bash
  yarn add @pulumi/oci
  ```



  To use with Python, install using `pip`:

  ```bash
  python3 -m pip install pulumi_oci
  ```



  To use with Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pulumi/pulumi-oci/sdk/v2/...
  ```



  To use with .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.Oci
  ```



  The following configuration options are available for the `oci` provider:

  | Option                   | Environment variable          | Description                                                                                                                 |
  | ------------------------ | ----------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
  | `oci:tenancyOcid`        | `TF_VAR_tenancy_ocid`         | OCID of your tenancy.                                                                                                       |
  | `oci:userOcid`           | `TF_VAR_user_ocid`            | OCID of the user calling the API.                                                                                           |
  | `oci:privateKey`         | `TF_VAR_private_key`          | The contents of the private key file. Required if `privateKeyPath` is not defined and takes precedence if both are defined. |
  | `oci:privateKeyPath`     | `TF_VAR_private_key_path`     | The path (including filename) of the private key stored on your computer. Required if `privateKey` is not defined.          |
  | `oci:privateKeyPassword` | `TF_VAR_private_key_password` | Passphrase used for the key, if it is encrypted.                                                                            |
  | `oci:fingerprint`        | `TF_VAR_fingerprint`          | Fingerprint for the key pair being used.                                                                                    |
  | `oci:region`             | `TF_VAR_region`               | An OCI region.                                                                                                              |
  | `oci:configFileProfile`  | `TF_VAR_config_file_profile`  | The custom profile to use instead of the `DEFAULT` profile in `.oci/config`.             |

  Use the [Required Keys and OCIDs](https://docs.oracle.com/en-us/iaas/Content/API/Concepts/apisigningkey.htm#Required_Keys_and_OCIDs) chapter of the OCI Developer Guide to learn:

  - [How to Generate an API Signing Key](https://docs.oracle.com/en-us/iaas/Content/API/Concepts/apisigningkey.htm#two)
  - [How to Get the Key's Fingerprint](https://docs.oracle.com/en-us/iaas/Content/API/Concepts/apisigningkey.htm#four)
  - [Where to Get the Tenancy's OCID and User's OCID](https://docs.oracle.com/en-us/iaas/Content/API/Concepts/apisigningkey.htm#five)



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/oci/api-docs/).


pkgId: c3745c04dfd6c8b972a9bb462a6a01c1b23bd17ea29daa45268049b0a42d2ebc
name: python-pulumi-okta-help
arch: noarch
version: 4.12.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-okta
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-okta-4.12.0-1.src.rpm
location_href: Packages/python-pulumi-okta-help-4.12.0-1.noarch.rpm
checksum_type: sha256
description:
  r[![Actions Status](https://github.com/pulumi/pulumi-okta/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-okta/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fokta.svg)](https://www.npmjs.com/package/@pulumi/okta)
  [![Python version](https://badge.fury.io/py/pulumi-okta.svg)](https://pypi.org/project/pulumi-okta)
  [![NuGet version](https://badge.fury.io/nu/pulumi.okta.svg)](https://badge.fury.io/nu/pulumi.okta)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-okta/sdk/v4/go)](https://pkg.go.dev/github.com/pulumi/pulumi-okta/sdk/v4/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-okta/blob/master/LICENSE)



  The Okta resource provider for Pulumi lets you manage Okta resources in your cloud programs. To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/okta

  or `yarn`:

      $ yarn add @pulumi/okta



  To use from Python, install using `pip`:

      $ pip install pulumi_okta



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-okta/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Okta



  The following configuration points are available:

  - `okta:orgName` - (Required) This is the org name of your Okta account, for example dev-123.oktapreview.com would have
  an org name of dev-123. May be set via the `OKTA_ORG_NAME` environment variable.
  - `okta:baseUrl` - (Required) This is the domain of your Okta account, for example `dev-123.oktapreview.com` would have
  a base url of `oktapreview.com`. May be set via the `OKTA_BASE_URL` environment variable.
  - `okta:apiToken` - (Required) This is the API token to interact with your Okta org. May be set via the `OKTA_API_TOKEN`
  environment variable.
  - `okta:backoff` - (Optional)  Whether to use exponential back off strategy for rate limits, the default is `true`.
  - `okta:maxRetries` - (Optional) Maximum number of retries to attempt before returning an error, the default is `5`.
  - `okta:maxWaitSeconds` - (Optional) Maximum seconds to wait when rate limit is hit, the default is `300`.
  - `okta:minWaitSeconds` - (Optional) Minimum seconds to wait when rate limit is hit, the default is `30`.



  For further information, please visit [the Okta provider docs](https://www.pulumi.com/docs/intro/cloud-providers/okta)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/okta).


pkgId: 1997fd6df5bf8476fa243be869cc3b6256730305e59992f2571ae9eca9422162
name: python-pulumi-onelogin-help
arch: noarch
version: 0.6.8
epoch: 0
release: 1
summary: Development documents and examples for pulumi-onelogin
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-onelogin-0.6.8-1.src.rpm
location_href: Packages/python-pulumi-onelogin-help-0.6.8-1.noarch.rpm
checksum_type: sha256
description:
  r[![Actions Status](https://github.com/pulumi/pulumi-onelogin/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-onelogin/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fonelogin.svg)](https://www.npmjs.com/package/@pulumi/onelogin)
  [![Python version](https://badge.fury.io/py/pulumi-onelogin.svg)](https://pypi.org/project/pulumi-onelogin)
  [![NuGet version](https://badge.fury.io/nu/pulumi.onelogin.svg)](https://badge.fury.io/nu/pulumi.onelogin)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-onelogin/sdk/go/onelogin)](https://pkg.go.dev/github.com/pulumi/pulumi-onelogin/sdk/go/onelogin)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-onelogin/blob/master/LICENSE)



  OneLogin Resource Provider for Pulumi lets you manage [OneLogin](https://onelogin.com) resources.
  To use this package, please [install the Pulumi CLI first](https://pulumi.io/).
  This provider is bridge to [github.com/onelogin/terraform-provider-onelogin](https://github.com/onelogin/terraform-provider-onelogin).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/onelogin

  or `yarn`:

      $ yarn add @pulumi/onelogin



  To use from Python, install using `pip`:

      $ pip install pulumi_onelogin



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-onelogin/sdk/go/...



  You'll need admin access to a OneLogin account where you can create API credentials.
  Create a set of API credentials with manage all permission.
  The following environment variables used to configure the `onelogin` provider:

  - `ONELOGIN_CLIENT_ID` - your client id
  - `ONELOGIN_CLIENT_SECRET` - your client secret
  - `ONELOGIN_OAPI_URL` - the api url for your region



  For detailed reference documentation, please visit [the API docs][1].

  [1]: https://www.pulumi.com/docs/reference/pkg/onelogin/


pkgId: bc30e43baee732071e39ea8ed36d1790aa16bebfc097e9ec312d4bf77d611e3d
name: python-pulumi-openstack-help
arch: noarch
version: 5.0.2
epoch: 0
release: 1
summary: Development documents and examples for pulumi-openstack
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-openstack-5.0.2-1.src.rpm
location_href: Packages/python-pulumi-openstack-help-5.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-openstack/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-openstack/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fopenstack.svg)](https://www.npmjs.com/package/@pulumi/openstack)
  [![Python version](https://badge.fury.io/py/pulumi-openstack.svg)](https://pypi.org/project/pulumi-openstack)
  [![NuGet version](https://badge.fury.io/nu/pulumi.openstack.svg)](https://badge.fury.io/nu/pulumi.openstack)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-openstack/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-openstack/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-openstack/blob/master/LICENSE)



  The OpenStack resource provider for Pulumi lets you use OpenStack resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/openstack

  or `yarn`:

      $ yarn add @pulumi/openstack



  To use from Python, install using `pip`:

      $ pip install pulumi_openstack



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-openstack/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Openstack



  The following configuration points are available:

  - `openstack:authUrl` - (Optional) The Identity authentication URL. If omitted, the `OS_AUTH_URL` environment variable is used.
  - `openstack:cloud` - (Optional) An entry in a `clouds.yaml` file. See the OpenStack `openstacksdk`
    [documentation](https://docs.openstack.org/openstacksdk/latest/user/config/configuration.html) for more information about
    `clouds.yaml` files. If omitted, the `OS_CLOUD` environment variable is used.
  - `openstack:region` - (Optional) The region of the OpenStack cloud to use. If omitted, the `OS_REGION_NAME` environment
    variable is used. If `OS_REGION_NAME` is not set, then no region will be used. It should be possible to omit the region
    in single-region OpenStack environments, but this behavior may vary depending on the OpenStack environment being used.
  - `openstack:userName` - (Optional) The Username to login with. If omitted, the `OS_USERNAME` environment variable is used.
  - `openstack:userId` - (Optional) The User ID to login with. If omitted, the `OS_USER_ID` environment variable is used.
  - `openstack:applicationCredentialId` - (Optional) (Identity v3 only) The ID of an application credential to authenticate with. An
    `applicationCredentialSecret` has to bet set along with this parameter. Can be set via the `OS_APPLICATION_CREDENTIAL_ID`
    environment variable.
  - `openstack:applicationCredentialName` - (Optional) (Identity v3 only) The name of an application credential to authenticate with.
    Conflicts with the `applicationCredentialName`, requires `userId`, or `userName` and `userDomainName` (or `userDomainId`) to be set.
    Can be set via the `OS_APPLICATION_CREDENTIAL_NAME` environment variable.
  - `openstack:applicationCredentialSecret` - (Optional) (Identity v3 only) The secret of an application credential to authenticate with.
    Required by `applicationCredentialId` or `applicationCredentialName`. Can be set via the `OS_APPLICATION_CREDENTIAL_SECRET`
    environment variable.
  - `openstack:tenantId` - (Optional) The ID of the Tenant (Identity v2) or Project (Identity v3) to login with. If omitted, the
    `OS_TENANT_ID` or `OS_PROJECT_ID` environment variables are used.
  - `openstack:tenantName` - (Optional) The Name of the Tenant (Identity v2) or Project (Identity v3) to login with. If omitted,
    the `OS_TENANT_NAME` or `OS_PROJECT_NAME` environment variable are used.
  - `openstack:password` - (Optional) The Password to login with. If omitted, the
    `OS_PASSWORD` environment variable is used.
  - `openstack:token` - (Optional) A token is an expiring, temporary means of access issued via the Keystone service. By specifying
    a token, you do not have to specify a username/password combination, since the token was already created by a username/password
    out of band of the provider. If omitted, the `OS_TOKEN` or `OS_AUTH_TOKEN` environment variables are used.
  - `openstack:userDomainName` - (Optional) The domain name where the user is located. If omitted, the `OS_USER_DOMAIN_NAME`
    environment variable is checked.
  - `openstack:userDomainId` - (Optional) The domain ID where the user is located. If omitted, the `OS_USER_DOMAIN_ID` environment
    variable is checked.
  - `openstack:projectDomainName` - (Optional) The domain name where the project is located. If omitted, the `OS_PROJECT_DOMAIN_NAME`
    environment variable is checked.
  - `openstack:projectDomainId` - (Optional) The domain ID where the project is located. If omitted, the `OS_PROJECT_DOMAIN_ID`
    environment variable is checked.
  - `openstack:domainId` - (Optional) The ID of the Domain to scope to (Identity v3). If omitted, the `OS_DOMAIN_ID` environment
    variable is checked.
  - `openstack:domainName` - (Optional) The Name of the Domain to scope to (Identity v3). If omitted, the `OS_DOMAIN_NAME` environment
    variable is checked.
  - `openstack:defaultDomain` - (Optional) The ID of the Domain to scope to if no other domain is specified (Identity v3). If omitted,
    the environment variable `OS_DEFAULT_DOMAIN` is checked or a default value of `default` will be used.
  - `openstack:insecure` - (Optional) Trust self-signed SSL certificates. If omitted, the `OS_INSECURE` environment variable is used.
  - `openstack:cacertFile` - (Optional) Specify a custom CA certificate when communicating over SSL. You can specify either a path
    to the file or the contents of the certificate. If omitted, the `OS_CACERT` environment variable is used.
  - `openstack:cert` - (Optional) Specify client certificate file for SSL client authentication. You can specify either a path to
    the file or the contents of the certificate. If omitted the `OS_CERT` environment variable is used.
  - `openstack:key` - (Optional) Specify client private key file for SSL client authentication. You can specify either a path
    to the file or the contents of the key. If omitted the `OS_KEY` environment variable is used.
  - `openstack:endpointType` - (Optional) Specify which type of endpoint to use from the service catalog. It can be set using the
    `OS_ENDPOINT_TYPE` environment variable. If not set, public endpoints is used.
  - `openstack:endpointOverrides` - (Optional) A set of key/value pairs that can override an endpoint for a specified OpenStack service.
    Setting an override requires you to specify the full and complete endpoint URL. This might also invalidate any region you have set,
    too. Please use this at your own risk.
  - `openstack:swauth` - (Optional) Set to `true` to authenticate against Swauth, a Swift-native authentication system. If omitted, the
    `OS_SWAUTH` environment variable is used. You must also set `username` to the Swauth/Swift username such as `username:project`.
    Set the `password` to the Swauth/Swift key. Finally, set `auth_url` as the location of the Swift service. Note that this
    will only work when used with the OpenStack Object Storage resources.
  - `openstack:userOctavia` - (Optional) If set to `true`, API requests will go the Load Balancer service (Octavia) instead of
    the Networking service (Neutron).
  - `openstack:disableNoCacheHeader` - (Optional) If set to `true`, the HTTP `Cache-Control: no-cache` header will not be added by default to all API requests.
    If omitted this header is added to all API requests to force HTTP caches (if any) to go upstream instead of serving cached responses.
  - `openstack:delayedAuth` - (Optional) If set to `true`, OpenStack authorization will be perfomed, when the service provider client is called.
  - `openstack:allowReauth` - (Optional) If set to `true`, OpenStack authorization will be perfomed automatically, if the initial auth token get
    expired. This is useful, when the token TTL is low or the overall provider execution time expected to be greater than the initial token TTL.



  For further information, please visit [the OpenStack provider docs](https://www.pulumi.com/docs/intro/cloud-providers/openstack) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/openstack).


pkgId: f8f4b42b71fce79d5360910a055c7677bbc131b8511e9039e0c44cdef28b6724
name: python-pulumi-opsgenie-help
arch: noarch
version: 1.3.13
epoch: 0
release: 1
summary: Development documents and examples for pulumi-opsgenie
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-opsgenie-1.3.13-1.src.rpm
location_href: Packages/python-pulumi-opsgenie-help-1.3.13-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-opsgenie/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-opsgenie/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fopsgenie.svg)](https://npmjs.com/package/@pulumi/opsgenie)
  [![NuGet version](https://badge.fury.io/nu/pulumi.opsgenie.svg)](https://badge.fury.io/nu/pulumi.opsgenie)
  [![Python version](https://badge.fury.io/py/pulumi-opsgenie.svg)](https://pypi.org/project/pulumi-opsgenie)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-opsgenie/sdk/go)](https://pkg.go.dev/github.com/pulumi/pulumi-opsgenie/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-opsgenie/blob/master/LICENSE)



  The OpsGenie resource provider for Pulumi lets you manage opsgenie resources in your cloud programs. To use this package, please install the Pulumi CLI first.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/opsgenie

  or `yarn`:

      $ yarn add @pulumi/opsgenie



  To use from Python, install using `pip`:

      $ pip install pulumi_opsgenie



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-opsgenie/sdk



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Opsgenie



  The following configuration points are available for the `opsgenie` provider:

  - `opsgenie:api_key` (Required) - the API key for `opsgenie`. Can also be provided with `OPSGENIE_API_KEY`.
  - `opsgenie:api_url` (Optional) - the API url for `opsgenie`. Can also be provided with `OPSGENIE_API_URL`. Defaults to `api.opsgenie.com`.



  For detailed reference documentation, please visit [the API docs][1].


  [1]: https://www.pulumi.com/docs/reference/pkg/opsgenie/


pkgId: cd8845e31ceccb330b8a80f6fbb7749c5ac363f2dccfb2e10da1cffb7cd4ab6b
name: python-pulumi-ovh-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-ovh
url: https://www.pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-ovh-1.2.0-1.src.rpm
location_href: Packages/python-pulumi-ovh-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  The OVH Resource Provider lets you manage [OVHcloud](https://www.ovhcloud.com/en/) resources.

  <a href="https://github.com/ovh/pulumi-ovh/releases/latest"><img alt="GitHub release" src="https://img.shields.io/github/v/release/ovh/pulumi-ovh?logo=github&style=flat-square"></a>
  [![GoDoc](https://godoc.org/github.com/ovh/pulumi-ovh?status.svg)](https://pkg.go.dev/github.com/ovh/pulumi-ovh/sdk)
  [![NPM version](https://badge.fury.io/js/@ovhcloud%2Fpulumi-ovh.svg)](https://badge.fury.io/js/@ovhcloud%2Fpulumi-ovh)
  [![PyPI version](https://badge.fury.io/py/pulumi-ovh.svg)](https://badge.fury.io/py/pulumi-ovh)
  [![NuGet version](https://badge.fury.io/nu/Pulumi.Ovh.svg)](https://badge.fury.io/nu/Pulumi.Ovh)
  [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.ovhcloud.pulumi.ovh/pulumi-ovh/badge.svg)](https://s01.oss.sonatype.org/#nexus-search;quick~com.ovhcloud.pulumi.ovh)
  <a href="https://gitpod.io/#https://github.com/ovh/pulumi-ovh"><img src="https://img.shields.io/badge/Contribute%20with-Gitpod-908a85?logo=gitpod" alt="Contribute with Gitpod"/></a>



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @ovhcloud/pulumi-ovh
  ```

  or `yarn`:

  ```bash
  yarn add @ovhcloud/pulumi-ovh
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi-ovh
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/ovh/pulumi-ovh/sdk/go/...
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.Ovh
  ```



  To use from Java, add the dependency below to your `pom.xml` file:

  ```bash
  <dependency>
      <groupId>com.ovhcloud.pulumi.ovh</groupId>
      <artifactId>pulumi-ovh</artifactId>
      <version>[0.48.9,)</version>
  </dependency>
  ```



  The following configuration points are available for the `Ovh` provider:

  - `ovh:endpoint` (environment: `OVH_ENDPOINT`) - the Ovh endpoint, such `ovh-eu`
  - `ovh:applicationKey` (environment: `OVH_APPLICATION_KEY`) - the Ovh application key
  - `ovh:applicationSecret` (environment: `OVH_APPLICATION_SECRET`) - the Ovh application secret
  - `ovh:consumerKey` (environment: `OVH_CONSUMER_KEY`) - the Ovh consumer key



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/ovh/api-docs/).




  The following configuration points are available for the `Ovh` provider:

  - `ovh:endpoint` (environment: `OVH_ENDPOINT`) - the Ovh endpoint, such `ovh-eu`
  - `ovh:applicationKey` (environment: `OVH_APPLICATION_KEY`) - the Ovh application key
  - `ovh:applicationSecret` (environment: `OVH_APPLICATION_SECRET`) - the Ovh application secret
  - `ovh:consumerKey` (environment: `OVH_CONSUMER_KEY`) - the Ovh consumer key



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/ovh/api-docs/).


pkgId: c7f6df4573964ea1c57dc16ad7156b51cf8780063de5eb814ad12ad18f83e9f4
name: python-pulumi-pagerduty-help
arch: noarch
version: 4.17.1
epoch: 0
release: 1
summary: Development documents and examples for pulumi-pagerduty
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-pagerduty-4.17.1-1.src.rpm
location_href: Packages/python-pulumi-pagerduty-help-4.17.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-pagerduty/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-pagerduty/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fpagerduty.svg)](https://www.npmjs.com/package/@pulumi/pagerduty)
  [![Python version](https://badge.fury.io/py/pulumi-pagerduty.svg)](https://pypi.org/project/pulumi-pagerduty)
  [![NuGet version](https://badge.fury.io/nu/pulumi.pagerduty.svg)](https://badge.fury.io/nu/pulumi.pagerduty)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-pagerduty/sdk/v2/go)](https://pkg.go.dev/github.com/pulumi/pulumi-pagerduty/sdk/v2/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-pagerduty/blob/master/LICENSE)



  The PagerDuty Resource Provider lets you manage PagerDuty resources.



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/pagerduty

  or `yarn`:

      $ yarn add @pulumi/pagerduty



  To use from Python, install using `pip`:

      $ pip install pulumi_pagerduty



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-pagerduty/sdk/v4



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Pagerduty



  The following configuration points are available:

  - `pagerduty:token` - (Required) The v2 authorization token. It can also be sourced from the `PAGERDUTY_TOKEN`
    environment variable. See [API Documentation](https://v2.developer.pagerduty.com/docs/authentication) for more information.
  - `pageduty:skipCredentialsValidation` - (Optional) Skip validation of the token against the PagerDuty API.



  For further information, please visit [the PagerDuty provider docs](https://www.pulumi.com/docs/intro/cloud-providers/pagerduty)
  or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/pagerduty).


pkgId: 47d38dfbf0bfa1cf893fd2a7366f58eb552905753c41c7a758ce11ef2e84d1cd
name: python-pulumi-postgresql-help
arch: noarch
version: 3.14.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-postgresql
url: https://pulumi.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-postgresql-3.14.0-1.src.rpm
location_href: Packages/python-pulumi-postgresql-help-3.14.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/pulumi/pulumi-postgresql/workflows/master/badge.svg)](https://github.com/pulumi/pulumi-postgresql/actions)
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fpostgresql.svg)](https://www.npmjs.com/package/@pulumi/postgresql)
  [![Python version](https://badge.fury.io/py/pulumi-postgresql.svg)](https://pypi.org/project/pulumi-postgresql)
  [![NuGet version](https://badge.fury.io/nu/pulumi.postgresql.svg)](https://badge.fury.io/nu/pulumi.postgresql)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-postgresql/sdk/v3/go)](https://pkg.go.dev/github.com/pulumi/pulumi-postgresql/sdk/v3/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumi.svg)](https://github.com/pulumi/pulumi-postgresql/blob/master/LICENSE)



  The postgresql resource provider for Pulumi lets you manage postgresql resources in your cloud programs.  To use
  this package, please [install the Pulumi CLI first](https://pulumi.io/).



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/postgresql

  or `yarn`:

      $ yarn add @pulumi/postgresql



  To use from Python, install using `pip`:

      $ pip install pulumi_postgresql



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-postgresql/sdk/v3



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.Postgresql



  The following configuration points are available:

  - `postgresql:host` - (required) The address for the postgresql server connection. Can also be specified with the `PGHOST`
     environment variable.
  - `postgresql:port` - (optional) The port for the postgresql server connection. The default is `5432`.  Can also be specified
     with the `PGPORT` environment variable.
  - `postgresql:database` - (optional) Database to connect to. The default is `postgres`. Can also be specified
     with the `PGDATABASE` environment variable.
  - `postgresql:username` - (required) Username for the server connection. The default is `postgres`. Can also be specified
     with the `PGUSER` environment variable.
  - `postgresql:password` - (optional) Password for the server connection. Can also be specified with the `PGPASSWORD` environment variable.
  - `postgresql:database_username` - (optional) Username of the user in the database if different than connection username (See user name maps).
  - `postgresql:superuser` - (optional) Should be set to false if the user to connect is not a PostgreSQL superuser (as is the case in RDS).
     In this case, some features might be disabled (e.g.: Refreshing state password from database).
  - `postgresql:sslmode` - (optional) Set the priority for an SSL connection to the server. Valid values for sslmode are (note: prefer is not supported by Go's lib/pq):
      * `disable` - No ssl
      * `require` - always SSL (the default, also skip verification)
      * `verify-ca` - always SSL (verify that the certificate presented by the server was signed by a trusted CA)
      * `verify-full` - Always SSL (verify that the certification presented by the server was signed by a trusted CA and the server
         host name matches the one in the certificate) Additional information on the options and their implications can be seen in the libpq(3) SSL guide.
    Can also be specified with the `PGSSLMODE` environment variable.
  - `postgresql:connect_timeout` - (optional) Maximum wait for connection, in seconds. The default is `180s`. Zero or not specified means wait indefinitely.
    Can also be specified with the `PGCONNECT_TIMEOUT` environment variable.
  - `postgresql:max_connections` - (optional) Set the maximum number of open connections to the database. The default is `4`. Zero means unlimited open connections.
  - `postgresql:expected_version` - (optional) Specify a hint to Terraform regarding the expected version that the provider will be talking with. This is a
     required hint in order for the provider to talk with an ancient version of PostgreSQL. This parameter is expected to be a PostgreSQL Version or current.
     Once a connection has been established, the provider will fingerprint the actual version. Default: 9.0.0.
  - `postgresql:clientcert` - (optional) Clientcert block for configuring SSL certificate.
    - `postgresql:clientcert.cert` - (required) The SSL client certificate file path. The file must contain PEM encoded data.
    - `postgresql:clientcert.key` - (required) The SSL client certificate private key file path. The file must contain PEM encoded data.




  For further information, please visit [the postgresql provider docs](https://www.pulumi.com/docs/intro/cloud-providers/postgresql) or for detailed reference documentation, please visit [the API docs](https://www.pulumi.com/docs/reference/pkg/postgresql).


pkgId: 216642e082a80ee0940a2205709b483543644487649b15f3d5efea92c9a24221
name: python-pulumi-proxmoxve-help
arch: noarch
version: 6.18.0
epoch: 0
release: 1
summary: Development documents and examples for pulumi-proxmoxve
url: https://github.com/muhlba91/pulumi-proxmoxve
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-proxmoxve-6.18.0-1.src.rpm
location_href: Packages/python-pulumi-proxmoxve-help-6.18.0-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/github/license/muhlba91/pulumi-proxmoxve?style=for-the-badge)](LICENSE)
  [![](https://img.shields.io/github/actions/workflow/status/muhlba91/pulumi-proxmoxve/verify.yml?style=for-the-badge)](https://github.com/muhlba91/pulumi-proxmoxve/actions/workflows/verify.yml)
  [![](https://api.scorecard.dev/projects/github.com/muhlba91/pulumi-proxmoxve/badge?style=for-the-badge)](https://scorecard.dev/viewer/?uri=github.com/muhlba91/pulumi-proxmoxve)
  [![](https://img.shields.io/github/release-date/muhlba91/pulumi-proxmoxve?style=for-the-badge)](https://github.com/muhlba91/pulumi-proxmoxve/releases)
  [![](https://img.shields.io/pypi/v/pulumi-proxmoxve?style=for-the-badge)](https://pypi.org/project/pulumi-proxmoxve/)
  [![](https://img.shields.io/pypi/dm/pulumi-proxmoxve?style=for-the-badge)](https://pypi.org/project/pulumi-proxmoxve/)
  [![](https://img.shields.io/nuget/v/Pulumi.ProxmoxVE?style=for-the-badge)](https://www.nuget.org/packages/Pulumi.ProxmoxVE/)
  [![](https://img.shields.io/nuget/dt/Pulumi.ProxmoxVE?style=for-the-badge)](https://www.nuget.org/packages/Pulumi.ProxmoxVE/)
  [![](https://img.shields.io/npm/v/@muhlba91/pulumi-proxmoxve?style=for-the-badge)](https://www.npmjs.com/package/@muhlba91/pulumi-proxmoxve)
  [![](https://img.shields.io/npm/dm/@muhlba91/pulumi-proxmoxve?style=for-the-badge)](https://www.npmjs.com/package/@muhlba91/pulumi-proxmoxve)
  [![](https://img.shields.io/github/all-contributors/muhlba91/pulumi-proxmoxve?color=ee8449&style=for-the-badge)](#contributors)
  <a href="https://www.buymeacoffee.com/muhlba91" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/default-orange.png" alt="Buy Me A Coffee" height="28" width="150"></a>

  The Proxmox VE Resource Provider for [Pulumi](https://www.pulumi.com) lets you manage [Proxmox VE](http://proxmox.com) resources.

  The provider is built on https://github.com/bpg/terraform-provider-proxmox.



  This package is available in many languages in the standard packaging formats.



  1. Download the appropriate archive file from the Releases page:
     `wget https://github.com/muhlba91/pulumi-proxmoxve/releases/download/vX.Y.Z/pulumi-resource-proxmoxve-vX.Y.Z-OPERATING_SYSTEM-ARCH.tar.gz`
  2. Add the plugin to Pulumi:
     `pulumi plugin install resource proxmoxve X.Y.Z -f ./pulumi-resource-proxmoxve-vX.Y.Z-OPERATING_SYSTEM-ARCH.tar.gz`



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @muhlba91/pulumi-proxmoxve
  ```

  or `yarn`:

  ```bash
  yarn add @muhlba91/pulumi-proxmoxve
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pulumi-proxmoxve
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/muhlba91/pulumi-proxmoxve/sdk/go/...
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package Pulumi.ProxmoxVE
  ```



  Unfortunately, configuration via environment variables is not (yet) working.
  To configure the provider you must create and pass it through.

  Example for *Typescript*:

  ```typescript
  import * as proxmox from '@muhlba91/pulumi-proxmoxve';

  const provider = new proxmox.Provider('proxmoxve', {
    endpoint: process.env.PROXMOX_VE_ENDPOINT,
    insecure: process.env.PROXMOX_VE_INSECURE,
    username: process.env.PROXMOX_VE_USERNAME,
    password: process.env.PROXMOX_VE_PASSWORD
  });

  const args = {};
  const vm = new proxmox.vm.VirtualMachine(
    'vm',
    args,
    {
      provider: provider,
    },
  );
  ```



  For detailed reference documentation, please visit the upstream Terraform provider's documentation at: https://registry.terraform.io/providers/bpg/proxmox/latest.

  Some input parameters are required as per the [Proxmox API Viewer](https://pve.proxmox.com/pve-docs/api-viewer/index.html).
  Please refer to this documentation for more information regarding required parameters for your Proxmox VE version.



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://muehlbachler.io/"><img src="https://avatars.githubusercontent.com/u/653739?v=4?s=100" width="100px;" alt="Daniel Mühlbachler-Pietrzykowski"/><br /><sub><b>Daniel Mühlbachler-Pietrzykowski</b></sub></a><br /><a href="#maintenance-muhlba91" title="Maintenance">🚧</a> <a href="https://github.com/muhlba91/pulumi-proxmoxve/commits?author=muhlba91" title="Code">💻</a> <a href="https://github.com/muhlba91/pulumi-proxmoxve/commits?author=muhlba91" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/NCMartins"><img src="https://avatars.githubusercontent.com/u/11583533?v=4?s=100" width="100px;" alt="Nelson Costa Martins"/><br /><sub><b>Nelson Costa Martins</b></sub></a><br /><a href="#example-NCMartins" title="Examples">💡</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/guineveresaenger"><img src="https://avatars.githubusercontent.com/u/13116240?v=4?s=100" width="100px;" alt="Guinevere Saenger"/><br /><sub><b>Guinevere Saenger</b></sub></a><br /><a href="https://github.com/muhlba91/pulumi-proxmoxve/commits?author=guineveresaenger" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/susanev"><img src="https://avatars.githubusercontent.com/u/5489125?v=4?s=100" width="100px;" alt="Susan Evans"/><br /><sub><b>Susan Evans</b></sub></a><br /><a href="https://github.com/muhlba91/pulumi-proxmoxve/commits?author=susanev" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/zamrih"><img src="https://avatars.githubusercontent.com/u/1061718?v=4?s=100" width="100px;" alt="zamrih"/><br /><sub><b>zamrih</b></sub></a><br /><a href="https://github.com/muhlba91/pulumi-proxmoxve/commits?author=zamrih" title="Code">💻</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: c7b20c8f0bb63d8ab1011d22615cda28c90522a930d71a9657de36f2e7ccee31
name: python-pulumi-pulumiservice-help
arch: noarch
version: 0.27.3
epoch: 0
release: 1
summary: Development documents and examples for pulumi-pulumiservice
url: https://pulumi.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pulumi-pulumiservice-0.27.3-1.src.rpm
location_href: Packages/python-pulumi-pulumiservice-help-0.27.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Slack](http://www.pulumi.com/images/docs/badges/slack.svg)](https://slack.pulumi.com)
  [![NPM version](https://badge.fury.io/js/%40pulumi%2Fpulumiservice.svg)](https://www.npmjs.com/package/@pulumi/pulumiservice)
  [![Python version](https://badge.fury.io/py/pulumi-pulumiservice.svg)](https://pypi.org/project/pulumi-pulumiservice)
  [![NuGet version](https://badge.fury.io/nu/pulumi.pulumiservice.svg)](https://badge.fury.io/nu/pulumi.pulumiservice)
  [![PkgGoDev](https://pkg.go.dev/badge/github.com/pulumi/pulumi-pulumiservice/sdk/go/pulumiservice)](https://pkg.go.dev/github.com/pulumi/pulumi-pulumiservice/sdk/go)
  [![License](https://img.shields.io/npm/l/%40pulumi%2Fpulumiservice.svg)](https://github.com/pulumi/pulumi-pulumiservice/blob/main/LICENSE)

  A Pulumi Resource Provider for The Pulumi Service.

  The Pulumi Service Provider is built on top of the [Pulumi Service REST API](https://pulumi.com/docs/reference/service-rest-api) which is another feature available to our customers to programmatically configuring the Pulumi Service. The Pulumi Service REST API includes functionality to interact with and manipulate any kind of metadata managed by Pulumi. That includes Projects and Stacks, Previews and Updates, Organizations and Audit Logs. We have already seen Cloud Engineering teams using the Pulumi REST API to build all sorts of custom functionality. These new capabilities are especially powerful when used in combination with the [Automation API](https://pulumi.com/automation).



  - [Webhooks](https://pulumi.com/docs/intro/pulumi-service/webhooks)
  - [Teams](https://pulumi.com/docs/intro/pulumi-service/teams)
    - You can grant a team access to stacks via the `TeamStackPermission` resource
  - [StackTags](https://pulumi.com/docs/reference/cli/pulumi_stack_tag)
  - [AccessTokens](https://pulumi.com/docs/intro/pulumi-service/accounts)

  For reference documentation, visit the [Pulumi Service API Documentation](https://www.pulumi.com/registry/packages/pulumiservice/api-docs/) on the [Pulumi Registry](https://www.pulumi.com/registry/packages/pulumiservice/)



  This package is available in many languages in the standard packaging formats.



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

      $ npm install @pulumi/pulumiservice

  or `yarn`:

      $ yarn add @pulumi/pulumiservice



  To use from Python, install using `pip`:

      $ pip install pulumi_pulumiservice



  To use from Go, use `go get` to grab the latest version of the library

      $ go get github.com/pulumi/pulumi-pulumiservice/sdk/go



  To use from .NET, install using `dotnet add package`:

      $ dotnet add package Pulumi.PulumiService



  Ensure that you have ran `pulumi login`. Run `pulumi whoami` to verify that you are logged in.



  Use `pulumi config set pulumiservice:<option>` or pass options to the [constructor of `new pulumiservice.Provider`][1].

  | Option        | Environment Variable Name | Required/Optional | Description                                                                           |
  |---------------|---------------------------|-------------------|---------------------------------------------------------------------------------------|
  | `accessToken` | `PULUMI_ACCESS_TOKEN`     | Optional          | Overrides [Pulumi Service Access Tokens][2]                                           |
  | `apiUrl`      | `PULUMI_BACKEND_URL`      | Optional          | Allows overriding default [Pulumi Service API URL][3] for [self hosted customers][4]. |
  |               |                           |                   |                                                                                       |



  ```typescript
  import * as aws from "@pulumi/awsx"
  import * as pulumi from "@pulumi/pulumi";
  import * as service from "@pulumi/pulumiservice";

  const team = new service.Team("team", {
      name: "pulumi-service-team",
      displayName: "Pulumi Service",
      description: "The Pulumi Service Team",
      organizationName: "pulumi",
      teamType: "pulumi",
      members: [
          "piers",
          "bryce",
          "casey"
          "evan",
          "devon",
          "meagan"
          "myles",
          "steve"
      ],
  });

  export const members = team.members;
  ```

  Check out the [examples/](examples/) directory for more examples.

  [1]: https://pulumi.com/registry/packages/pulumiservice/api-docs/provider
  [2]: https://www.pulumi.com/docs/intro/pulumi-service/accounts/#access-tokens
  [3]: https://www.pulumi.com/docs/reference/service-rest-api
  [4]: https://www.pulumi.com/docs/guides/self-hosted/


