# packages

pkgId: 4378d5966af63616f6fd3ccbd0ae2beba60da18836bc6e998012cf5837408652
name: python-cavapy-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for cavapy
url: https://github.com/Risk-Team/cavapy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cavapy-0.1.0-1.src.rpm
location_href: Packages/python-cavapy-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **Beta testing**


  This project is about creating a Python function to automatically get the required climate data needed to run pyAEZ. This can be an optional feature of the pyAEZ climate module.


  The climate data is available at the THREDDS data server of the University of Cantabria as part of the CAVA (Climate and Agriculture Risk Visualization and Assessment) product developed by FAO, the University of Cantabria, the University of Cape Town and Predictia.
  CAVA has available CORDEX-CORE climate models, the high resolution (25 Km) dynamically-downscaled climate models used in the IPCC report AR5. Additionally, CAVA  offers access to state-of-the-art reanalyses datasets, such as W5E5 and ERA5.

  The currently available data is:

  - CORDEX-CORE simulations (3 GCMs donwscaled with 2 RCMs for two RCPs)
  - W5E5 and ERA5 reanalyses datasets

  Available variables are:

  - Daily maximum temperature (tasmax)
  - Daily minimum temperature (tasmin)
  - Daily precipitation (pr)
  - Daily relative humidity (hurs)
  - Daily wind speed (sfcWind)
  - Daily solar radiation (rsds)




  The function can be downloaded from the script folder and imported, for example, as follow:

  ```
  import os
  os.chdir('/path/to/function')
  import cavapy

  help(cavapy.get_climate_data)

  ```
  Depending on the interest, downloading climate data can be done in a few different ways. Note that GCM stands for General Circulation Model while RCP stands for Regional Climate Model. As the climate data comes from the CORDEX-CORE initiative, users can choose between 3 different GCMs downscaled with two RCMs. In total, there are six simulations for any given domain (except for CAS-22 where only three are available).

  Since bias-correction requires both the historical run of the CORDEX model and the observational dataset (in this case ERA5), even when the historical argument is set to False, the historical run will be used for learning the bias-correction factor.

  ```

  Zambia_climate_data = cavapy.get_climate_data(country="Zambia", cordex_domain="AFR-22", rcp="rcp26", gcm="MPI", rcm="REMO", years_up_to=2030, obs=False, bias_correction=True, historical=False)

  Zambia_climate_data = cavapy.get_climate_data(country="Zambia", cordex_domain="AFR-22", rcp="rcp26", gcm="MPI", rcm="REMO", years_up_to=2030, obs=False, bias_correction=False, historical=False)

  Zambia_climate_data = cavapy.get_climate_data(country="Zambia", cordex_domain="AFR-22", rcp="rcp26", gcm="MPI", rcm="REMO", years_up_to=2030, obs=False, bias_correction=True, historical=True)

  Zambia_climate_data = cavapy.get_climate_data(country="Zambia", cordex_domain="AFR-22", rcp="rcp26", gcm="MPI", rcm="REMO", years_up_to=2030, obs=True, bias_correction=True, historical=True, years_obs=range(1980,2019))
  ```


pkgId: fcf099677e353866359b6a3cb1ddada318e7416afc3615f986ff9195c9e18dee
name: python-cave-utils-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for cave-utils
url: https://github.com/mit-cave/cave_utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cave-utils-2.3.0-1.src.rpm
location_href: Packages/python-cave-utils-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Basic utilities for the MIT Cave App. This package is intended to be used by the Cave App and the Cave API.


pkgId: 7cd19856e8586c9ab4e0cf7840f74d70df89105ee19e8efa8fabe93dd0950bec
name: python-caveclient-help
arch: noarch
version: 7.4.1
epoch: 0
release: 1
summary: Development documents and examples for caveclient
url: https://caveconnectome.github.io/CAVEclient/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-caveclient-7.4.1-1.src.rpm
location_href: Packages/python-caveclient-help-7.4.1-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/CAVEclient)
  [![build status](https://github.com/CAVEconnectome/CAVEclient/actions/workflows/daily.yml/badge.svg)](https://github.com/CAVEconnectome/CAVEclient/actions/workflows/daily.yml) [![Downloads](https://static.pepy.tech/badge/caveclient)](https://pepy.tech/project/caveclient)
  [![codecov](https://codecov.io/gh/CAVEconnectome/CAVEclient/graph/badge.svg?token=KVI1AG6B8A)](https://codecov.io/gh/CAVEconnectome/CAVEclient)

  CAVE is short for Connectome Annotation Versioning Engine. CAVE is a set of microservices
  that provide a framework for storing and versioning connectomics data and large sets of
  dynamic annotations, metadata, and segmentations. This repository supplies client-side
  code to easily interact with the microservices in CAVE.

  A full description of the Connectome Annotation Versioning Engine can be found [in this paper](https://www.biorxiv.org/content/10.1101/2023.07.26.550598v1).



  `CAVEclient` can be installed from PyPI:

  ```bash
  pip install caveclient
  ```

  To add optional dependencies (currently for interfacing with the segmentation, imagery,
  and some skeleton formats via cloud-volume), you can install with the following:

  ```bash
  pip install caveclient[cv]
  ```



  Currently we are officially supporting and testing against Python 3.9, 3.10, 3.11 and 3.12.



  You can find full documentation at [caveconnectome.github.io/CAVEclient](https://caveconnectome.github.io/CAVEclient).



  We welcome bug reports and questions. Please post an informative issue on the [GitHub issue tracker](https://github.com/CAVEconnectome/CAVEclient/issues).



  To view information about developing CAVEclient, see our [contributing guide](https://caveconnectome.github.io/CAVEclient/contributing).


pkgId: ad90f6ae903da7666fed2660605fc2a9f56c89c36ce4386c1f91fa74b0cdcd85
name: python-cbar-rates-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for cbar-rates
url: https://github.com/TahirJalilov/cbar-rates/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cbar-rates-1.3.0-1.src.rpm
location_href: Packages/python-cbar-rates-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/cbar-rates)](https://pypi.org/project/cbar-rates)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cbar-rates)](https://pypi.org/project/cbar-rates)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/cbar-rates)](https://pypistats.org/packages/cbar-rates)
  [![License](https://img.shields.io/pypi/l/cbar-rates)](LICENSE.md)

  A Python library to work with Azerbaijani manat (AZN) official exchange rates based on [CBAR](https://cbar.az/currency/rates?language=en) (The Central Bank of the Republic of Azerbaijan).



  - Retrieve official CBAR exchange rates for the Azerbaijani manat (AZN).
  - Compare exchange rates between two dates and calculate differences.
  - Filter results by specific currency codes (e.g., USD, EUR).



  - Python 3.7 or higher
  - `requests` library



  Install the library using pip:

  ```bash
  pip install cbar-rates --upgrade
  ```

  For isolated installations, use a virtual environment:

  ```bash
  python3 -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate
  pip install cbar-rates
  ```





  ```python
  from datetime import date
  import cbar

  rates_date = date.today()
  currencies = ["USD", "EUR"]

  rates = cbar.get_rates(rates_date, currencies)

  print(rates)

  {
      "date": "18.11.2024",
      "currencies": {
          "USD": {
              "nominal": "1",
              "rate": 1.7
          },
          "EUR": {
              "nominal": "1",
              "rate": 1.7919
          },
      }
  }
  ```



  ```python
  from datetime import date
  import cbar

  previous_date = date(2024, 11, 25)
  date_ = date(2024, 11, 26)
  currencies = ["USD", "EUR"]

  rates = cbar.get_rates_with_diff(previous_date, date_, currencies)

  print(rates)

  {
      "previous_date": "25.11.2024",
      "date": "26.11.2024",
      "currencies": {
          "USD": {
              "nominal": "1",
              "previous_rate": 1.7,
              "rate": 1.7,
              "difference": 0.0,
          },
          "EUR": {
              "nominal": "1",
              "previous_rate": 1.7814,
              "rate": 1.7815,
              "difference": 0.0001,
          },
      }
  }
  ```



  ```python
  from datetime import date
  import cbar

  amount = 100
  from_currency = "USD"
  to_currency = "AZN"
  conversion_date = date(2024, 11, 25)

  converted_amount = cbar.convert(amount, from_currency, to_currency, conversion_date)

  print(converted_amount)

  170.0  # 1 USD = 1.7 AZN
  ```

  You can find all available currency codes on the [CBAR website](https://www.cbar.az/currency/rates?language=en)



  This project is licensed under the [MIT License](https://github.com/TahirJalilov/cbar-rates/blob/main/LICENSE.md).


pkgId: 5dc21c7c0e7eba066feb7a5452db3bb11889a84872a748ebe46db567a961bc49
name: python-cbox-tool-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for cbox-tool
url: https://github.com/beliefgp/mybox
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cbox-tool-0.1.0-1.src.rpm
location_href: Packages/python-cbox-tool-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  MyBox 是一个强大的多仓库管理工具，帮助您更好地组织和管理多个 Git 仓库。它支持工作空间管理、批量操作、分支管理等功能，让多仓库管理变得简单高效。



  - **工作空间管理**
    - 创建和管理多个工作空间
    - 导入现有仓库
    - 初始化新仓库
    - 扫描并批量导入仓库

  - **仓库操作**
    - 克隆远程仓库
    - 批量执行 git 操作（pull、push、commit）
    - 查看仓库状态
    - 导入本地仓库

  - **分支管理**
    - 创建、切换、删除分支
    - 合并分支
    - 查看分支状态
    - 批量分支操作





  ```bash
  pip install mybox-tool
  ```



  1. 克隆仓库：
  ```bash
  git clone https://github.com/yourusername/mybox.git
  cd mybox
  ```

  2. 安装依赖：
  ```bash
  pip install -e .
  ```



  1. 创建工作空间：
  ```bash
  mybox workspace add dev ~/projects/dev
  ```

  2. 克隆仓库到工作空间：
  ```bash
  mybox clone dev https://github.com/user/repo.git
  ```

  3. 查看工作空间状态：
  ```bash
  mybox status dev
  ```




  ```bash

  mybox workspace list


  mybox workspace remove dev
  ```


  ```bash

  mybox import dev ~/existing-repo


  mybox init dev new-project


  mybox scan-import dev ~/old-projects
  ```


  ```bash

  mybox pull dev


  mybox commit dev -m "feat: add new feature"


  mybox push dev
  ```


  ```bash

  mybox branch list dev


  mybox branch create dev feature/new-feature


  mybox branch switch dev feature/new-feature


  mybox branch delete dev feature/old-feature
  ```





  ```bash

  mybox add workspace1 ~/projects/workspace1


  mybox list


  mybox import-repo workspace1 ~/existing-repo


  mybox init workspace1 new-project


  mybox scan-import workspace1 ~/projects
  ```



  ```bash

  mybox status workspace1


  mybox pull workspace1


  mybox commit workspace1 "feat: add new feature"


  mybox push workspace1
  ```



  ```bash

  mybox branches workspace1


  mybox create-branch workspace1 feature/new-feature


  mybox switch workspace1 feature/new-feature


  mybox merge workspace1 feature/new-feature


  mybox delete-branch workspace1 feature/new-feature
  ```



  使用 `switch` 命令可以同时切换工作空间中所有仓库的分支。如果本地分支不存在，会自动检查远程仓库：

  ```bash

  mybox switch dev feature/new-ui
  ```

  切换分支时会显示详细的操作结果：

  ```
  切换分支结果:
  仓库      原分支    目标分支         状态
  repo1    main     feature/new-ui   已切换
  repo2    main     feature/new-ui   已在该分支
  repo3    dev      feature/new-ui   有未提交的更改
  repo4    main     feature/new-ui   分支不存在（本地和远程）
  ```

  分支切换过程：
  1. 检查本地是否存在目标分支
  2. 如果本地不存在：
     - 从远程获取最新更新
     - 检查远程是否有对应分支
     - 如果远程分支存在，创建本地分支并设置跟踪
  3. 检查是否有未提交的更改
  4. 执行分支切换

  状态说明：
  - `已切换`：成功切换到目标分支
  - `已在该分支`：当前已经在目标分支上
  - `有未提交的更改`：有未保存的修改，需要先提交或暂存
  - `分支不存在（本地和远程）`：本地和远程都没有找到目标分支
  - `错误: [具体原因]`：其他错误（如权限问题等）





  - `add`: 添加新的工作空间
  - `list`: 列出所有工作空间
  - `clone`: 克隆远程仓库
  - `import-repo`: 导入本地仓库
  - `init`: 初始化新仓库
  - `scan-import`: 扫描并导入仓库



  - `status`: 查看仓库状态
  - `pull`: 拉取更新
  - `push`: 推送更改
  - `commit`: 提交更改



  - `branches`: 列出所有分支
  - `create-branch`: 创建新分支
  - `switch`: 切换分支
  - `merge`: 合并分支
  - `delete-branch`: 删除分支



  MyBox 使用 `~/.mybox.yaml` 存储配置信息。配置文件格式如下：

  ```yaml
  workspace1: /path/to/workspace1
  workspace2: /path/to/workspace2
  ```



  1. **工作空间组织**
     - 按项目类型组织工作空间
     - 相关的仓库放在同一个工作空间
     - 使用有意义的工作空间名称

  2. **批量操作**
     - 使用状态命令检查更改
     - 批量提交前确认消息
     - 定期同步所有仓库

  3. **分支管理**
     - 遵循一致的分支命名规范
     - 及时清理已合并的分支
     - 使用有意义的提交消息



  1. **Q: 如何移动仓库到其他工作空间？**
     A: 使用 `import-repo` 命令将仓库导入到新的工作空间。

  2. **Q: 如何处理合并冲突？**
     A: MyBox 会在合并时提示冲突，需要手动解决冲突后再次提交。

  3. **Q: 如何更新 MyBox？**
     A: 使用 `pip install -e .` 重新安装最新版本。



  欢迎贡献代码和提出建议！请遵循以下步骤：

  1. Fork 仓库
  2. 创建特性分支
  3. 提交更改
  4. 推送到分支
  5. 创建 Pull Request



  MIT License




  ```
  名称    路径                状态
  dev     ~/projects/dev     活动
  work    ~/workspace        未找到
  ```


  ```
  仓库        分支    状态      未跟踪
  repo1      main    clean     0
  repo2      dev     有更改    2
  ```


  ```
  repo1
  分支名     当前    远程跟踪      最后提交
  main      ✓      origin/main   feat: add new feature
  develop          origin/dev    fix: update dependencies

  repo2
  分支名     当前    远程跟踪      最后提交
  main      ✓      origin/main   docs: update README
  ```



  MyBox 提供清晰的错误提示：

  - 导入已存在的仓库：
    ```
    错误: 目标路径 '/path/to/workspace/existing-repo' 已存在
    ```

  - 扫描导入结果：
    ```
    扫描完成:
    ✓ 成功导入: 2 个仓库
    - 已存在: 1 个仓库
    ✗ 导入失败: 1 个仓库

    失败详情:
      - /path/to/repo: 错误原因
    ```


pkgId: 5a5ad558fb5f422d601ae41c48addc463f7e782cd48b98421d422a016f2dd48d
name: python-cbpi4gui-help
arch: noarch
version: 0.3.17.2
epoch: 0
release: 1
summary: Development documents and examples for cbpi4gui
url: https://openbrewing.gitbook.io/craftbeerpi4_support/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cbpi4gui-0.3.17.2-1.src.rpm
location_href: Packages/python-cbpi4gui-help-0.3.17.2-1.noarch.rpm
checksum_type: sha256
description:
  After installation the plugin UI is available under to following url
  http://localhost:8000#



  ```npm start``` for testing the web app

  - Server needs to be started on the same host and UI is accessible via http://localhost:3000

  ```npm run build``` to build the webapp



  ```python3 setup.py develop```



  ```python3 setup.py sdist```



  - 21.08.24: (0.3.17.1) Update power value on power slider, if button action was used to adjust power
  - 01.08.24: (0.3.17) Fixed Bug for pipe color for existing pipes
  - 08.07.24: (0.3.16) Change position of notification information in tab title. Add options to pipes (opaqueness, width, color). Add progress bar to actor button for power display and for progress on compressor actor plugin
  - 01.07.24: (0.3.15) Update Brewfather API calls to V2 API, Add information about # of notifications to tab title
  - 06.06.24: (0.3.14.rc0) Some internal adaptions which require also server version 4.4.1.rc0 (Renaming of CustomSVG properties)
  - 31.05.24: (0.3.14.a7) Added actor dependency possibility to CustomSVG (Different SVG to be displayed depending on actor status). Activated Badge icon to display past 100 notifications
  - 28.05.24: (0.3.14.a3) Test on different color of sensor value if value is to far from target
  - 24.05.24: (0.3.14.a2) Fixed error in download log introduced with 0.3.14.a1
  - 10.05.24: (0.3.14.a1) Add date in front of filename for backup download
  - 12.01.24: (0.3.13) Variable dashboard grid width in edit mode and some fixes
  - 31.05.23: (0.3.12) Change version to release
  - 31.05.23: (0.3.12.rc1) Added various tooltips and fixed issue if fermenter recipe contained special characters (-> will be automatically replaced). Option on analytics page to delete all logs
  - 17.04.23: (0.3.12.a5) Added selection option to settings page for global plugin settings, Option to remove obsolete global settings on system page.
  - 18.03.23: (0.3.11) Added play buzzer option to web interface, some fixes in grafana widget.pip install
  - 10.03.23: (0.3.10) Added datatype to sensor values -> Allows datetime and string (e.g. time of last received data from ispindle plugin or alarmtimer)
  - 07.03.23: (0.3.7) Added Power Slider for Actors
  - 17.02.23: (0.3.6) Fix Bug in Grafana Widget | Add text property timeframe to Grafana widget (e.g. now-2h or now-7d 2023-02-17 12:00 can be entered)
  - 01.02.23: (0.3.2) Bump Version to release
  - 29.01.23: (0.3.2.rc6) Axis styling on analytics page adapted to allow for better reading
  - 28.01.23: (0.3.2.rc5) Togglebutton import changed to new requirements on analytics page
  - 27.01.23: (0.3.2.rc4) Fixed bug for sensor action, added hover effect on steps and fermentersteps, added gui version info on about page
  - 26.01.23: (0.3.2.rc2) Replaced some deprecated functions and adapted style for step/fermenterstep widget
  - 23.01.23: (0.3.2.b5) Fixed sensor digits of harware table to 1
  - 22.01.23: (0.3.2.b4) Merged pull request [#30](https://github.com/avollkopf/craftbeerpi4-ui/pull/30) and removed unused imports
  - 20.01.23: (0.3.2.b1) Some bugs fixed where reload page via browser caused an issue (e.g. settings page)
  - 08.01.23: (0.3.2.a5) Some style updates
  - 06.01.23: (0.3.2.a2) UI migrated to @mui V5 and react 18.2.0 (Alpha version not officially released)
  - 05.01.23: (0.3.0.a1) UI migrated to React Router V6 (Alpha version not officially released)
  - 10.12.22: (0.2.3) Some updates, fixes and additional features
  - 12.05.22: (0.2.2) First working release


pkgId: d373794e4c1f1503bf8c18d445b0bbabd658e60b3be782b0a795cb1f29a1218c
name: python-cbr-website-beta-help
arch: noarch
version: 0.221.1
epoch: 0
release: 1
summary: Development documents and examples for cbr-website-beta
url: https://github.com/the-cyber-boardroom/cbr-website-beta
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cbr-website-beta-0.221.1-1.src.rpm
location_href: Packages/python-cbr-website-beta-help-0.221.1-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta/graph/badge.svg?token=NZDJOJ2CYH)](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta)
  ![Current Release](https://img.shields.io/badge/release--blue)



  Main repo for The Cyber Boardroom website deployed in a serverless AWS environment (i.e. using Lambdas)




  Here is the [CodeCov page](https://app.codecov.io/gh/the-cyber-boardroom/cbr-website-beta) for this repo

  ![](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta/graphs/sunburst.svg?token=NZDJOJ2CYH)
  ![](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta/graphs/tree.svg?token=NZDJOJ2CYH)
  ![](https://codecov.io/gh/the-cyber-boardroom/cbr-website-beta/graphs/icicle.svg?token=NZDJOJ2CYH)


pkgId: 3b0dba667f9f30f524694a592adcf819ca6fb61a246b32e5c8f8633ce6b6740b
name: python-ccdt-help
arch: noarch
version: 2.1.130
epoch: 0
release: 1
summary: Development documents and examples for ccdt
url: https://github.com/chipeak/chipeak_cv_data_tool
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccdt-2.1.130-1.src.rpm
location_href: Packages/python-ccdt-help-2.1.130-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="resources/LOGO.png" width="450"/>
    <center>

    [![PyPI](https://img.shields.io/badge/pypi-v1.0.0-blue)](https://pypi.org/project/ccdt/)
    [![license](https://img.shields.io/badge/license-GNU%20General%20Public%20License-green)](https://github.com/540717421/chipeak_cv_data_tool/blob/main/LICENSE)

    </center>
  </div>



  简体中文| [English](README_EN.md)

  &nbsp;&nbsp;&nbsp;&nbsp;chipeak_cv_data_tool主要用于多种数据集(计算机视觉)格式之间的相互转换,如coco、labelme等。另外还集成数据、文件、视频等文件常用的处理功能。



  1. 集成多种计算机视觉标注格式相互转换
  2. 支持各类数据集的筛选,分配与切割
  3. 集成多种文件、图像、视频处理功能
  4. 模块可拓展,用户可自定义数据格式
  5. 提供python模块包,命令行等便捷方式



  pip install ccdt


  请参考[快速入门文档](docs/get_started.md)学习 chipeak_cv_data_tool 的基本使用。



  labelme:https://github.com/wkentaro/labelme


  * 数据支持集格式：
      - [x] labelme格式数据集 https://github.com/wkentaro/labelme
      - [x] COCO格式数据集
  * 数据处理功能：
      - [x] 数据集标注文件相互转换
      - [x] 截取目标保存为图像(目前支持:矩形框,)
  * 图像(文件)处理：
      - [x] 按比例或者文件数目划分数据(列如:文件分配或者训练测试集划分)
  * 视频处理：
      - [x] 视频切片成图像
      - [x] 图像合成为视频


  * 数据支持集格式：
      - [x] labelme格式数据集 https://github.com/wkentaro/labelme
      - [x] COCO格式数据集
  * 数据处理功能：
      - [x] 数据集标注文件相互转换
      - [x] 截取目标保存为图像(目前支持:矩形框,)
  * 图像(文件)处理：
      - [x] 按比例或者文件数目划分数据(列如:用于文件分配或者训练测试集划分)
  * 视频处理：
      - [x] 视频切片成图像
      - [x] 图像合成为视频



  该项目采用 [GNU General Public License v3.0 开源许可证](LICENSE)。



  最新的月度版本 v1.0 在 2021.11.08 发布。

  已支持的数据集：

  - [x] COCO数据集
  - [x] Via标注数据集
  - [x] Labelme标注数据集


  已更新的功能：

  - [x] labelme数据集抠图
  - [x] coco数据集转labelme数据集
  - [x] labelme数据集转coco数据集
  - [x] 根据标签类别筛选labelme数据集



  无



  无



  ```
  @misc{ccdt2021,
    author =       {詹勇},
    title =        {{ccdt: Annotation conversion and file video processing tools}},
    howpublished = {url{https://github.com/chipeak/chipeak_cv_data_tool.git}},
    year =         {2023}
  }
  ```


  - [ccdt](https://github.com/540717421/chipeak_data_tool): chipeak_cv_data_tool AI数据处理工具箱




  扫描下方的二维码可关注 芯峰科技团队的 [官方网站](http://http://www.chipeak.com/)，加入芯峰科技 团队的 [官方交流](http://www.chipeak.com/account/login)
  <div align="center">
  <img src="/resources/xf_rq_code.png" height="200" />
  </div>
  我们会在 ChiPeak 社区为大家

  - 📢 分享 AI 框架的前沿核心技术
  - 💻 解读 ccdt 常用模块源码
  - 📰 发布 ChiPeak 的相关新闻
  - 🚀 介绍 ChiPeakDetection 开发的前沿算法
  - 🏃 获取更高效的问题答疑和意见反馈
  - 🔥 提供与各行各业开发者充分交流的平台

  干货满满 📘，等你来撩 💗，ChiPeak 社区期待您的加入 👬


  [![Security Status](https://www.murphysec.com/platform3/v31/badge/1673251865674670080.svg)](https://www.murphysec.com/console/report/1673251865636921344/1673251865674670080)


pkgId: 4dd1af55fe8314306b75c40edbd80c3ed6be6adda28fdeb1a0f2ba3a5ef99711
name: python-ccpi-regularisation-cupy-help
arch: noarch
version: 24.1.0
epoch: 0
release: 1
summary: Development documents and examples for ccpi-regularisation-cupy
url: https://pypi.org/project/ccpi-regularisation-cupy/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccpi-regularisation-cupy-24.1.0-1.src.rpm
location_href: Packages/python-ccpi-regularisation-cupy-help-24.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CI status](https://anvil.softeng-support.ac.uk/jenkins/buildStatus/icon?subject=master&job=CILsingle/CCPi-Regularisation-Toolkit)](https://anvil.softeng-support.ac.uk/jenkins/job/CILsingle/job/CCPi-Regularisation-Toolkit/lastBuild)
  [![conda version](https://anaconda.org/ccpi/ccpi-regulariser/badges/version.svg) ![conda date](https://anaconda.org/ccpi/ccpi-regulariser/badges/latest_release_date.svg) ![conda platforms](https://anaconda.org/ccpi/ccpi-regulariser/badges/platforms.svg) ![conda downloads](https://anaconda.org/ccpi/ccpi-regulariser/badges/downloads.svg)](https://anaconda.org/ccpi/ccpi-regulariser)
  [![License](https://img.shields.io/github/license/TomographicImaging/CCPi-Regularisation-Toolkit)](https://github.com/TomographicImaging/CCPi-Regularisation-Toolkit/blob/master/LICENSE)

  Iterative image reconstruction (IIR) methods frequently require regularisation to ensure convergence and make inverse problem well-posed. The CCPi-Regularisation Toolkit (CCPi-RGL) toolkit provides a set of 2D/3D regularisation strategies to guarantee a better performance of IIR methods (higher SNR and resolution). The regularisation modules for scalar and vectorial datasets are based on the [proximal operator](https://en.wikipedia.org/wiki/Proximal_operator) framework and can be used with [proximal splitting algorithms](https://en.wikipedia.org/wiki/Proximal_gradient_method), such as PDHG, Douglas-Rachford, ADMM, FISTA and [others](https://arxiv.org/abs/0912.3522). While the main target for CCPi-RGL is [tomographic image reconstruction](https://github.com/dkazanc/ToMoBAR), the toolkit can be used for image denoising problems. The core modules are written in C-OMP and CUDA languages and wrappers for Matlab and Python are provided. With [CuPy](https://docs.cupy.dev/en/stable/index.html) dependency installed for Python, one can use regularisers directly without the need for explicit compilation. We recommend this option as the simplest to start with if you've got a GPU. This software can also be used by running in parallel across multiple GPU devices on a PC or a cluster compute node.

  <div align="center"><img src="demos/images/CCPiRGL_sm.jpg" height="400"></div>



  - Python (3.7+) and/or [MATLAB](https://www.mathworks.com/products/matlab)
  - C compilers
  - `nvcc` (CUDA SDK) compilers
    - [CuPy](https://docs.cupy.dev) for the GPU-enabled methods





  1. Rudin-Osher-Fatemi (ROF) Total Variation (explicit PDE minimisation scheme) **2D/3D CPU/GPU + CuPy**[^1]
  2. Fast-Gradient-Projection (FGP) Total Variation **2D/3D CPU/GPU**[^2]
  3. Split-Bregman (SB) Total Variation **2D/3D CPU/GPU**[^5]
  4. Primal-Dual (PD) Total Variation **2D/3D CPU/GPU + CuPy**[^13]
  5. Total Generalised Variation (TGV) model for higher-order regularisation **2D/3D CPU/GPU**[^6][^13]
  6. Linear and nonlinear diffusion (explicit PDE minimisation scheme) **2D/3D CPU/GPU**[^8]
  7. Anisotropic Fourth-Order Diffusion (explicit PDE minimisation) **2D/3D CPU/GPU**[^9]
  8. A joint ROF-LLT (Lysaker-Lundervold-Tai) model for higher-order regularisation **2D/3D CPU/GPU**[^10][^11]
  9. Nonlocal Total Variation regularisation (GS fixed point iteration) **2D CPU/GPU**[^12]



  1. Fast-Gradient-Projection (FGP) Directional Total Variation **2D/3D CPU/GPU**[^3][^4][^2]
  2. Total Nuclear Variation (TNV) penalty **2D+channels CPU**[^7]



  The package comes as a [CMake](https://cmake.org) project and additional wrappers for Python and Matlab. Please see more detailed [Installation](./Installation.md) information.



  To install precompiled binaries, you need `conda` and install from the `ccpi` channel using :

  ```sh
  conda install ccpi-regulariser -c ccpi -c conda-forge
  ```



  One can also use some of the GPU modules with the provided [CuPy](https://docs.cupy.dev/en/stable/index.html) interfaces. The functions in `ccpi-regularisation-cupy` package work with CuPy arrays as an input and return a CuPy array for output.

  ```sh
  conda install -c httomo ccpi-regularisation-cupy
  ```

  Once installed please see [Demos](./demos/demo_gpu_regularisers3D_CuPy.py). Please note that not all modules are yet supported as this is an ongoing development. One can install both CuPy-driven and the `ccpi-regulariser` package in one environment, but please be aware that the functions carry the identical names.



  [^1]: [Rudin, L.I., Osher, S. and Fatemi, E., 1992. Nonlinear total variation based noise removal algorithms. Physica D: nonlinear phenomena, 60(1-4)](https://www.sciencedirect.com/science/article/pii/016727899290242F)
  [^2]: [Beck, A. and Teboulle, M., 2009. Fast gradient-based algorithms for constrained total variation image denoising and deblurring problems. IEEE Transactions on Image Processing, 18(11)](https://doi.org/10.1109/TIP.2009.2028250)
  [^3]: [Ehrhardt, M.J. and Betcke, M.M., 2016. Multicontrast MRI reconstruction with structure-guided total variation. SIAM Journal on Imaging Sciences, 9(3)](https://doi.org/10.1137/15M1047325)
  [^4]: [Kazantsev, D., Jørgensen, J.S., Andersen, M., Lionheart, W.R., Lee, P.D. and Withers, P.J., 2018. Joint image reconstruction method with correlative multi-channel prior for X-ray spectral computed tomography. Inverse Problems, 34(6)](https://doi.org/10.1088/1361-6420/aaba86) **Results can be reproduced using the following** [SOFTWARE](https://github.com/dkazanc/multi-channel-X-ray-CT)
  [^5]: [Goldstein, T. and Osher, S., 2009. The split Bregman method for L1-regularized problems. SIAM journal on imaging sciences, 2(2)](https://doi.org/10.1137/080725891)
  [^6]: [Bredies, K., Kunisch, K. and Pock, T., 2010. Total generalized variation. SIAM Journal on Imaging Sciences, 3(3)](https://doi.org/10.1137/090769521)
  [^7]: [Duran, J., Moeller, M., Sbert, C. and Cremers, D., 2016. Collaborative total variation: a general framework for vectorial TV models. SIAM Journal on Imaging Sciences, 9(1)](https://doi.org/10.1137/15M102873X)
  [^8]: [Black, M.J., Sapiro, G., Marimont, D.H. and Heeger, D., 1998. Robust anisotropic diffusion. IEEE Transactions on image processing, 7(3)](https://doi.org/10.1109/83.661192)
  [^9]: [Hajiaboli, M.R., 2011. An anisotropic fourth-order diffusion filter for image noise removal. International Journal of Computer Vision, 92(2)](https://doi.org/10.1007/s11263-010-0330-1)
  [^10]: [Lysaker, M., Lundervold, A. and Tai, X.C., 2003. Noise removal using fourth-order partial differential equation with applications to medical magnetic resonance images in space and time. IEEE Transactions on image processing, 12(12)](https://doi.org/10.1109/TIP.2003.819229)
  [^11]: [Kazantsev, D., Guo, E., Phillion, A.B., Withers, P.J. and Lee, P.D., 2017. Model-based iterative reconstruction using higher-order regularization of dynamic synchrotron data. Measurement Science and Technology, 28(9)](https://doi.org/10.1088/1361-6501/aa7fa8)
  [^12]: [Abderrahim E., Lezoray O. and Bougleux S. 2008. Nonlocal discrete regularization on weighted graphs: a framework for image and manifold processing. IEEE Trans. Image Processing 17(7), pp. 1047-1060.](https://ieeexplore.ieee.org/document/4526700)
  [^13]: [Chambolle, A. and Pock, T., 2010. A first-order primal-dual algorithm for convex problems with applications to imaging. Journal of mathematical imaging and vision 40(1)](https://doi.org/10.1007/s10851-010-0251-1)



  - [Kazantsev, D., Pasca, E., Turner, M.J. and Withers, P.J., 2019. CCPi-Regularisation toolkit for computed tomographic image reconstruction with proximal splitting algorithms. SoftwareX, 9, pp.317-323.](https://www.sciencedirect.com/science/article/pii/S2352711018301912)



  - [The Core Imaging Library](https://github.com/TomographicImaging/CIL) by [CCPi](https://ccpi.ac.uk/cil/)
  - [TOmographic MOdel-BAsed Reconstruction (ToMoBAR)](https://github.com/dkazanc/ToMoBAR)
  - [Joint image reconstruction method with correlative multi-channel prior for X-ray spectral computed tomography (MATLAB code)](https://github.com/dkazanc/multi-channel-X-ray-CT)



  [![License](https://img.shields.io/github/license/TomographicImaging/CCPi-Regularisation-Toolkit)](https://github.com/TomographicImaging/CCPi-Regularisation-Toolkit/blob/master/LICENSE)



  CCPi-RGL software is a product of the [CCPi](https://www.ccpi.ac.uk) group and STFC SCD software developers.
  Any relevant questions/comments can be e-mailed to [Daniil Kazantsev](mailto:dkazanc@hotmail.com).


pkgId: a98ba2ffeb1753cbba1f7340bbe56b5446503ca5a83eadda3a11823b0039d358
name: python-ccs-digitalmarketplace-apiclient-help
arch: noarch
version: 29.12.2
epoch: 0
release: 1
summary: Development documents and examples for ccs-digitalmarketplace-apiclient
url: https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-apiclient
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccs-digitalmarketplace-apiclient-29.12.2-1.src.rpm
location_href: Packages/python-ccs-digitalmarketplace-apiclient-help-29.12.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)
  ![Python 3.13](https://img.shields.io/badge/python-3.13-blue.svg)
  [![PyPI version](https://badge.fury.io/py/ccs-digitalmarketplace-apiclient.svg)](https://badge.fury.io/py/ccs-digitalmarketplace-apiclient)

  API clients for Digital Marketplace [Data API](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-api) and
  [Search API](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-search-api).
  Originally was part of [Digital Marketplace Utils](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-utils).

  Install Python dependencies:
  ```
  make bootstrap
  invoke requirements-dev
  ```
  Run the tests:
  ```
  invoke test
  ```

  ```python
  data_client = apiclient.DataAPIClient(api_url, api_access_token)
  services = data_client.find_services_iter(framework=frameworks)
  ```

  To update the package version, edit the `__version__ = ...` string in `dmapiclient/__init__.py`,
  commit and push the change and wait for CI to create a new version tag.
  Once the tag is available on GitHub, the new version can be used by the apps by adding the following
  line to the app `requirements.txt` (replacing `X.Y.Z` with the current version number):
  ```
  git+https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-apiclient.git@X.Y.Z#egg=ccs-digitalmarketplace-apiclient==X.Y.Z
  ```
  When changing a major version number consider adding a record to the `CHANGELOG.md` with a
  description of the change and an example of the upgrade process for the client apps.

  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.

  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.
  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.
  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/
  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: 7461ac38570821431bc5b91a1aa028208081e51bf25808ebd8fc2a8d412d88c2
name: python-ccs-digitalmarketplace-content-loader-help
arch: noarch
version: 13.0.1
epoch: 0
release: 1
summary: Development documents and examples for ccs-digitalmarketplace-content-loader
url: https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-content-loader
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccs-digitalmarketplace-content-loader-13.0.1-1.src.rpm
location_href: Packages/python-ccs-digitalmarketplace-content-loader-help-13.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)
  [![PyPI version](https://badge.fury.io/py/ccs-digitalmarketplace-content-loader.svg)](https://badge.fury.io/py/ccs-digitalmarketplace-content-loader)

  Content loader for Digital Marketplace.
  Originally was part of [Digital Marketplace Utils](https://github.com/Crown-Commercial-Service/digitalmarketplace-utils).

  Install Python dependencies
  ```
  make bootstrap
  invoke requirements-dev
  ```
  Run the tests
  ```
  invoke test
  ```

  To update the package version, edit the `__version__ = ...` string in `dmcontent/__init__.py`,
  once merged the new version will be released and published to [PyPI](https://pypi.org/project/digitalmarketplace-content-loader/) by [Github Actions](./.github/workflows).
  When changing a major version number consider adding a record to the `CHANGELOG.md` with a
  description of the change and an example of the upgrade process for the client apps.

  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.

  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.
  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.
  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/
  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: 1f1c2546f47912b9e9efa8ddd9ce6a06a0b5f01cda32f435bdf0fc0319854a20
name: python-ccs-digitalmarketplace-frontend-jinja-help
arch: noarch
version: 3.0.2
epoch: 0
release: 1
summary: Development documents and examples for ccs-digitalmarketplace-frontend-jinja
url: https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-frontend-jinja
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccs-digitalmarketplace-frontend-jinja-3.0.2-1.src.rpm
location_href: Packages/python-ccs-digitalmarketplace-frontend-jinja-help-3.0.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)
  [![PyPI version](https://badge.fury.io/py/ccs-digitalmarketplace-frontend-jinja.svg)](https://badge.fury.io/py/ccs-digitalmarketplace-frontend-jinja)
  This repository provides a complete set of [Jinja](https://jinja.palletsprojects.com/) macros that are kept up-to-date and 100% compliant with [CCS Digital Marketplace GOV.UK Frontend](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend) Nunjucks macros. Porting is intentionally manual rather than automated to make updates simpler than maintaining an automated conversion routine. A comprehensive test suite ensures compliance against the latest, and every subsequent, CCS GOV.UK Frontend Frontend release.
  This project was inspired by the [GOV.UK Frontend Jinja Macros](https://github.com/LandRegistry/govuk-frontend-jinja) project by [HM Land Registry](https://github.com/LandRegistry) and we thank them for their work which has helped with this project.

  The following table shows the version of Digital Marketplace Frontend Jinja that you should use for your targeted version of CCS Digital Marketplace GOV.UK Frontend:
  | Digital Marketplace Frontend Jinja Version | Target CCS Digital Marketplace GOV.UK Frontend Version |
  | ------------------------------------------ | ------------------------------------------------------ |
  | [3.0.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/3.0.1) | [2.0.2](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v2.0.2) |
  | [2.10.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.10.0) | [1.3.1](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v1.3.1) |
  | [2.9.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.9.0) | [1.2.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v1.2.0) |
  | [2.8.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.8.0) | [1.1.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v1.1.0) |
  | [2.7.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.7.0) | [1.0.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/v1.0.0) |
  | [2.6.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.6.0) | [6.4.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.4.0) |
  | [2.5.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.5.0) | [6.3.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.3.0) |
  | [2.2.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.2.0) | [6.2.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.2.0) |
  | [2.1.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.1.1) | [6.1.1](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.1.1) |
  | [2.1.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.1.0) | [6.1.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.1.0) |
  | [2.0.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/2.0.0) | [6.0.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/6.0.0) |
  | [1.4.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.4.1) | [5.5.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.5.0) |
  | [1.4.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.4.0) | [5.5.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.5.0) |
  | [1.3.3](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.3.3) | [5.4.3](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.4.3) |
  | [1.3.2](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.3.2) | [5.4.2](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.4.2) |
  | [1.3.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.3.1) | [5.4.1](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.4.1) |
  | [1.3.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.3.0) | [5.4.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.4.0) |
  | [1.2.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.2.0) | [5.2.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.2.0) |
  | [1.1.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.1.0) | [5.2.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.2.0) |
  | [1.0.2](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.0.2) | [5.1.2](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.1.2) |
  | [1.0.1](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.0.1) | [5.1.1](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.1.1) |
  | [1.0.0](https://github.com/tim-s-ccs/ccs-digitalmarketplace-frontend-jinja/releases/tag/1.0.0) | [5.1.0](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/releases/tag/5.1.0) |
  Any other versions of CCS Digital Marketplace GOV.UK Frontend not shown above _may_ still be compatible, but have not been specifically tested and verified.

  After running `pip install ccs-digitalmarketplace-frontend-jinja`, ensure that you tell Jinja where to load the templates from using the `PackageLoader` as follows:
  ```python
  from flask import Flask
  from jinja2 import ChoiceLoader, PackageLoader, PrefixLoader
  app = Flask(__name__)
  app.jinja_loader = ChoiceLoader(
      [
          PackageLoader("app"),
          PrefixLoader(
            {
              "govuk_frontend_jinja": PackageLoader("govuk_frontend_jinja"),
              "digitalmarketplace_frontend_jinja": PackageLoader("digitalmarketplace_frontend_jinja"),
            }
          ),
      ]
  )
  ```

  To use a component in your project templates you must import and call the component macro and pass the relevant options, for example:
  ```html
  { from 'digitalmarketplace_frontend_jinja/components/alert/macro.html' import digitalmarketplaceAlert -%}
  {{ digitalmarketplaceAlert({
      "titleText": "Your application is complete",
      "text": "You still have 3 unsubmitted services",
      "type" : "success"
  }) }}
  ```
  The options available to each component macro can be found in the original [CCS Digital Marketplace GOV.UK Frontend](https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-govuk-frontend/tree/main/packages/digitalmarketplace-frontend/src/digitalmarketplace/components) documentation. Since this project is a like-for-like port, the only difference between the Nunjucks examples and their Jinja equivalents is having to quote key names, e.g. `'text'` instead of `text`.

  Releases of this project follow [semantic versioning](http://semver.org/), ie
  > Given a version number MAJOR.MINOR.PATCH, increment the:
  >
  > - MAJOR version when you make incompatible API changes,
  > - MINOR version when you add functionality in a backwards-compatible manner, and
  > - PATCH version when you make backwards-compatible bug fixes.
  To make a new version:
  - update the version in the `digitalmarketplace_frontend_jinja/__init__.py` file
  - if you are making a major change, also update the change log;
  When the pull request is merged a GitHub Action will tag the new version.

  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.

  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.
  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.
  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/
  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: 14ae3fd177afccf803621e56e9c27486767330155b5a21d640bd4c7577dbbf9b
name: python-ccs-digitalmarketplace-test-utils-help
arch: noarch
version: 6.1.1
epoch: 0
release: 1
summary: Development documents and examples for ccs-digitalmarketplace-test-utils
url: https://github.com/Crown-Commercial-Service/ccs-digitalmarketplace-test-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccs-digitalmarketplace-test-utils-6.1.1-1.src.rpm
location_href: Packages/python-ccs-digitalmarketplace-test-utils-help-6.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Python 3.11](https://img.shields.io/badge/python-3.11-blue.svg)
  ![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)
  ![Python 3.13](https://img.shields.io/badge/python-3.13-blue.svg)
  [![PyPI version](https://badge.fury.io/py/ccs-digitalmarketplace-test-utils.svg)](https://badge.fury.io/py/ccs-digitalmarketplace-test-utils)

  Utility functions and scripts for testing Digital Marketplace code

  This library's dependencies are deliberately kept minimal - see comment in `setup.py` before
  adding any more!



  Releases of this project follow [semantic versioning](http://semver.org/), ie
  > Given a version number MAJOR.MINOR.PATCH, increment the:
  >
  > - MAJOR version when you make incompatible API changes,
  > - MINOR version when you add functionality in a backwards-compatible manner, and
  > - PATCH version when you make backwards-compatible bug fixes.

  To make a new version:
  - update the version in the `dmutils/__init__.py` file
  - if you are making a major change, also update the change log;

  When the pull request is merged a GitHub Action will tag the new version.



  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.



  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.

  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.

  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/

  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: 441c9700953ed0bbabe0639f7409d5db4aa7430219760c2fdc8c071f60ef4845
name: python-ccs-govuk-frontend-jinja-help
arch: noarch
version: 1.4.1
epoch: 0
release: 1
summary: Development documents and examples for ccs-govuk-frontend-jinja
url: https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccs-govuk-frontend-jinja-1.4.1-1.src.rpm
location_href: Packages/python-ccs-govuk-frontend-jinja-help-1.4.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ccs-govuk-frontend-jinja.svg)](https://pypi.org/project/ccs-govuk-frontend-jinja/)
  ![govuk-frontend 5.4.0](https://img.shields.io/badge/govuk--frontend%20version-5.4.0-005EA5?logo=gov.uk&style=flat)
  [![Python package](https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja/actions/workflows/python-package.yml/badge.svg)](https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja/actions/workflows/python-package.yml)

  **This is a fork of [GOV.UK Frontend Jinja Macros](https://github.com/LandRegistry/govuk-frontend-jinja) which has not been updated beyond GOV.UK Frontend v5.1. This is for use in the Digital Marketplace until it starts to get updated again.**

  **GOV.UK Frontend Jinja is a [community tool](https://design-system.service.gov.uk/community/resources-and-tools/) of the [GOV.UK Design System](https://design-system.service.gov.uk/). The Design System team is not responsible for it and cannot support you with using it. Contact the [maintainers](#contributors) directly if you need [help](#support) or you want to request a feature.**

  This repository provides a complete set of [Jinja](https://jinja.palletsprojects.com/) macros that are kept up-to-date and 100% compliant with the original [GOV.UK Frontend](https://github.com/alphagov/govuk-frontend) Nunjucks macros. Porting is intentionally manual rather than automated to make updates simpler than maintaining an automated conversion routine. A comprehensive test suite ensures compliance against the latest, and every subsequent, GOV.UK Frontend release.




  The following table shows the version of CCS GOV.UK Frontend Jinja that you should use for your targeted version of GOV.UK Frontend:

  | CCS GOV.UK Frontend Jinja Version | Target GOV.UK Frontend Version |
  | ----------------------------- | ------------------------------ |
  | [1.3.0](https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja/releases/tag/1.3.0) | [5.7.1](https://github.com/alphagov/govuk-frontend/releases/tag/v5.7.1) |
  | [1.2.2](https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja/releases/tag/1.2.2) | [5.5.0](https://github.com/alphagov/govuk-frontend/releases/tag/v5.5.0) |
  | [1.2.1](https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja/releases/tag/1.2.1) | [5.4.1](https://github.com/alphagov/govuk-frontend/releases/tag/v5.4.1) |
  | [1.2.0](https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja/releases/tag/1.2.0) | [5.4.0](https://github.com/alphagov/govuk-frontend/releases/tag/v5.4.0) |
  | [1.1.0](https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja/releases/tag/1.1.0) | [5.4.0](https://github.com/alphagov/govuk-frontend/releases/tag/v5.4.0) |
  | [1.0.0](https://github.com/tim-s-ccs/ccs-govuk-frontend-jinja/releases/tag/1.0.0) | [5.3.1](https://github.com/alphagov/govuk-frontend/releases/tag/v5.3.1) |

  Any other versions of GOV.UK Frontend not shown above _may_ still be compatible, but have not been specifically tested and verified.

  Use [GOV.UK Frontend Jinja Macros](https://github.com/LandRegistry/govuk-frontend-jinja) for older versions of GOV.UK Frontend



  After running `pip install ccs-govuk-frontend-jinja`, ensure that you tell Jinja where to load the templates from using the `PackageLoader` as follows:

  ```python
  from flask import Flask
  from jinja2 import ChoiceLoader, PackageLoader, PrefixLoader

  app = Flask(__name__)

  app.jinja_loader = ChoiceLoader(
      [
          PackageLoader("app"),
          PrefixLoader({"govuk_frontend_jinja": PackageLoader("govuk_frontend_jinja")}),
      ]
  )
  ```



  To use a component in your project templates you must import and call the component macro and pass the relevant options, for example:

  ```html
  { from 'govuk_frontend_jinja/components/button/macro.html' import govukButton -%}

  {{ govukButton({
    'text': "Save and continue"
  }) }}
  ```

  The options available to each component macro can be found in the original [GOV.UK Design System Components](https://design-system.service.gov.uk/components/) documentation. Since this project is a like-for-like port, the only difference between the Nunjucks examples and their Jinja equivalents is having to quote key names, e.g. `'text'` instead of `text`.



  The tests are run in a GitHub actions pipeline and you can run them locally with `pytest`.

  You will need to download the GOV.UK Frontend package via npm with:

  ```bash
  npm i
  ```

  You can install the requirements for your chosen version of Python with:

  ```bash
  pip install -r requirements-test-<YOUR_PYTHON_VERSION>.txt
  ```

  You can then run the tests with:

  ```bash
  pytest
  ```

  The tests compare the HTML for each component fixture, which are within the GOV.UK Frontend package, with HTML generated by the Jinja macros.



  Releases of this project follow [semantic versioning](http://semver.org/), ie
  > Given a version number MAJOR.MINOR.PATCH, increment the:
  >
  > - MAJOR version when you make incompatible API changes,
  > - MINOR version when you add functionality in a backwards-compatible manner, and
  > - PATCH version when you make backwards-compatible bug fixes.

  To make a new version:
  - update the version in the `digitalmarketplace_frontend_jinja/__init__.py` file
  - if you are making a major change, also update the change log;

  When the pull request is merged a GitHub Action will tag the new version.



  This project has a [pre-commit hook][pre-commit hook] to do some general file checks and check the `pyproject.toml`.
  Follow the [Quick start][pre-commit quick start] to see how to set this up in your local checkout of this project.



  Unless stated otherwise, the codebase is released under [the MIT License][mit].
  This covers both the codebase and any sample code in the documentation.

  The documentation is [&copy; Crown copyright][copyright] and available under the terms
  of the [Open Government 3.0][ogl] licence.

  [mit]: LICENCE
  [copyright]: http://www.nationalarchives.gov.uk/information-management/re-using-public-sector-information/uk-government-licensing-framework/crown-copyright/
  [ogl]: http://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/

  [pre-commit hook]: https://pre-commit.com/
  [pre-commit quick start]: https://pre-commit.com/#quick-start


pkgId: b09bbf7aaea8e057768fd53b7c4caefcb0ba03fe3ca940a0355043dfa9d4160a
name: python-ccx2paraview-help
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: Development documents and examples for ccx2paraview
url: https://github.com/calculix/ccx2paraview
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccx2paraview-3.2.0-1.src.rpm
location_href: Packages/python-ccx2paraview-help-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [Downloads](https://github.com/calculix/ccx2paraview/releases) |
  [How to use](#how-to-use) |
  [Screenshots](#screenshots) |
  [Your help](#your-help) |
  [For developers](#for-developers) |


pkgId: 74d827bd5ef6ff000f0dda574748107527e3dd580381079e53ec0c0fdc74e3a1
name: python-cdb-cellmaps-help
arch: noarch
version: 0.0.1a1000207
epoch: 0
release: 1
summary: Development documents and examples for cdb-cellmaps
description:
  ```bash
  pip install cdb_cellmaps

url: https://cincodebio.colmb.me/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdb-cellmaps-0.0.1a1000207-1.src.rpm
location_href: Packages/python-cdb-cellmaps-help-0.0.1a1000207-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright 2024 CincoDeBio  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 9493fac7336873a6e65c393ceb90851462074646e9e572f4c33dc1413be29fa9
name: python-cdk-aurora-globaldatabase-help
arch: noarch
version: 2.3.685
epoch: 0
release: 1
summary: Development documents and examples for cdk-aurora-globaldatabase
url: https://github.com/neilkuan/cdk-aurora-globaldatabase.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-aurora-globaldatabase-2.3.685-1.src.rpm
location_href: Packages/python-cdk-aurora-globaldatabase-help-2.3.685-1.noarch.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-aurora-globaldatabase.svg)](https://badge.fury.io/js/cdk-aurora-globaldatabase)
  [![PyPI version](https://badge.fury.io/py/cdk-aurora-globaldatabase.svg)](https://badge.fury.io/py/cdk-aurora-globaldatabase)
  ![Release](https://github.com/neilkuan/cdk-aurora-globaldatabase/workflows/release/badge.svg)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-aurora-globaldatabase?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-aurora-globaldatabase?label=pypi&color=blue)



  `cdk-aurora-globaldatabase` is an AWS CDK construct library that allows you to create [Amazon Aurora Global Databases](https://aws.amazon.com/rds/aurora/global-database/) with AWS CDK in Typescript or Python.



  **Amazon Aurora Global Databases** is designed for multi-regional Amazon Aurora Database clusters that span across different AWS regions. Due to the lack of native cloudformation support, it has been very challenging to build with cloudformation or AWS CDK with the upstream `aws-rds` construct.

  `cdk-aurora-globaldatabase` aims to offload the heavy-lifting and helps you provision and deploy cross-regional **Amazon Aurora Global Databases** simply with just a few CDK statements.



  ```bash
  Use the npm dist tag to opt in CDKv1 or CDKv2:

  // for CDKv2
  npm install cdk-aurora-globaldatabase
  or
  npm install cdk-aurora-globaldatabase@latest

  // for CDKv1
  npm install cdk-aurora-globaldatabase@cdkv1
  ```







  ```python
  import { GlobalAuroraRDSMaster, InstanceTypeEnum, GlobalAuroraRDSSlaveInfra } from 'cdk-aurora-globaldatabase';
  import { App, Stack, CfnOutput } from 'aws-cdk-lib';
  import * as ec2 from 'aws-cdk-lib/aws-ec2';
  // new app .
  const mockApp = new App();

  // setting two region env config .
  const envSingapro  = { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'ap-southeast-1' };
  const envTokyo = { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'ap-northeast-1' };

  // create stack main .
  const stackM = new Stack(mockApp, 'testing-stackM',{env: envTokyo});
  const vpcPublic = new ec2.Vpc(stackM,'defaultVpc',{
    natGateways: 0,
    maxAzs: 3,
    subnetConfiguration: [{
      cidrMask: 26,
      name: 'masterVPC2',
      subnetType: ec2.SubnetType.PUBLIC,
    }],
  });
  const  globaldbM = new GlobalAuroraRDSMaster(stackM, 'globalAuroraRDSMaster',{
    instanceType: InstanceTypeEnum.R5_LARGE,
    vpc: vpcPublic,
    rdsPassword: '1qaz2wsx',
  });
  globaldbM.rdsCluster.connections.allowDefaultPortFrom(ec2.Peer.ipv4(`${process.env.MYIP}/32`))

  // create stack slave infra or you can give your subnet group.
  const stackS = new Stack(mockApp, 'testing-stackS',{env: envSingapro});
  const vpcPublic2 = new ec2.Vpc(stackS,'defaultVpc2',{
    natGateways: 0,
    maxAzs: 3,
    subnetConfiguration: [{
      cidrMask: 26,
      name: 'secondVPC2',
      subnetType: ec2.SubnetType.PUBLIC,
    }],
  });
  const globaldbS = new GlobalAuroraRDSSlaveInfra(stackS, 'slaveregion',{vpc: vpcPublic2,subnetType:ec2.SubnetType.PUBLIC });

  // so we need to wait stack slave created first .
  stackM.addDependency(stackS)


  new CfnOutput(stackM, 'password', { value: globaldbM.rdsPassword });
  // add second region cluster
  globaldbM.addRegionalCluster(stackM,'addregionalrds',{
    region: 'ap-southeast-1',
    dbSubnetGroupName: globaldbS.dbSubnetGroup.dbSubnetGroupName,
  });
  ```

  ![like this ](./image/Mysql-cluster.jpg)



  ```python
  import { GlobalAuroraRDSMaster, InstanceTypeEnum, GlobalAuroraRDSSlaveInfra } from 'cdk-aurora-globaldatabase';
  import { App, Stack, CfnOutput } from 'aws-cdk-lib';
  import * as ec2 from 'aws-cdk-lib/aws-ec2';
  import * as _rds from 'aws-cdk-lib/aws-rds';

  const mockApp = new App();
  const envSingapro  = { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'ap-southeast-1' };
  const envTokyo = { account: process.env.CDK_DEFAULT_ACCOUNT, region: 'ap-northeast-1' };

  const stackM = new Stack(mockApp, 'testing-stackM',{env: envTokyo});
  const vpcPublic = new ec2.Vpc(stackM,'defaultVpc',{
    natGateways: 0,
    maxAzs: 3,
    subnetConfiguration: [{
      cidrMask: 26,
      name: 'masterVPC2',
      subnetType: ec2.SubnetType.PUBLIC,
    }],
  });

  // Note if you use postgres , need to give the same value in engineVersion and  dbClusterpPG's engine .
  const globaldbM = new GlobalAuroraRDSMaster(stackM, 'globalAuroraRDSMaster',{
    instanceType: InstanceTypeEnum.R5_LARGE,
    vpc: vpcPublic,
    rdsPassword: '1qaz2wsx',
    engineVersion: _rds.DatabaseClusterEngine.auroraPostgres({
      version: _rds.AuroraPostgresEngineVersion.VER_12_11}),
    dbClusterpPG: new _rds.ParameterGroup(stackM, 'dbClusterparametergroup', {
      engine: _rds.DatabaseClusterEngine.auroraPostgres({
        version: _rds.AuroraPostgresEngineVersion.VER_12_11,
      }),
      parameters: {
        'rds.force_ssl': '1',
        'rds.log_retention_period': '10080',
        'auto_explain.log_min_duration': '5000',
        'auto_explain.log_verbose': '1',
        'timezone': 'UTC+8',
        'shared_preload_libraries': 'auto_explain,pg_stat_statements,pg_hint_plan,pgaudit',
        'log_connections': '1',
        'log_statement': 'ddl',
        'log_disconnections': '1',
        'log_lock_waits': '1',
        'log_min_duration_statement': '5000',
        'log_rotation_age': '1440',
        'log_rotation_size': '102400',
        'random_page_cost': '1',
        'track_activity_query_size': '16384',
        'idle_in_transaction_session_timeout': '7200000',
      },
    }),
  });
  globaldbM.rdsCluster.connections.allowDefaultPortFrom(ec2.Peer.ipv4(`${process.env.MYIP}/32`))

  const stackS = new Stack(mockApp, 'testing-stackS',{env: envSingapro});
  const vpcPublic2 = new ec2.Vpc(stackS,'defaultVpc2',{
    natGateways: 0,
    maxAzs: 3,
    subnetConfiguration: [{
      cidrMask: 26,
      name: 'secondVPC2',
      subnetType: ec2.SubnetType.PUBLIC,
    }],
  });
  const globaldbS = new GlobalAuroraRDSSlaveInfra(stackS, 'slaveregion',{
    vpc: vpcPublic2,subnetType:ec2.SubnetType.PUBLIC,
  });

  stackM.addDependency(stackS)


  new CfnOutput(stackM, 'password', { value: globaldbM.rdsPassword });
  // add second region cluster
  globaldbM.addRegionalCluster(stackM,'addregionalrds',{
    region: 'ap-southeast-1',
    dbSubnetGroupName: globaldbS.dbSubnetGroup.dbSubnetGroupName,
  });
  ```



  ```bash
  cdk deploy
  ```



  ```bash
  cdk destroy
  ```



  [![Stargazers repo roster for @neilkuan/cdk-aurora-globaldatabase](https://reporoster.com/stars/neilkuan/cdk-aurora-globaldatabase)](https://github.com/neilkuan/cdk-aurora-globaldatabase/stargazers)
  [![Forkers repo roster for @neilkuan/cdk-aurora-globaldatabase](https://reporoster.com/forks/neilkuan/cdk-aurora-globaldatabase)](https://github.com/neilkuan/cdk-aurora-globaldatabase/network/members)


pkgId: ccb48bd31011d9caa73a6a3f0ab6f4d8535cc4333e78f6cf799867d3908ad47d
name: python-cdk-budibase-help
arch: noarch
version: 0.0.541
epoch: 0
release: 1
summary: Development documents and examples for cdk-budibase
url: https://github.com/neilkuan/cdk-budibase.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-budibase-0.0.541-1.src.rpm
location_href: Packages/python-cdk-budibase-help-0.0.541-1.noarch.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-budibase.svg)](https://badge.fury.io/js/cdk-budibase)
  [![PyPI version](https://badge.fury.io/py/cdk-budibase.svg)](https://badge.fury.io/py/cdk-budibase)
  [![release](https://github.com/neilkuan/cdk-budibase/actions/workflows/release.yml/badge.svg)](https://github.com/neilkuan/cdk-budibase/actions/workflows/release.yml)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-budibase?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-budibase?label=pypi&color=blue)



  > [`BudiBase`](https://github.com/Budibase/budibase)  is open source! is Build apps, forms, and workflows that perfectly fit your business - so you can move forward, faster. Best of all.
  > Use AWS CDK to create budibase server.
  > data store in efs

  * base resource:

    * vpc, ecs cluster, ecs service, efs

  > ref: https://medium.com/devops-techable/learn-how-to-use-the-efs-mount-point-in-your-ecs-cluster-running-fargate-with-aws-cdk-e5c9df435c8b



  ![](./docs/arch.png)



  ![](/docs/cdk-deploy.png)

  ```bash

  npx aws-cdk@latest diff --app='npx ts-node src/integ.api.ts'


  npx aws-cdk@latest deploy --app='npx ts-node src/integ.api.ts'


  npx aws-cdk@latest destroy --app='npx ts-node src/integ.api.ts'
  ```



  ```python
  import { BudiBaseBaseResource } from 'cdk-budibase';

  const app = new App();
  const env = {
    account: process.env.CDK_DEFAULT_ACCOUNT,
    region: process.env.CDK_DEFAULT_REGION,
  };

  const stack = new Stack(app, 'MyStack', { env });
  new BudiBaseBaseResource(stack, 'BudiBaseBaseResource');
  ```



  ![](/docs/efs.png)



  ![](/docs/admin-sign-up.png)
  ![](/docs/budibase-console.png)


pkgId: 56a4fb6e4dce3779876697f07851e6b2b9cf1886471f50449348f021eb89a68c
name: python-cdk-certbot-dns-route53-help
arch: noarch
version: 2.4.333
epoch: 0
release: 1
summary: Development documents and examples for cdk-certbot-dns-route53
url: https://github.com/neilkuan/cdk-certbot-dns-route53.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-certbot-dns-route53-2.4.333-1.src.rpm
location_href: Packages/python-cdk-certbot-dns-route53-help-2.4.333-1.noarch.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-certbot-dns-route53.svg)](https://badge.fury.io/js/cdk-certbot-dns-route53)
  [![PyPI version](https://badge.fury.io/py/cdk-certbot-dns-route53.svg)](https://badge.fury.io/py/cdk-certbot-dns-route53)
  [![Release](https://github.com/neilkuan/cdk-certbot-dns-route53/actions/workflows/release.yml/badge.svg?branch=main)](https://github.com/neilkuan/cdk-certbot-dns-route53/actions/workflows/release.yml)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-certbot-dns-route53?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-certbot-dns-route53?label=pypi&color=blue)



  **cdk-certbot-dns-route53** is a CDK construct library that allows you to create [Certbot](https://github.com/certbot/certbot) Lambda Function on AWS with CDK, and setting schedule cron job to renew certificate to store on S3 Bucket.



  ```bash
  Use the npm dist tag to opt in CDKv1 or CDKv2:

  // for CDKv2
  npm install cdk-certbot-dns-route53
  or
  npm install cdk-certbot-dns-route53@latest

  // for CDKv1
  npm install cdk-certbot-dns-route53@cdkv1
  ```

  💡💡💡 please click [here](https://github.com/neilkuan/cdk-certbot-dns-route53/tree/cdkv1#readme), if you are using aws-cdk v1.x.x version.💡💡💡

  ```python
  import * as r53 from 'aws-cdk-lib/aws-route53';
  import * as s3 from 'aws-cdk-lib/aws-s3';
  import * as cdk from 'aws-cdk-lib';
  import { CertbotDnsRoute53Job } from 'cdk-certbot-dns-route53';

  const devEnv = {
    account: process.env.CDK_DEFAULT_ACCOUNT,
    region: process.env.CDK_DEFAULT_REGION,
  };

  const app = new cdk.App();

  const stack = new cdk.Stack(app, 'lambda-certbot-dev', { env: devEnv });

  new CertbotDnsRoute53Job(stack, 'Demo', {
    certbotOptions: {
      domainName: '*.example.com',
      email: 'user@example.com',
    },
    zone: r53.HostedZone.fromHostedZoneAttributes(stack, 'myZone', {
      zoneName: 'example.com',
      hostedZoneId:  'mockId',
    }),
    destinationBucket: s3.Bucket.fromBucketName(stack, 'myBucket', 'mybucket'),
  });
  ```



  ```python
  import * as r53 from 'aws-cdk-lib/aws-route53';
  import * as s3 from 'aws-cdk-lib/aws-s3';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  import * as cdk from 'aws-cdk-lib';
  import { CertbotDnsRoute53Job } from 'cdk-certbot-dns-route53';

  const mockApp = new cdk.App();
  const stack = new cdk.Stack(mockApp, 'teststack', { env: devEnv });
  const bucket = new s3.Bucket(stack, 'testingBucket');
  const zone = r53.HostedZone.fromHostedZoneAttributes(stack, 'zone', {
    zoneName: mock.zoneName, hostedZoneId: mock.zoneId,
  });
  new CertbotDnsRoute53Job(stack, 'Testtask', {
    certbotOptions: {
      domainName: 'example.com',
      email: 'user@example.com',
      customPrefixDirectory: '/',
    },
    zone,
    destinationBucket: bucket,
    schedule: events.Schedule.cron({ month: '2' }),
    architecture: lambda.Architecture.ARM_64, // <- like this way.
  });
  ```



  ![](./images/lambda-logs.png)



  ![](./images/s3-bucket.png)



  > Support enabled Lambda Function Url.

  ```python
  import * as r53 from 'aws-cdk-lib/aws-route53';
  import * as s3 from 'aws-cdk-lib/aws-s3';
  import * as lambda from 'aws-cdk-lib/aws-lambda';
  import * as cdk from 'aws-cdk-lib';
  import { CertbotDnsRoute53JobPython } from 'cdk-certbot-dns-route53';

  const mockApp = new cdk.App();
  const stack = new cdk.Stack(mockApp, 'teststack', { env: devEnv });
  const bucket = new s3.Bucket(stack, 'testingBucket');
  const zone = r53.HostedZone.fromHostedZoneAttributes(stack, 'zone', {
    zoneName: mock.zoneName, hostedZoneId: mock.zoneId,
  });
  new CertbotDnsRoute53JobPython(stack, 'Testtask', {
    certbotOptions: {
      domainName: 'example.com',
      email: 'user@example.com',
      customPrefixDirectory: '/',
    },
    zone,
    destinationBucket: bucket,
    schedule: events.Schedule.cron({ month: '2' }),
    enabledLambdaFunctionUrl: true,
  });
  ```


pkgId: 42a6330ef9934df30f8b91dd53f68a68cdaf34ff8da9bc6e46bdd067b5dce089
name: python-cdk-common-help
arch: noarch
version: 2.0.1043
epoch: 0
release: 1
summary: Development documents and examples for cdk-common
url: https://github.com/neilkuan/cdk-common.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-common-2.0.1043-1.src.rpm
location_href: Packages/python-cdk-common-help-2.0.1043-1.noarch.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-common.svg)](https://badge.fury.io/js/cdk-common)
  [![PyPI version](https://badge.fury.io/py/cdk-common.svg)](https://badge.fury.io/py/cdk-common)
  [![release](https://github.com/neilkuan/cdk-common/actions/workflows/release.yml/badge.svg)](https://github.com/neilkuan/cdk-common/actions/workflows/release.yml)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-common?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-common?label=pypi&color=blue)



  This Constructs Library will collection of useful `function` and `class` for AWS CDK.



  ```bash
  Use the npm dist tag to opt in CDKv1 or CDKv2:

  // for CDKv2
  npm install cdk-common
  or
  npm install cdk-common@latest

  // for CDKv1
  npm install cdk-common@cdkv1
  ```

  💡💡💡 please click [here](https://github.com/neilkuan/cdk-common/tree/cdkv1#readme), if you are using aws-cdk v1.x.x version.💡💡💡



  ```python
  import * as cdk from 'aws-cdk-lib';
  import { AWSManagedPolicies } from 'cdk-common';
  import { Construct } from 'constructs';
  const app = new cdk.App();

  const stack = new cdk.Stack(app, 'integ-default', { env });

  export class IntegDefault extends Construct {
    constructor(scope: Construct, id: string ) {
      super(scope, id);

      const role = new iam.Role(this, 'iamrole', {
        assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
      });
      // Use this way.
      role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName(AWSManagedPolicies.AMAZON_SSM_MANAGED_INSTANCE_CORE));

      // Not this way.
      role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'));
    }
  }
  ```


pkgId: db915c9e1bc652f4824b824ede92e6bfefc78fbe0cc089679caca3a87b864cb4
name: python-cdk-cr-constructs-help
arch: noarch
version: 2.1.655
epoch: 0
release: 1
summary: Development documents and examples for cdk-cr-constructs
url: https://github.com/neilkuan/cdk-cr-constructs.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-cr-constructs-2.1.655-1.src.rpm
location_href: Packages/python-cdk-cr-constructs-help-2.1.655-1.noarch.rpm
checksum_type: sha256
description:
  This Construct is collect custom resource



  ```python
  import { App, Stack, CfnOutput, Duration, aws_iam } from 'aws-cdk-lib';
  import { CustomResourceGetEIP } from 'cdk-cr-constructs';
  const env = {
    region: process.env.CDK_DEFAULT_REGION,
    account: process.env.CDK_DEFAULT_ACCOUNT,
  };
  const app = new App();
  const stack = new Stack(app, 'testing-stack', { env });
  const getIps = new CustomResourceGetEIP(stack, 'CustomResourceGetEIP', {
    /**
     * Discovery us-east-1 Elastic Ips.
     */
    regions: ['us-east-1'],
    /**
     * Add Company Ips.
     */
    companyIps: ['1.2.3.4'],
  });
  const role = new aws_iam.Role(stack, 'DemoRole', {
    assumedBy: new aws_iam.AccountRootPrincipal(),
  });
  /**
   * Example create an assume role, allow all action from ip address.
  */
  role.addToPolicy(new aws_iam.PolicyStatement({
    effect: aws_iam.Effect.ALLOW,
    resources: ['*'],
    actions: ['*'],
    conditions: {
      IpAddress: {
        'aws:SourceIp': getIps.ipList(),
      },
    },
  }));
  ```


pkgId: 893e8112bf46c9468342036bf04193795b66667a2085e70f1fcbfb086cc6f7d9
name: python-cdk-databrew-cicd-help
arch: noarch
version: 2.0.448
epoch: 0
release: 1
summary: Development documents and examples for cdk-databrew-cicd
url: https://github.com/HsiehShuJeng/cdk-databrew-cicd.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-databrew-cicd-2.0.448-1.src.rpm
location_href: Packages/python-cdk-databrew-cicd-help-2.0.448-1.noarch.rpm
checksum_type: sha256
description:
  This construct creates a **CodePipeline** pipeline where users can push a **DataBrew** recipe into the **CodeCommit** repository and the recipe will be pushed to a pre-production AWS account and a production AWS account by order automatically.

  | npm (JS/TS) | PyPI (Python) | Maven (Java) | Go | NuGet |
  | --- | --- | --- | --- | --- |
  | [Link](https://www.npmjs.com/package/cdk-databrew-cicd) | [Link](https://pypi.org/project/cdk_databrew_cicd/) | [Link](https://search.maven.org/artifact/io.github.hsiehshujeng/cdk-databrew-cicd) | [Link](https://github.com/HsiehShuJeng/cdk-databrew-cicd-go) | [Link](https://www.nuget.org/packages/Databrew.Cicd/) |

  [![License](https://img.shields.io/badge/License-Apache%202.0-green)](https://opensource.org/licenses/Apache-2.0) [![Release](https://github.com/HsiehShuJeng/cdk-databrew-cicd/workflows/Release/badge.svg)](https://github.com/HsiehShuJeng/cdk-databrew-cicd/actions/workflows/release.yml) [![npm downloads](https://img.shields.io/npm/dt/cdk-databrew-cicd?label=npm%20downloads&style=plastic)](https://img.shields.io/npm/dt/cdk-databrew-cicd?label=npm%20downloads&style=plastic) [![pypi downloads](https://img.shields.io/pypi/dm/cdk-databrew-cicd?label=pypi%20downloads&style=plastic)](https://img.shields.io/pypi/dm/cdk-databrew-cicd?label=pypi%20downloads&style=plastic) [![NuGet downloads](https://img.shields.io/nuget/dt/Databrew.Cicd?label=NuGet%20downloads&style=plastic)](https://img.shields.io/nuget/dt/Databrew.Cicd?label=NuGet%20downloads&style=plastic) [![repo languages](https://img.shields.io/github/languages/count/HsiehShuJeng/cdk-databrew-cicd?label=repo%20languages&style=plastic)](https://img.shields.io/github/languages/count/HsiehShuJeng/cdk-databrew-cicd?label=repo%20languages&style=plastic)



  * [Serverless Architecture](#serverless-architecture)
  * [Introduction](#introduction)
  * [Example](#example)

    * [Typescript](#typescript)
    * [Python](#python)
    * [Java](#java)
    * [C#](#c)
    * [Go](#go)
  * [Some Efforts after Stack Creation](#some-efforts-after-stack-creation)
  * [How Successful Commits Look Like](#how-successful-commits-look-like)



  ![image](https://d2908q01vomqb2.cloudfront.net/b6692ea5df920cad691c20319a6fffd7a4a766b8/2021/05/19/image001.jpg) *Romi B. and Gaurav W., 2021*



  The architecture was introduced by **Romi Boimer** and **Gaurav Wadhawan** and was posted on the AWS Blog as [*Set up CI/CD pipelines for AWS Glue DataBrew using AWS Developer Tools*](https://aws.amazon.com/tw/blogs/big-data/set-up-ci-cd-pipelines-for-aws-glue-databrew-using-aws-developer-tools/).
  I converted the architecture into a CDK construct for 5 programming languages. Before applying the AWS construct, make sure you've set up a proper IAM role for the pre-production and production AWS accounts. You could achieve it either by creating manually or creating through a custom construct in this library.

  ```python
  import { IamRole } from 'cdk-databrew-cicd';

  new IamRole(this, 'AccountIamRole', {
      environment: 'preproduction', // or 'production'
      accountID: 'ACCOUNT_ID',
      // roleName: 'OPTIONAL'
  });
  ```





  You could also refer to [here](https://github.com/HsiehShuJeng/cdk-databrew-cicd/tree/main/src/demo/typescript).

  ```bash
  $ cdk --init language typescript
  $ yarn add cdk-databrew-cicd
  ```

  ```python
  import * as cdk from '@aws-cdk/core';
  import { DataBrewCodePipeline } from 'cdk-databrew-cicd';

  class TypescriptStack extends cdk.Stack {
    constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
      super(scope, id, props);

      const preproductionAccountId = 'PREPRODUCTION_ACCOUNT_ID';
      const productionAccountId = 'PRODUCTION_ACCOUNT_ID';

      const dataBrewPipeline = new DataBrewCodePipeline(this, 'DataBrewCicdPipeline', {
        preproductionIamRoleArn: `arn:${cdk.Aws.PARTITION}:iam::${preproductionAccountId}:role/preproduction-Databrew-Cicd-Role`,
        productionIamRoleArn: `arn:${cdk.Aws.PARTITION}:iam::${productionAccountId}:role/production-Databrew-Cicd-Role`,
        // bucketName: 'OPTIONAL',
        // repoName: 'OPTIONAL',
        // branchName: 'OPTIONAL',
        // pipelineName: 'OPTIONAL'
      });

      new cdk.CfnOutput(this, 'OPreproductionLambdaArn', { value: dataBrewPipeline.preproductionFunctionArn });
      new cdk.CfnOutput(this, 'OProductionLambdaArn', { value: dataBrewPipeline.productionFunctionArn });
      new cdk.CfnOutput(this, 'OCodeCommitRepoArn', { value: dataBrewPipeline.codeCommitRepoArn });
      new cdk.CfnOutput(this, 'OCodePipelineArn', { value: dataBrewPipeline.codePipelineArn });
    }
  }

  const app = new cdk.App();
  new TypescriptStack(app, 'TypescriptStack', {
    stackName: 'DataBrew-CICD'
  });
  ```



  You could also refer to [here](https://github.com/HsiehShuJeng/cdk-databrew-cicd/tree/main/src/demo/python).

  ```bash

  $ python -m ensurepip --upgrade
  $ python -m pip install --upgrade pip
  $ python -m pip install --upgrade virtualenv

  $ cdk init --language python

  $ source .venv/bin/activate
  $ cat <<EOL > requirements.txt
  aws-cdk.core
  cdk-databrew-cicd
  EOL
  $ python -m pip install -r requirements.txt
  ```

  ```python
  from aws_cdk import core as cdk
  from cdk_databrew_cicd import DataBrewCodePipeline

  class PythonStack(cdk.Stack):

      def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None:
          super().__init__(scope, construct_id, **kwargs)

          preproduction_account_id = "PREPRODUCTION_ACCOUNT_ID"
          production_account_id = "PRODUCTION_ACCOUNT_ID"

          databrew_pipeline = DataBrewCodePipeline(self,
          "DataBrewCicdPipeline",
          preproduction_iam_role_arn=f"arn:{cdk.Aws.PARTITION}:iam::{preproduction_account_id}:role/preproduction-Databrew-Cicd-Role",
          production_iam_role_arn=f"arn:{cdk.Aws.PARTITION}:iam::{production_account_id}:role/preproduction-Databrew-Cicd-Role",
              
              
              
              
              
              )

          cdk.CfnOutput(self, 'OPreproductionLambdaArn', value=databrew_pipeline.preproduction_function_arn)
          cdk.CfnOutput(self, 'OProductionLambdaArn', value=databrew_pipeline.production_function_arn)
          cdk.CfnOutput(self, 'OCodeCommitRepoArn', value=databrew_pipeline.code_commit_repo_arn)
          cdk.CfnOutput(self, 'OCodePipelineArn', value=databrew_pipeline.code_pipeline_arn)
  ```

  ```bash
  $ deactivate
  ```



  You could also refer to [here](https://github.com/HsiehShuJeng/cdk-databrew-cicd/tree/main/src/demo/java).

  ```bash
  $ cdk init --language java
  $ mvn package
  ```

  ```xml
  .
  .
  <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <cdk.version>2.87.0</cdk.version>
        <constrcut.verion>2.0.196</constrcut.verion>
        <junit.version>5.7.1</junit.version>
  </properties>
   .
   .
   <dependencies>
       <!-- AWS Cloud Development Kit -->
        <dependency>
              <groupId>software.amazon.awscdk</groupId>
              <artifactId>aws-cdk-lib</artifactId>
              <version>${cdk.version}</version>
        </dependency>
        <dependency>
          <groupId>io.github.hsiehshujeng</groupId>
          <artifactId>cdk-databrew-cicd</artifactId>
          <version>${constrcut.verion}</version>
          </dependency>
       .
       .
       .
   </dependencies>
  ```

  ```java
  package com.myorg;

  import software.amazon.awscdk.core.CfnOutput;
  import software.amazon.awscdk.core.CfnOutputProps;
  import software.amazon.awscdk.core.Construct;
  import software.amazon.awscdk.core.Stack;
  import software.amazon.awscdk.core.StackProps;
  import io.github.hsiehshujeng.cdk.databrew.cicd.DataBrewCodePipeline;
  import io.github.hsiehshujeng.cdk.databrew.cicd.DataBrewCodePipelineProps;

  public class JavaStack extends Stack {
      public JavaStack(final Construct scope, final String id) {
          this(scope, id, null);
      }

      public JavaStack(final Construct scope, final String id, final StackProps props) {
          super(scope, id, props);
          String preproductionAccountId = "PREPRODUCTION_ACCOUNT_ID";
          String productionAccountId = "PRODUCTION_ACCOUNT_ID";
          DataBrewCodePipeline databrewPipeline = new DataBrewCodePipeline(this, "DataBrewCicdPipeline",
                  DataBrewCodePipelineProps.builder().preproductionIamRoleArn(preproductionAccountId)
                          .productionIamRoleArn(productionAccountId)
                          // .bucketName("OPTIONAL")
                          // .branchName("OPTIONAL")
                          // .pipelineName("OPTIONAL")
                          .build());

          new CfnOutput(this, "OPreproductionLambdaArn",
                  CfnOutputProps.builder()
                      .value(databrewPipeline.getPreproductionFunctionArn())
                      .build());
          new CfnOutput(this, "OProductionLambdaArn",
                  CfnOutputProps.builder()
                      .value(databrewPipeline.getProductionFunctionArn())
                      .build());
          new CfnOutput(this, "OCodeCommitRepoArn",
                  CfnOutputProps.builder()
                      .value(databrewPipeline.getCodeCommitRepoArn())
                      .build());
          new CfnOutput(this, "OCodePipelineArn",
                  CfnOutputProps.builder()
                      .value(databrewPipeline.getCodePipelineArn())
                      .build());
      }
  }
  ```



  You could also refer to [here](https://github.com/HsiehShuJeng/cdk-databrew-cicd/tree/main/src/demo/csharp).

  ```bash
  $ cdk init --language csharp
  $ dotnet add src/Csharp package Databrew.Cicd --version 2.0.196
  ```

  ```cs
  using Amazon.CDK;
  using ScottHsieh.Cdk;

  namespace Csharp
  {
      public class CsharpStack : Stack
      {
          internal CsharpStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
          {
              var preproductionAccountId = "PREPRODUCTION_ACCOUNT_ID";
              var productionAccountId = "PRODUCTION_ACCOUNT_ID";

              var dataBrewPipeline = new DataBrewCodePipeline(this, "DataBrewCicdPipeline", new DataBrewCodePipelineProps
              {
                  PreproductionIamRoleArn = $"arn:{Aws.PARTITION}:iam::{preproductionAccountId}:role/preproduction-Databrew-Cicd-Role",
                  ProductionIamRoleArn = $"arn:{Aws.PARTITION}:iam::{productionAccountId}:role/preproduction-Databrew-Cicd-Role",
                  // BucketName = "OPTIONAL",
                  // RepoName = "OPTIONAL",
                  // BranchName = "OPTIONAL",
                  // PipelineName = "OPTIONAL"
              });
              new CfnOutput(this, "OPreproductionLambdaArn", new CfnOutputProps
              {
                  Value = dataBrewPipeline.PreproductionFunctionArn
              });
              new CfnOutput(this, "OProductionLambdaArn", new CfnOutputProps
              {
                  Value = dataBrewPipeline.ProductionFunctionArn
              });
              new CfnOutput(this, "OCodeCommitRepoArn", new CfnOutputProps
              {
                  Value = dataBrewPipeline.CodeCommitRepoArn
              });
              new CfnOutput(this, "OCodePipelineArn", new CfnOutputProps
              {
                  Value = dataBrewPipeline.CodeCommitRepoArn
              });
          }
      }
  }
  ```



  You could also refer to [here](src/demo/go_lang/).

  ```bash

  cdk init app -l go

  go get github.com/HsiehShuJeng/cdk-databrew-cicd-go/cdkdatabrewcicd/v2@v2.0.196

  go mod tidy

  go get -u ./...
  ```

  ```go
  package main

  import (
  	"fmt"

  	"github.com/aws/aws-cdk-go/awscdk/v2"

  	// "github.com/aws/aws-cdk-go/awscdk/v2/awssqs"
  	"github.com/HsiehShuJeng/cdk-databrew-cicd-go/cdkdatabrewcicd/v2"
  	"github.com/aws/constructs-go/constructs/v10"
  	"github.com/aws/jsii-runtime-go"
  )

  type GoLangStackProps struct {
  	awscdk.StackProps
  }

  func NewGoLangStack(scope constructs.Construct, id string, props *GoLangStackProps) awscdk.Stack {
  	var sprops awscdk.StackProps
  	if props != nil {
  		sprops = props.StackProps
  	}
  	stack := awscdk.NewStack(scope, &id, &sprops)

  	preproductionAccountId := "PREPRODUCTION_ACCOUNT_ID"
  	productionAccountId := "PRODUCTION_ACCOUNT_ID"

  	dataBrewPipeline := cdkdatabrewcicd.NewDataBrewCodePipeline(stack, jsii.String("DataBrewCicdPipeline"), &cdkdatabrewcicd.DataBrewCodePipelineProps{
  		PreproductionIamRoleArn: jsii.String(fmt.Sprintf("arn:%s:iam::%s:role/preproduction-Databrew-Cicd-Role", *awscdk.Aws_PARTITION(), preproductionAccountId)),
  		ProductionIamRoleArn:    jsii.String(fmt.Sprintf("arn:%s:iam::%s:role/production-Databrew-Cicd-Role", *awscdk.Aws_PARTITION(), productionAccountId)),
  		// BucketName:   jsii.String("OPTIONAL"),
  		// RepoName:     jsii.String("OPTIONAL"),
  		// BranchName:   jsii.String("OPTIONAL"),
  		// PipelineName: jsii.String("OPTIONAL"),
  	})

  	awscdk.NewCfnOutput(stack, jsii.String("OPreproductionLambdaArn"), &awscdk.CfnOutputProps{Value: dataBrewPipeline.PreproductionFunctionArn()})
  	awscdk.NewCfnOutput(stack, jsii.String("OProductionLambdaArn"), &awscdk.CfnOutputProps{Value: dataBrewPipeline.ProductionFunctionArn()})
  	awscdk.NewCfnOutput(stack, jsii.String("OCodeCommitRepoArn"), &awscdk.CfnOutputProps{Value: dataBrewPipeline.CodeCommitRepoArn()})
  	awscdk.NewCfnOutput(stack, jsii.String("OCodePipelineArn"), &awscdk.CfnOutputProps{Value: dataBrewPipeline.CodePipelineArn()})

  	return stack
  }

  func main() {
  	defer jsii.Close()

  	app := awscdk.NewApp(nil)

  	NewGoLangStack(app, "GoLangStack", &GoLangStackProps{
  		awscdk.StackProps{
  			Env: env(),
  		},
  	})

  	app.Synth(nil)
  }

  func env() *awscdk.Environment {
  	return nil
  }

  ```





  1. Create HTTPS Git credentials for AWS CodeCommit with an IAM user that you're going to use.
     ![image](https://raw.githubusercontent.com/HsiehShuJeng/cdk-databrew-cicd/main/images/codecommit_credentials.png)
  2. Run through the steps noted on the README.md of the CodeCommit repository after finishing establishing the stack via CDK. The returned message with success should be looked like the following (assume you have installed [`git-remote-codecommit`](https://pypi.org/project/git-remote-codecommit/)):

     ```bash
     $ git clone codecommit://scott.codecommit@DataBrew-Recipes-Repo
     Cloning into 'DataBrew-Recipes-Repo'...
     remote: Counting objects: 6, done.
     Unpacking objects: 100% (6/6), 2.03 KiB | 138.00 KiB/s, done.
     ```
  3. Add a DataBrew recipe into the local repositroy (directory) and commit the change. (either directly on the main branch or merging another branch into the main branch)



  1. Download any recipe either generated out by following [*Getting started with AWS Glue DataBrew*](https://docs.aws.amazon.com/zh_tw/databrew/latest/dg/getting-started.html) or made by yourself as **JSON file**.
     ![image](https://raw.githubusercontent.com/HsiehShuJeng/cdk-databrew-cicd/main/images/databrew_recipes.png)
  2. Move the recipe from the download directory to the local directory for the CodeCommit repository.

     ```bash
     $ mv ${DOWNLOAD_DIRECTORY}/chess-project-recipe.json ${CODECOMMIT_LOCAL_DIRECTORY}/
     ```
  3. Commit the change to a branch with a name you prefer.

     ```bash
     $ cd ${{CODECOMMIT_LOCAL_DIRECTORY}}
     $ git checkout -b add-recipe main
     $ git add .
     $ git commit -m "first recipe"
     $ git push --set-upstream origin add-recipe
     ```
  4. Merge the branch into the main branch. Just go to the **AWS CodeCommit** web console to do the merge as its process is purely the same as you've already done thousands of times on **Github** but only with different UIs.



  1. In the infrastructure account, the status of the CodePipeline DataBrew pipeline should be similar as the following:
     ![image](https://raw.githubusercontent.com/HsiehShuJeng/cdk-databrew-cicd/main/images/infra_codepipeline.png)
  2. In the **pre-production** account with the same region as where the CICD pipeline is deployed at the infrastructue account, you'll see this.
     ![image](https://raw.githubusercontent.com/HsiehShuJeng/cdk-databrew-cicd/main/images/preproduction-recipe.png)
  3. In the **production** account with the same region as where the CICD pipeline is deployed at the infrastructue account, you'll see this.
     ![image](https://raw.githubusercontent.com/HsiehShuJeng/cdk-databrew-cicd/main/images/production-recipe.png)


pkgId: 4195e40b8bafc31e8b12aa318fdce359bda39ec99ff3f1e1f13146821c449150
name: python-cdk-docker-image-deployment-help
arch: noarch
version: 0.0.687
epoch: 0
release: 1
summary: Development documents and examples for cdk-docker-image-deployment
url: https://github.com/cdklabs/cdk-docker-image-deployment#readme
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-docker-image-deployment-0.0.687-1.src.rpm
location_href: Packages/python-cdk-docker-image-deployment-help-0.0.687-1.noarch.rpm
checksum_type: sha256
description:
  This module allows you to copy docker image assets to a repository you control.
  This can be necessary if you want to build a Docker image in one CDK app and consume it in a different app or outside the CDK,
  or if you want to apply a lifecycle policy to all images of a part of your application.



  Below is a basic example for how to use the `DockerImageDeployment` API:

  ```python
  import * as ecr from 'aws-cdk-lib/aws-ecr';
  import * as imagedeploy from 'cdk-docker-image-deployment';

  const repo = ecr.Repository.fromRepositoryName(this, 'MyRepository', 'myrepository');

  new imagedeploy.DockerImageDeployment(this, 'ExampleImageDeploymentWithTag', {
    source: imagedeploy.Source.directory('path/to/directory'),
    destination: imagedeploy.Destination.ecr(repo, {
      tag: 'myspecialtag',
    }),
  });
  ```



  * `Source.directory()`: Supply a path to a local docker image as source.

  > Don't see a source listed? See if there is an open [issue](https://github.com/cdklabs/cdk-docker-image-deployment/issues)
  > or [PR](https://github.com/cdklabs/cdk-docker-image-deployment/pulls) already. If not, please open an issue asking for it
  > or better yet, submit a contribution!



  * `Destination.ecr(repo, options)`: Send your docker image to an ECR repository in your stack's account.

  > Don't see a destination listed? See if there is an open [issue](https://github.com/cdklabs/cdk-docker-image-deployment/issues)
  > or [PR](https://github.com/cdklabs/cdk-docker-image-deployment/pulls) already. If not, please open an issue asking for it
  > or better yet, submit a contribution!



  1. When this stack is deployed (either via cdk deploy or via CI/CD), the contents of the local Docker image will be archived and uploaded to an intermediary assets ECR Repository using the cdk-assets mechanism.
  2. The `DockerImageDeployment` construct synthesizes a CodeBuild Project which uses docker to pull the image from the intermediary repository, tag the image if a tag is provided, and push the image to the destination repository.
  3. The deployment will wait until the CodeBuild Project completes successfully before finishing.

  The architecture of this construct can be seen here:

  ![Construct-Architecture](https://user-images.githubusercontent.com/36202692/187282269-7ab29d3e-192f-470f-9123-5dbb62d9dac3.jpg)



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: bea649b495cf55f622e2367e11bde2d1231431edf6cd8306392502b533394f1f
name: python-cdk-ecr-deployment-help
arch: noarch
version: 3.0.152
epoch: 0
release: 1
summary: Development documents and examples for cdk-ecr-deployment
url: https://github.com/cdklabs/cdk-ecr-deployment
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-ecr-deployment-3.0.152-1.src.rpm
location_href: Packages/python-cdk-ecr-deployment-help-3.0.152-1.noarch.rpm
checksum_type: sha256
description:
  [![Release](https://github.com/cdklabs/cdk-ecr-deployment/actions/workflows/release.yml/badge.svg)](https://github.com/cdklabs/cdk-ecr-deployment/actions/workflows/release.yml)
  [![npm version](https://img.shields.io/npm/v/cdk-ecr-deployment)](https://www.npmjs.com/package/cdk-ecr-deployment)
  [![PyPI](https://img.shields.io/pypi/v/cdk-ecr-deployment)](https://pypi.org/project/cdk-ecr-deployment)
  [![npm](https://img.shields.io/npm/dw/cdk-ecr-deployment?label=npm%20downloads)](https://www.npmjs.com/package/cdk-ecr-deployment)
  [![PyPI - Downloads](https://img.shields.io/pypi/dw/cdk-ecr-deployment?label=pypi%20downloads)](https://pypi.org/project/cdk-ecr-deployment)

  CDK construct to synchronize single docker image between docker registries.

  **Only use v3 of this package**

  ⚠️ Version 2.* is no longer supported, as the Go.1.x runtime is no longer supported in AWS Lambda.\
  ⚠️ Version 1.* is no longer supported, as CDK v1 has reached the end-of-life
  stage.



  * Copy image from ECR/external registry to (another) ECR/external registry
  * Copy an archive tarball image from s3 to ECR/external registry



  Enable flags: `true`, `1`. e.g. `export CI=1`

  * `CI` indicate if it's CI environment. This flag will enable building lambda from scratch.
  * `NO_PREBUILT_LAMBDA` disable using prebuilt lambda.
  * `FORCE_PREBUILT_LAMBDA` force using prebuilt lambda.

  ⚠️ If you want to force using prebuilt lambda in CI environment to reduce build time. Try `export FORCE_PREBUILT_LAMBDA=1`.



  ```python
  from aws_cdk.aws_ecr_assets import DockerImageAsset


  image = DockerImageAsset(self, "CDKDockerImage",
      directory=path.join(__dirname, "docker")
  )


  ecrdeploy.ECRDeployment(self, "DeployDockerImage1",
      src=ecrdeploy.DockerImageName(image.image_uri),
      dest=ecrdeploy.DockerImageName(f"{cdk.Aws.ACCOUNT_ID}.dkr.ecr.us-west-2.amazonaws.com/my-nginx:latest")
  )


  ecrdeploy.ECRDeployment(self, "DeployDockerImage2",
      src=ecrdeploy.DockerImageName("nginx:latest"),
      dest=ecrdeploy.DockerImageName(f"{cdk.Aws.ACCOUNT_ID}.dkr.ecr.us-west-2.amazonaws.com/my-nginx2:latest")
  )



  ecrdeploy.ECRDeployment(self, "DeployDockerImage3",
      src=ecrdeploy.DockerImageName("javacs3/nginx:latest", "username:password"),
      
      
      dest=ecrdeploy.DockerImageName(f"{cdk.Aws.ACCOUNT_ID}.dkr.ecr.us-west-2.amazonaws.com/my-nginx3:latest")
  ).add_to_principal_policy(iam.PolicyStatement(
      effect=iam.Effect.ALLOW,
      actions=["secretsmanager:GetSecretValue"
      ],
      resources=["*"]
  ))
  ```



  ```shell

  NO_PREBUILT_LAMBDA=1 npx cdk deploy -a "npx ts-node -P tsconfig.dev.json --prefer-ts-exts test/example.ecr-deployment.ts"
  ```





  The core of this project relies on [containers/image](https://github.com/containers/image) which is used by [Skopeo](https://github.com/containers/skopeo).
  Please take a look at those projects before contribution.

  To support a new docker image source(like docker tarball in s3), you need to implement [image transport interface](https://github.com/containers/image/blob/master/types/types.go). You could take a look at [docker-archive](https://github.com/containers/image/blob/ccb87a8d0f45cf28846e307eb0ec2b9d38a458c2/docker/archive/transport.go) transport for a good start.

  To test the `lambda` folder, `make test`.


pkgId: 9021ee117011b5deafbb93d457c3e8bde59ef852c2b4d47373653379abb97f24
name: python-cdk-ecs-service-extensions-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for cdk-ecs-service-extensions
url: https://github.com/cdklabs/cdk-ecs-service-extensions.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-ecs-service-extensions-2.0.0-1.src.rpm
location_href: Packages/python-cdk-ecs-service-extensions-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <!--END STABILITY BANNER-->
  This library provides a high level, extensible pattern for constructing services
  deployed using Amazon ECS.
  ```python
  import {
    AppMeshExtension,
    CloudwatchAgentExtension,
    Container,
    Environment,
    FireLensExtension,
    HttpLoadBalancerExtension,
    Service,
    ServiceDescription,
    XRayExtension,
  } from 'cdk-ecs-service-extensions';
  ```
  The `Service` construct provided by this module can be extended with optional `ServiceExtension` classes that add supplemental ECS features including:
  * [AWS X-Ray](https://aws.amazon.com/xray/) for tracing your application
  * [Amazon CloudWatch Agent](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) for capturing per task stats
  * [AWS AppMesh](https://aws.amazon.com/app-mesh/) for adding your application to a service mesh
  * [Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html), for exposing your service to the public
  * [AWS FireLens](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html), for filtering and routing application logs
  * [Injecter Extension](#injecter-extension), for allowing your service connect to other AWS services by granting permission and injecting environment variables
  * [Queue Extension](#queue-extension), for allowing your service to consume messages from an SQS Queue which can be populated by one or more SNS Topics that it is subscribed to
  * [Community Extensions](#community-extensions), providing support for advanced use cases
  The `ServiceExtension` class is an abstract class which you can also implement in
  order to build your own custom service extensions for modifying your service, or
  attaching your own custom resources or sidecars.

  ```python
  // Create an environment to deploy a service in.
  const environment = new Environment(this, 'production');
  // Build out the service description
  const nameDescription = new ServiceDescription();
  nameDescription.add(new Container({
    cpu: 1024,
    memoryMiB: 2048,
    trafficPort: 80,
    image: ecs.ContainerImage.fromRegistry('nathanpeck/name'),
    environment: {
      PORT: '80',
    },
  }));
  declare const mesh: appmesh.Mesh;
  nameDescription.add(new AppMeshExtension({ mesh }));
  nameDescription.add(new FireLensExtension());
  nameDescription.add(new XRayExtension());
  nameDescription.add(new CloudwatchAgentExtension());
  nameDescription.add(new HttpLoadBalancerExtension());
  // Implement the service description as a real service inside
  // an environment.
  const nameService = new Service(this, 'name', {
    environment: environment,
    serviceDescription: nameDescription,
  });
  ```

  An `Environment` is a place to deploy your services. You can have multiple environments
  on a single AWS account. For example, you could create a `test` environment as well
  as a `production` environment so you have a place to verify that your application
  works as intended before you deploy it to a live environment.
  Each environment is isolated from other environments. In other words,
  when you create an environment, by default the construct supplies its own VPC,
  ECS Cluster, and any other required resources for the environment:
  ```python
  const environment = new Environment(this, 'production');
  ```
  However, you can also choose to build an environment out of a pre-existing VPC
  or ECS Cluster:
  ```python
  declare const vpc: ec2.Vpc;
  const cluster = new ecs.Cluster(this, 'Cluster', { vpc });
  const environment = new Environment(this, 'production', {
    vpc,
    cluster,
  });
  ```

  The `ServiceDescription` defines what application you want the service to run and
  what optional extensions you want to add to the service. The most basic form of a `ServiceDescription` looks like this:
  ```python
  const nameDescription = new ServiceDescription();
  nameDescription.add(new Container({
    cpu: 1024,
    memoryMiB: 2048,
    trafficPort: 80,
    image: ecs.ContainerImage.fromRegistry('nathanpeck/name'),
    environment: {
      PORT: '80',
    },
  }));
  ```
  Every `ServiceDescription` requires at minimum that you add a `Container` extension
  which defines the main application (essential) container to run for the service.

  If no observability extensions have been configured for a service, the ECS Service Extensions configures an `awslogs` log driver for the application container of the service to send the container logs to CloudWatch Logs.
  You can either provide a log group to the `Container` extension or one will be created for you by the CDK.
  Following is an example of an application with an `awslogs` log driver configured for the application container:
  ```python
  import * as logs from 'aws-cdk-lib/aws-logs';
  const environment = new Environment(this, 'production');
  const nameDescription = new ServiceDescription();
  nameDescription.add(new Container({
    cpu: 1024,
    memoryMiB: 2048,
    trafficPort: 80,
    image: ContainerImage.fromRegistry('nathanpeck/name'),
    environment: {
      PORT: '80',
    },
    logGroup: new logs.LogGroup(this, 'MyLogGroup'),
  }));
  ```
  If a log group is not provided, no observability extensions have been created, and the `ECS_SERVICE_EXTENSIONS_ENABLE_DEFAULT_LOG_DRIVER` feature flag is enabled, then logging will be configured by default and a log group will be created for you.
  The `ECS_SERVICE_EXTENSIONS_ENABLE_DEFAULT_LOG_DRIVER` feature flag is enabled by default in any CDK apps that are created with CDK v1.140.0 or v2.8.0 and later.
  To enable default logging for previous versions, ensure that the `ECS_SERVICE_EXTENSIONS_ENABLE_DEFAULT_LOG_DRIVER` flag within the application stack context is set to true, like so:
  ```python
  import * as cxapi from '@aws-cdk/cx-api';
  this.node.setContext(cxapi.ECS_SERVICE_EXTENSIONS_ENABLE_DEFAULT_LOG_DRIVER, true);
  ```
  Alternatively, you can also set the feature flag in the `cdk.json` file. For more information, refer the [docs](https://docs.aws.amazon.com/cdk/v2/guide/featureflags.html).
  After adding the `Container` extension, you can optionally enable additional features for the service using the `ServiceDescription.add()` method:
  ```python
  declare const mesh: appmesh.Mesh;
  const nameDescription = new ServiceDescription();
  nameDescription.add(new AppMeshExtension({ mesh }));
  nameDescription.add(new FireLensExtension());
  nameDescription.add(new XRayExtension());
  nameDescription.add(new CloudwatchAgentExtension());
  nameDescription.add(new HttpLoadBalancerExtension());
  nameDescription.add(new AssignPublicIpExtension());
  ```

  Once the service description is defined, you can launch it as a service:
  ```python
  const environment = new Environment(this, 'production');
  const nameDescription = new ServiceDescription();
  const nameService = new Service(this, 'name', {
    environment: environment,
    serviceDescription: nameDescription,
  });
  ```
  At this point, all the service resources will be created. This includes the ECS Task
  Definition, Service, as well as any other attached resources, such as App Mesh Virtual
  Node or an Application Load Balancer.

  Sometimes the taskRole should be defined outside of the service so that you can create strict resource policies (ie. S3 bucket policies) that are restricted to a given taskRole:
  ```python
  const taskRole = new iam.Role(this, 'CustomTaskRole', {
    assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
  });
  // Use taskRole in any CDK resource policies
  // new s3.BucketPolicy(this, 'BucketPolicy, {});
  const environment = new Environment(this, 'production');
  const nameDescription = new ServiceDescription();
  const nameService = new Service(this, 'name', {
    environment: environment,
    serviceDescription: nameDescription,
    taskRole,
  });
  ```

  You can configure the task count of a service to match demand. The recommended way of achieving this is to configure target tracking policies for your service which scales in and out in order to keep metrics around target values.
  You need to configure an auto scaling target for the service by setting the `minTaskCount` (defaults to 1) and `maxTaskCount` in the `Service` construct. Then you can specify target values for "CPU Utilization" or "Memory Utilization" across all tasks in your service. Note that the `desiredCount` value will be set to `undefined` if the auto scaling target is configured.
  If you want to configure auto-scaling policies based on resources like Application Load Balancer or SQS Queues, you can set the corresponding resource-specific fields in the extension. For example, you can enable target tracking scaling based on Application Load Balancer request count as follows:
  ```python
  const environment = new Environment(this, 'production');
  const serviceDescription = new ServiceDescription();
  serviceDescription.add(new Container({
    cpu: 256,
    memoryMiB: 512,
    trafficPort: 80,
    image: ecs.ContainerImage.fromRegistry('my-alb'),
  }));
  // Add the extension with target `requestsPerTarget` value set
  serviceDescription.add(new HttpLoadBalancerExtension({ requestsPerTarget: 10 }));
  // Configure the auto scaling target
  new Service(this, 'my-service', {
    environment,
    serviceDescription,
    desiredCount: 5,
    // Task auto-scaling constuct for the service
    autoScaleTaskCount: {
      maxTaskCount: 10,
      targetCpuUtilization: 70,
      targetMemoryUtilization: 50,
    },
  });
  ```
  You can also define your own service extensions for [other auto-scaling policies](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-auto-scaling.html) for your service by making use of the `scalableTaskCount` attribute of the `Service` class.

  In addition to using the default service extensions that come with this module, you
  can choose to implement your own custom service extensions. The `ServiceExtension`
  class is an abstract class you can implement yourself. The following example
  implements a custom service extension that could be added to a service in order to
  autoscale it based on scaling intervals of SQS Queue size:
  ```python
  export class MyCustomAutoscaling extends ServiceExtension {
    constructor() {
      super('my-custom-autoscaling');
      // Scaling intervals for the step scaling policy
      this.scalingSteps = [{ upper: 0, change: -1 }, { lower: 100, change: +1 }, { lower: 500, change: +5 }];
      this.sqsQueue = new sqs.Queue(this.scope, 'my-queue');
    }
    // This hook utilizes the resulting service construct
    // once it is created
    public useService(service: ecs.Ec2Service | ecs.FargateService) {
      this.parentService.scalableTaskCount.scaleOnMetric('QueueMessagesVisibleScaling', {
        metric: this.sqsQueue.metricApproximateNumberOfMessagesVisible(),
        scalingSteps: this.scalingSteps,
      });
    }
  }
  ```
  This `ServiceExtension` can now be reused and added to any number of different
  service descriptions. This allows you to develop reusable bits of configuration,
  attach them to many different services, and centrally manage them. Updating the
  `ServiceExtension` in one place would update all services that use it, instead of
  requiring decentralized updates to many different services.
  Every `ServiceExtension` can implement the following hooks to modify the properties
  of constructs, or make use of the resulting constructs:
  * `addHooks()` - This hook is called after all the extensions are added to a
    ServiceDescription, but before any of the other extension hooks have been run.
    It gives each extension a chance to do some inspection of the overall ServiceDescription
    and see what other extensions have been added. Some extensions may want to register
    hooks on the other extensions to modify them. For example, the Firelens extension
    wants to be able to modify the settings of the application container to route logs
    through Firelens.
  * `modifyTaskDefinitionProps()` - This is hook is passed the proposed
    ecs.TaskDefinitionProps for a TaskDefinition that is about to be created.
    This allows the extension to make modifications to the task definition props
    before the TaskDefinition is created. For example, the App Mesh extension modifies
    the proxy settings for the task.
  * `useTaskDefinition()` - After the TaskDefinition is created, this hook is
    passed the actual TaskDefinition construct that was created. This allows the
    extension to add containers to the task, modify the task definition's IAM role,
    etc.
  * `resolveContainerDependencies()` - Once all extensions have added their containers,
    each extension is given a chance to modify its container's `dependsOn` settings.
    Extensions need to check and see what other extensions were enabled and decide
    whether their container needs to wait on another container to start first.
  * `modifyServiceProps()` - Before an Ec2Service or FargateService is created, this
    hook is passed a draft version of the service props to change. Each extension adds
    its own modifications to the service properties. For example, the App Mesh extension
    needs to modify the service settings to enable CloudMap service discovery.
  * `useService()` - After the service is created, this hook is given a chance to
    utilize that service. This is used by extensions like the load balancer or App Mesh
    extension, which create and link other AWS resources to the ECS extension.
  * `connectToService()` - This hook is called when a user wants to connect one service
    to another service. It allows an extension to implement logic about how to allow
    connections from one service to another. For example, the App Mesh extension implements
    this method in order to easily connect one service mesh service to another, which
    allows the service's Envoy proxy sidecars to route traffic to each other.

  One of the hooks that a `ServiceExtension` can implement is a hook for connection
  logic. This is utilized when connecting one service to another service, e.g.
  connecting a user facing web service with a backend API. Usage looks like this:
  ```python
  const frontendDescription = new ServiceDescription();
  const frontend = new Service(this, 'frontend', {
    environment,
    serviceDescription: frontendDescription,
  });
  const backendDescription = new ServiceDescription();
  const backend = new Service(this, 'backend', {
    environment,
    serviceDescription: backendDescription,
  });
  frontend.connectTo(backend);
  ```
  The address that a service will use to talk to another service depends on the
  type of ingress that has been created by the extension that did the connecting.
  For example, if an App Mesh extension has been used, then the service is accessible
  at a DNS address of `<service name>.<environment name>`. For example:
  ```python
  const environment = new Environment(this, 'production');
  // Define the frontend tier
  const frontendDescription = new ServiceDescription();
  frontendDescription.add(new Container({
    cpu: 1024,
    memoryMiB: 2048,
    trafficPort: 80,
    image: ecs.ContainerImage.fromRegistry('my-frontend-service'),
    environment: {
      BACKEND_URL: 'http://backend.production',
    },
  }));
  const frontend = new Service(this, 'frontend', {
    environment,
    serviceDescription: frontendDescription,
  });
  // Define the backend tier
  const backendDescription = new ServiceDescription();
  backendDescription.add(new Container({
    cpu: 1024,
    memoryMiB: 2048,
    trafficPort: 80,
    image: ecs.ContainerImage.fromRegistry('my-backend-service'),
    environment: {
      FRONTEND_URL: 'http://frontend.production',
    },
  }));
  const backend = new Service(this, 'backend', {
    environment,
    serviceDescription: backendDescription,
  });
  // Connect the two tiers to each other
  frontend.connectTo(backend);
  ```
  The above code uses the well-known service discovery name for each
  service, and passes it as an environment variable to the container so
  that the container knows what address to use when communicating to
  the other service.

  To create an environment with a pre-existing cluster, you must import the cluster first, then use `Environment.fromEnvironmentAttributes()`. When a cluster is imported into an environment, the cluster is treated as immutable. As a result, no extension may modify the cluster to change a setting.
  ```python
  declare const cluster: ecs.Cluster;
  const environment = Environment.fromEnvironmentAttributes(this, 'Environment', {
    capacityType: ecs.EnvironmentCapacityType.EC2, // or `FARGATE`
    cluster,
  });
  ```

  This service extension accepts a list of `Injectable` resources. It grants access to these resources and adds the necessary environment variables to the tasks that are part of the service.
  For example, an `InjectableTopic` is an SNS Topic that grants permission to the task role and adds the topic ARN as an environment variable to the task definition.

  You can use this extension to set up publishing permissions for SNS Topics.
  ```python
  const nameDescription = new ServiceDescription();
  nameDescription.add(new InjecterExtension({
    injectables: [new InjectableTopic({
      // SNS Topic the service will publish to
      topic: new sns.Topic(this, 'my-topic'),
    })],
  }));
  ```

  This service extension creates a default SQS Queue `eventsQueue` for the service (if not provided) and optionally also accepts list of `ISubscribable` objects that the `eventsQueue` can subscribe to. The service extension creates the subscriptions and sets up permissions for the service to consume messages from the SQS Queue.

  You can use this extension to set up SNS Topic subscriptions for the `eventsQueue`. To do this, create a new object of type `TopicSubscription` for every SNS Topic you want the `eventsQueue` to subscribe to and provide it as input to the service extension.
  ```python
  const nameDescription = new ServiceDescription();
  const myServiceDescription = nameDescription.add(new QueueExtension({
    // Provide list of topic subscriptions that you want the `eventsQueue` to subscribe to
    subscriptions: [new TopicSubscription({
      topic: new sns.Topic(this, 'my-topic'),
    }],
  }));
  // To access the `eventsQueue` for the service, use the `eventsQueue` getter for the extension
  const myQueueExtension = myServiceDescription.extensions.queue as QueueExtension;
  const myEventsQueue = myQueueExtension.eventsQueue;
  ```
  For setting up a topic-specific queue subscription, you can provide a custom queue in the `TopicSubscription` object along with the SNS Topic. The extension will set up a topic subscription for the provided queue instead of the default `eventsQueue` of the service.
  ```python
  declare const myEventsQueue: sqs.Queue;
  declare const myTopicQueue: sqs.Queue;
  const nameDescription = new ServiceDescription();
  nameDescription.add(new QueueExtension({
    eventsQueue: myEventsQueue,
    subscriptions: [new TopicSubscription({
      topic: new sns.Topic(this, 'my-topic'),
      // `myTopicQueue` will subscribe to the `my-topic` instead of `eventsQueue`
      topicSubscriptionQueue: {
        queue: myTopicQueue,
      },
    }],
  }));
  ```

  You can scale your service up or down to maintain an acceptable queue latency by tracking the backlog per task. It configures a target tracking scaling policy with target value (acceptable backlog per task) calculated by dividing the `acceptableLatency` by `messageProcessingTime`. For example, if the maximum acceptable latency for a message to be processed after its arrival in the SQS Queue is 10 mins and the average processing time for a task is 250 milliseconds per message, then `acceptableBacklogPerTask = 10 *  60 / 0.25 = 2400`. Therefore, each queue can hold up to 2400 messages before the service starts to scale up. For this, a target tracking policy will be attached to the scaling target for your service with target value `2400`. For more information, please refer: https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-using-sqs-queue.html .
  You can configure auto scaling based on SQS Queue for your service as follows:
  ```python
  declare const myEventsQueue: sqs.Queue;
  declare const myTopicQueue: sqs.Queue;
  const nameDescription = new ServiceDescription();
  nameDescription.add(new QueueExtension({
    eventsQueue: myEventsQueue,
    // Need to specify `scaleOnLatency` to configure auto scaling based on SQS Queue
    scaleOnLatency: {
      acceptableLatency: Duration.minutes(10),
      messageProcessingTime: Duration.millis(250),
    },
    subscriptions: [new TopicSubscription({
      topic: new sns.Topic(this, 'my-topic'),
      // `myTopicQueue` will subscribe to the `my-topic` instead of `eventsQueue`
      topicSubscriptionQueue: {
        queue: myTopicQueue,
        // Optionally provide `scaleOnLatency` for configuring separate autoscaling for `myTopicQueue`
        scaleOnLatency: {
          acceptableLatency: Duration.minutes(10),
          messageProcessingTime: Duration.millis(250),
        },
      },
    }],
  }));
  ```

  The [Publish/Subscribe Service Pattern](https://aws.amazon.com/pub-sub-messaging/) is used for implementing asynchronous communication between services. It involves 'publisher' services emitting events to SNS Topics, which are passed to subscribed SQS queues and then consumed by 'worker' services.
  The following example adds the `InjecterExtension` to a `Publisher` Service which can publish events to an SNS Topic and adds the `QueueExtension` to a `Worker` Service which can poll its `eventsQueue` to consume messages populated by the topic.
  ```python
  const environment = new Environment(this, 'production');
  const pubServiceDescription = new ServiceDescription();
  pubServiceDescription.add(new Container({
    cpu: 256,
    memoryMiB: 512,
    trafficPort: 80,
    image: ecs.ContainerImage.fromRegistry('sns-publish'),
  }));
  const myTopic = new sns.Topic(this, 'myTopic');
  // Add the `InjecterExtension` to the service description to allow publishing events to `myTopic`
  pubServiceDescription.add(new InjecterExtension({
    injectables: [new InjectableTopic({
      topic: myTopic,
    }],
  }));
  // Create the `Publisher` Service
  new Service(this, 'Publisher', {
    environment: environment,
    serviceDescription: pubServiceDescription,
  });
  const subServiceDescription = new ServiceDescription();
  subServiceDescription.add(new Container({
    cpu: 256,
    memoryMiB: 512,
    trafficPort: 80,
    image: ecs.ContainerImage.fromRegistry('sqs-reader'),
  }));
  // Add the `QueueExtension` to the service description to subscribe to `myTopic`
  subServiceDescription.add(new QueueExtension({
    subscriptions: [new TopicSubscription({
      topic: myTopic,
    }],
  }));
  // Create the `Worker` Service
  new Service(this, 'Worker', {
    environment: environment,
    serviceDescription: subServiceDescription,
  });
  ```

  We encourage the development of Community Service Extensions that support
  advanced features. Here are some useful extensions that we have reviewed:
  * [ListenerRulesExtension](https://www.npmjs.com/package/@wheatstalk/ecs-service-extension-listener-rules) for more precise control over Application Load Balancer rules
  > Please submit a pull request so that we can review your service extension and
  > list it here.


pkgId: 07c59d253d0319127580eac08f5cd98a1fc558f4806c041a91319a228f020c78
name: python-cdk-emrserverless-with-delta-lake-help
arch: noarch
version: 2.0.638
epoch: 0
release: 1
summary: Development documents and examples for cdk-emrserverless-with-delta-lake
url: https://github.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-emrserverless-with-delta-lake-2.0.638-1.src.rpm
location_href: Packages/python-cdk-emrserverless-with-delta-lake-help-2.0.638-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-Apache%202.0-green)](https://opensource.org/licenses/Apache-2.0) [![Release](https://github.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/actions/workflows/release.yml/badge.svg)](https://github.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/actions/workflows/release.yml/badge.svg) [![npm downloads](https://img.shields.io/npm/dt/cdk-emrserverless-with-delta-lake?label=npm%20downloads&style=plastic)](https://img.shields.io/npm/dt/cdk-emrserverless-with-delta-lake?label=npm%20downloads&style=plastic) [![pypi downloads](https://img.shields.io/pypi/dw/cdk-emrserverless-with-delta-lake?label=pypi%20downloads&style=plastic)](https://img.shields.io/pypi/dw/cdk-emrserverless-with-delta-lake?label=pypi%20downloads&style=plastic) [![NuGet downlods](https://img.shields.io/nuget/dt/Emrserverless.With.Delta.Lake?label=NuGet%20downloads&style=plastic)](https://img.shields.io/nuget/dt/Emrserverless.With.Delta.Lake?label=NuGet%20downloads&style=plastic) [![repo languages](https://img.shields.io/github/languages/count/HsiehShuJeng/cdk-emrserverless-with-delta-lake?style=plastic)](https://img.shields.io/github/languages/count/HsiehShuJeng/cdk-emrserverless-with-delta-lake?style=plastic)

  | npm (JS/TS) | PyPI (Python) | Maven (Java) | Go | NuGet |
  | --- | --- | --- | --- | --- |
  | [Link](https://www.npmjs.com/package/cdk-emrserverless-with-delta-lake) | [Link](https://pypi.org/project/cdk-emrserverless-with-delta-lake/) | [Link](https://search.maven.org/artifact/io.github.hsiehshujeng/cdk-emrserverless-quickdemo-with-delta-lake) | [Link](https://github.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake-go) | [Link](https://www.nuget.org/packages/Emrserverless.With.Delta.Lake/) |

  ![high level architecture](https://raw.githubusercontent.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/main/images/high%20level%20architecture.png)

  This constrcut builds an EMR studio, a cluster template for the EMR Studio, and an EMR Serverless application. 2 S3 buckets will be created, one is for the EMR Studio workspace and the other one is for EMR Serverless applications. Besides, the VPC and the subnets for the EMR Studio will be tagged `{"Key": "for-use-with-amazon-emr-managed-policies", "Value": "true"}` via a custom resource. This is necessary for the [service role](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-service-role.html#emr-studio-service-role-instructions) of EMR Studio.
  This construct is for analysts, data engineers, and anyone who wants to know how to process **Delta Lake data** with EMR serverless.
  ![cfn designer](https://github.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/blob/main/images/cfn-designer.png?raw=true)
  They build the construct via [cdkv2](https://docs.aws.amazon.com/cdk/v2/guide/home.html) and build a serverless job within the EMR application generated by the construct via AWS CLI within few minutes. After the EMR serverless job is finished, they can then check the processed result done by the EMR serverless job on an EMR notebook through the cluster template.
  ![app history](https://github.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/blob/main/images/spark%20jobs.png?raw=true)



  * [Requirements](#requirements)
  * [Before deployment](#before-deployment)
  * [Minimal content for deployment](#minimal-content-for-deployment)
  * [After deployment](#after-deployment)
  * [Create an EMR Serverless application](#create-an-emr-serverless-app)
  * [Check the executing job](#check-the-executing-job)
  * [Check results from an EMR notebook via cluster template](#check-results-from-an-emr-notebook-via-cluster-template)
  * [Fun facts](#fun-facts)
  * [Future work](#future-work)



  1. Your current identity has the `AdministratorAccess` power.
  2. [An IAM user](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) named `Administrator` with the `AdministratorAccess` power.

     * This is related to the Portfolio of AWS Service Catalog created by the construct, which is required for [EMR cluster tempaltes](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-cluster-templates.html).
     * You can choose whatsoever identity you wish to associate with the Product in the Porfolio for creating an EMR cluster via cluster tempalte. Check `serviceCatalogProps` in the `EmrServerless` construct for detail, otherwise, the IAM user mentioned above will be chosen to set up with the Product.



  You might want to execute the following command.

  ```sh
  PROFILE_NAME="scott.hsieh"

  cdk bootstrap aws://${AWS_ACCOUNT_ID}/${AWS_REGION} --profile ${PROFILE_NAME}
  ```



  ```python

  import * as cdk from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import { EmrServerless } from 'cdk-emrserverless-with-delta-lake';

  class TypescriptStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props?: cdk.StackProps) {
      super(scope, id, props);
      new EmrServerless(this, 'EmrServerless');
    }
  }

  const app = new cdk.App();
  new TypescriptStack(app, 'TypescriptStack', {
    stackName: 'emr-studio',
    env: {
      region: process.env.CDK_DEFAULT_REGION,
      account: process.env.CDK_DEFAULT_ACCOUNT,
    },
  });
  ```



  Promise me, darling, make advantage on the CloudFormation outputs.  All you need is **copy-paste**, **copy-paste**, **copy-paste**, life should be always that easy.
  ![cfn outputs](https://raw.githubusercontent.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/main/images/cfn-outputs.png)

  1. **Define the following environment variables on your current session.**

     ```
     export PROFILE_NAME="${YOUR_PROFILE_NAME}"
     export JOB_ROLE_ARN="${copy-paste-thank-you}"
     export APPLICATION_ID="${copy-paste-thank-you}"
     export SERVERLESS_BUCKET_NAME="${copy-paste-thank-you}"
     export DELTA_LAKE_SCRIPT_NAME="delta-lake-demo"
     ```
  2. **Copy partial NYC-taxi data into the EMR Serverless bucket.**

     ```sh
     aws s3 cp s3://nyc-tlc/trip\ data/ s3://${SERVERLESS_BUCKET_NAME}/nyc-taxi/ --exclude "*" --include "yellow_tripdata_2021-*.parquet" --recursive --profile ${PROFILE_NAME}
     ```
  3. **Create a Python script for processing Delta Lake**

     ```sh
     touch ${DELTA_LAKE_SCRIPT_NAME}.py
     cat << EOF > ${DELTA_LAKE_SCRIPT_NAME}.py
     from pyspark.sql import SparkSession
     import uuid

     if __name__ == "__main__":
         """
             Delta Lake with EMR Serverless, take NYC taxi as example.
         """
         spark = SparkSession \\
             .builder \\
             .config("spark.sql.extensions", "io.delta.sql.DeltaSparkSessionExtension") \\
             .config("spark.sql.catalog.spark_catalog", "org.apache.spark.sql.delta.catalog.DeltaCatalog") \\
             .enableHiveSupport() \\
             .appName("Delta-Lake-OSS") \\
             .getOrCreate()

         url = "s3://${SERVERLESS_BUCKET_NAME}/emr-serverless-spark/delta-lake/output/1.2.1/%s/" % str(
             uuid.uuid4())

         
         spark.range(5).write.format("delta").save(url)

         
         spark.read.format("delta").load(url).show()

         
         base = spark.read.parquet(
             "s3://${SERVERLESS_BUCKET_NAME}/nyc-taxi/*.parquet")

         
         base.write.format("delta") \\
             .mode("overwrite") \\
             .save("s3://${SERVERLESS_BUCKET_NAME}/emr-serverless-spark/delta-lake/nyx-tlc-2021")
         spark.stop()
     EOF
     ```
  4. **Upload the script and required jars into the serverless bucket**

     ```sh
     
     aws s3 cp delta-lake-demo.py s3://${SERVERLESS_BUCKET_NAME}/scripts/${DELTA_LAKE_SCRIPT_NAME}.py --profile ${PROFILE_NAME}
     
     DELTA_VERSION="3.0.0"
     DELTA_LAKE_CORE="delta-spark_2.13-${DELTA_VERSION}.jar"
     DELTA_LAKE_STORAGE="delta-storage-${DELTA_VERSION}.jar"
     curl https://repo1.maven.org/maven2/io/delta/delta-spark_2.13/${DELTA_VERSION}/${DELTA_LAKE_CORE} --output ${DELTA_LAKE_CORE}
     curl https://repo1.maven.org/maven2/io/delta/delta-storage/${DELTA_VERSION}/${DELTA_LAKE_STORAGE} --output ${DELTA_LAKE_STORAGE}
     aws s3 mv ${DELTA_LAKE_CORE} s3://${SERVERLESS_BUCKET_NAME}/jars/${DELTA_LAKE_CORE} --profile ${PROFILE_NAME}
     aws s3 mv ${DELTA_LAKE_STORAGE} s3://${SERVERLESS_BUCKET_NAME}/jars/${DELTA_LAKE_STORAGE} --profile ${PROFILE_NAME}
     ```



  Rememeber, you got so much information to copy and paste from the CloudFormation outputs.
  ![cfn outputs](https://raw.githubusercontent.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/main/images/cfn-outputs.png)

  ```sh
  aws emr-serverless start-job-run \
    --application-id ${APPLICATION_ID} \
    --execution-role-arn ${JOB_ROLE_ARN} \
    --name 'shy-shy-first-time' \
    --job-driver '{
          "sparkSubmit": {
              "entryPoint": "s3://'${SERVERLESS_BUCKET_NAME}'/scripts/'${DELTA_LAKE_SCRIPT_NAME}'.py",
              "sparkSubmitParameters": "--conf spark.executor.cores=1 --conf spark.executor.memory=4g --conf spark.driver.cores=1 --conf spark.driver.memory=4g --conf spark.executor.instances=1 --conf spark.jars=s3://'${SERVERLESS_BUCKET_NAME}'/jars/'${DELTA_LAKE_CORE}',s3://'${SERVERLESS_BUCKET_NAME}'/jars/'${DELTA_LAKE_STORAGE}'"
          }
      }' \
    --configuration-overrides '{
          "monitoringConfiguration": {
              "s3MonitoringConfiguration": {
                  "logUri": "s3://'${SERVERLESS_BUCKET_NAME}'/serverless-log/"
  	        }
  	    }
  	}' \
  	--profile ${PROFILE_NAME}
  ```

  If you execute with success, you should see similar reponse as the following:

  ```sh
  {
      "applicationId": "00f1gvklchoqru25",
      "jobRunId": "00f1h0ipd2maem01",
      "arn": "arn:aws:emr-serverless:ap-northeast-1:630778274080:/applications/00f1gvklchoqru25/jobruns/00f1h0ipd2maem01"
  }
  ```

  and got a Delta Lake data under `s3://${SERVERLESS_BUCKET_NAME}/emr-serverless-spark/delta-lake/nyx-tlc-2021/`.
  ![Delta Lake data](https://raw.githubusercontent.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/main/images/delta%20lake%20data.png)



  Access the EMR Studio via the URL from the CloudFormation outputs. It should look very similar to the following url: `https://es-pilibalapilibala.emrstudio-prod.ap-northeast-1.amazonaws.com`, i.e., weird string and region won't be the same as mine.

  1. **Enter into the application**
     ![enter into the app](https://raw.githubusercontent.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/main/images/enter-serverless-app.png)
  2. **Enter into the executing job**



  1. Create a workspace and an EMR cluster via the cluster template on the AWS Console
     ![create workspace](https://raw.githubusercontent.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/main/images/create%20workspace.png)
  2. Check the results delivered by the EMR serverless application via an EMR notebook.



  1. You can assign multiple jars as a comma-separated list to the `spark.jars` as [the Spark page](https://spark.apache.org/docs/latest/configuration.html#runtime-environment) says for your EMR Serverless job. The UI will complain, you still can start the job. Don't be afraid, just click it like when you were child, facing authority fearlessly.
     ![ui bug](https://raw.githubusercontent.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/main/images/ui-bug.png)
  2. To fully delet a stack with the construct, you need to make sure there is no more workspace within the EMR Studio. Aside from that, you also need to remove the associated identity from the Service Catalog (this is a necessary resource for the cluster template).
  3. Version inconsistency on Spark history. Possibly it can be ignored yet still made me wonder why the versions are different.
     ![naughty inconsistency](https://raw.githubusercontent.com/HsiehShuJeng/cdk-emrserverless-with-delta-lake/main/images/Spark%20history.png)
  4. So far, I still haven't figured out how to make the s3a URI work. The s3 URI is fine while the serverless app will complain that it couldn't find proper credentials provider to read the s3a URI.



  1. Custom resuorce for EMR Serverless
  2. Make the construct more flexible for users
  3. Compare Databricks Runtime and EMR Serverless.


pkgId: e55b9dc1c47f776fe353d59168c801e9a98a34a790d9f0902dc810d54032951c
name: python-cdk-events-notify-help
arch: noarch
version: 2.2.328
epoch: 0
release: 1
summary: Development documents and examples for cdk-events-notify
url: https://github.com/neilkuan/cdk-events-notify.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-events-notify-2.2.328-1.src.rpm
location_href: Packages/python-cdk-events-notify-help-2.2.328-1.noarch.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-events-notify.svg)](https://badge.fury.io/js/cdk-events-notify)
  [![PyPI version](https://badge.fury.io/py/cdk-events-notify.svg)](https://badge.fury.io/py/cdk-events-notify)
  ![Release](https://github.com/neilkuan/cdk-s3bucket/workflows/release/badge.svg)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-events-notify?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-events-notify?label=pypi&color=blue)



  `cdk-events-notify` is an AWS CDK Construct Library that provides you know who login in your aws console.



  It’s just a small feature at the moment,
  Provides you to trigger Lambda Function push notifications to Line Notify or Slack when you discover Console Login event or swith role event through Cloudtrail.

  > Welcome to contribute another event notify case you want.



  ![](./images/overview.png)



  * Line Notify
  * Slack ([webhooks](https://api.slack.com/messaging/webhooks#posting_with_webhooks))



  > more see https://aws.amazon.com/tw/cloudtrail/pricing/
  > ![](./images/management-events.png)



  > more see [line notify docs](https://notify-bot.line.me/doc/en/)

  ![](./images/access-token.png)



  ```bash
  Use the npm dist tag to opt in CDKv1 or CDKv2:

  // for CDKv2
  npm install cdk-events-notify
  or
  npm install cdk-events-notify@latest
  ```





  ```python
  import * as cdk from 'aws-cdk-lib';
  import { EventNotify } from 'cdk-events-notify';

  const app = new cdk.App();
  const stack = new cdk.Stack(app, 'integ-stack', { env });
  new EventNotify(stack, 'LineEventNotify', { lineNotifyToken: process.env.LINE_NOTIFY_TOKEN });
  ```



  ```bash
  cdk deploy
  ```



  ```bash
  cdk destroy
  ```



  * line
    ![](./images/line-chat.jpg)
  * slack
    ![](./images/slack.jpg)



  * [EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/aws-events.html)
  * [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)

  > Note: Event Bridge can not cross region , if you console sign in not the cdk-events-notify region will not get the evnet in cloudtrail see this [docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/cloudtrail-integration.html#cloudtrail-integration_signin-regions)



  [![Stargazers repo roster for @neilkuan/cdk-events-notify](https://reporoster.com/stars/neilkuan/cdk-events-notify)](https://github.com/neilkuan/cdk-events-notify/stargazers)
  [![Forkers repo roster for @neilkuan/cdk-events-notify](https://reporoster.com/forks/neilkuan/cdk-events-notify)](https://github.com/neilkuan/cdk-events-notify/network/members)


pkgId: 5299f4a9a026b932ea93af3696e5b43bd475898b77d38bdd5e844c5e2b9a4f06
name: python-cdk-gitlab-runner-help
arch: noarch
version: 2.2.356
epoch: 0
release: 1
summary: Development documents and examples for cdk-gitlab-runner
url: https://github.com/neilkuan/cdk-gitlab-runner.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-gitlab-runner-2.2.356-1.src.rpm
location_href: Packages/python-cdk-gitlab-runner-help-2.2.356-1.noarch.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdk-gitlab-runner.svg)](https://badge.fury.io/js/cdk-gitlab-runner)
  [![PyPI version](https://badge.fury.io/py/cdk-gitlab-runner.svg)](https://badge.fury.io/py/cdk-gitlab-runner)
  [![release](https://github.com/neilkuan/cdk-gitlab-runner/actions/workflows/release.yml/badge.svg)](https://github.com/neilkuan/cdk-gitlab-runner/actions/workflows/release.yml)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdk-gitlab-runner?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdk-gitlab-runner?label=pypi&color=blue)

  ![](https://img.shields.io/badge/iam_role_self-enable-green=?style=plastic&logo=appveyor)
  ![](https://img.shields.io/badge/vpc_self-enable-green=?style=plastic&logo=appveyor)
  ![](https://img.shields.io/badge/gitlab_url-customize-green=?style=plastic&logo=appveyor)
  ![](https://img.shields.io/badge/spotfleet-runner-green=?style=plastic&logo=appveyor)



  Use AWS CDK to create gitlab runner, and use [gitlab runner](https://gitlab.com/gitlab-org/gitlab-runner) to help you execute your Gitlab Pipeline Job.

  > GitLab Runner is the open source project that is used to run your CI/CD jobs and send the results back to GitLab. [(source repo)](https://gitlab.com/gitlab-org/gitlab-runner)



  Gitlab provides [400 minutes per month for each free user](https://about.gitlab.com/pricing/), hosted Gitlab Runner to execute your gitlab pipeline job.That's pretty good and users don't need to manage gitlab runner. If it is just a simple ci job for test 400, it may be enough.
  But what if you want to deploy to your AWS production environment through pipeline job?
  Is there any security consideration for using the hosted gitlab runner?!

  But creating Gitlab Runner is not that simple, so I created this OSS so that you can quickly create Gitlab Runner and delete your Gitlab Runner via AWS CDK.
  It will be used with AWS IAM Role, so you don't need to put AKSK in Gitlab environment variables.

  ![](./image/cdk-gitlab-runner.png)





  * VPC

    * Public Subnet (2)
  * EC2 (1 T3.micro)





  This registration process is only supported in GitLab Runner 15.10 or later
  This registration process is not supported in GitLab Runner 15.9 or earlier and only available as an experimental feature in GitLab Runner 15.10 and 15.11. You should upgrade to GitLab Runner 16.0 or later to use a stable version of this registration process. [Check this issue](https://github.com/neilkuan/cdk-gitlab-runner/issues/1796)

  Group > Settings > CI/CD
  ![group](image/group_runner_page.png)



  This registration process is only supported in GitLab Runner 15.10 or later
  This registration process is not supported in GitLab Runner 15.9 or earlier and only available as an experimental feature in GitLab Runner 15.10 and 15.11. You should upgrade to GitLab Runner 16.0 or later to use a stable version of this registration process. [Check this issue](https://github.com/neilkuan/cdk-gitlab-runner/issues/1796)

  Group > Build > Runners
  ![group](image/gitlab-runner-new-register.png)
  ![group](image/gitlab-runner-new-register-1.png)
  ![group](image/gitlab-runner-new-register-2.png)
  ![group](image/gitlab-runner-new-register-3.jpg)



  This registration process is only supported in GitLab Runner 15.10 or later
  This registration process is not supported in GitLab Runner 15.9 or earlier and only available as an experimental feature in GitLab Runner 15.10 and 15.11. You should upgrade to GitLab Runner 16.0 or later to use a stable version of this registration process. [Check this issue](https://github.com/neilkuan/cdk-gitlab-runner/issues/1796)

  Project > Settings > CI/CD > Runners
  ![project](image/project_runner_page.png)



  This registration process is only supported in GitLab Runner 15.10 or later
  This registration process is not supported in GitLab Runner 15.9 or earlier and only available as an experimental feature in GitLab Runner 15.10 and 15.11. You should upgrade to GitLab Runner 16.0 or later to use a stable version of this registration process. [Check this issue](https://github.com/neilkuan/cdk-gitlab-runner/issues/1796)

  Project > Settings > CI/CD > Runners
  ![project](image/gitlab-runner-new-register-project.png)



  Replace your gitlab runner token in `$GITLABTOKEN`



  Use the npm dist tag to opt in CDKv1 or CDKv2:

  ```bash
  // for CDKv2
  npm install cdk-gitlab-runner
  or
  npm install cdk-gitlab-runner@latest

  // for CDKv1
  npm install cdk-gitlab-runner@cdkv1
  ```





  ```python
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';

  // If want change instance type to t3.large .
  new GitlabContainerRunner(this, 'runner-instance', { gitlabtoken: 'glrt-GITLABTOKEN', ec2type:'t3.large',gitlabRunnerVersion: '15.10' });
  // OR
  // Just create a gitlab runner , by default instance type is t3.micro .
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';

  new GitlabContainerRunner(this, 'runner-instance', { gitlabtoken: 'glrt-GITLABTOKEN', gitlabRunnerVersion: '15.10' });
  ```



  If you want change what you want tag name .

  ```python
  // If you want change  what  your self Gitlab Server Url .
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';

  new GitlabContainerRunner(this, 'runner-instance-change-tag', {
    gitlabtoken: 'glrt-GITLABTOKEN',
    gitlaburl: 'https://gitlab.my.com/',
    gitlabRunnerVersion: '15.10'
  });
  ```



  If you want change what you want tag name .
  !!! Not support Gitlab Runner 15.10 and later !!!

  ```python
  // If you want change  what  you want tag name .
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';

  new GitlabContainerRunner(this, 'runner-instance-change-tag', {
    gitlabtoken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    tags: ['aa', 'bb', 'cc'],
  });
  ```



  If you want add runner other IAM Policy like s3-readonly-access.

  ```python
  // If you want add runner other IAM Policy like s3-readonly-access.
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';
  import { ManagedPolicy } from 'aws-cdk-lib/aws-iam';

  const runner = new GitlabContainerRunner(this, 'runner-instance-add-policy', {
    gitlabtoken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    tags: ['aa', 'bb', 'cc'],
  });
  runner.runnerRole.addManagedPolicy(
    ManagedPolicy.fromAwsManagedPolicyName('AmazonS3ReadOnlyAccess'),
  );
  ```



  If you want add runner other SG Ingress .

  ```python
  // If you want add runner other SG Ingress .
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';
  import { Port, Peer } from 'aws-cdk-lib/aws-ec2';

  const runner = new GitlabContainerRunner(this, 'runner-add-SG-ingress', {
    gitlabtoken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    tags: ['aa', 'bb', 'cc'],
  });

  // you can add ingress in your runner SG .
  runner.defaultRunnerSG.connections.allowFrom(
    Peer.ipv4('0.0.0.0/0'),
    Port.tcp(80),
  );
  ```



  > 2020/06/27 , you can use your self exist VPC or new VPC , but please check your `vpc public Subnet` Auto-assign public IPv4 address must be Yes ,or `vpc private Subnet` route table associated `nat gateway` .

  ```python
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';
  import { Port, Peer, Vpc, SubnetType } from 'aws-cdk-lib/aws-ec2';
  import { ManagedPolicy } from 'aws-cdk-lib/aws-iam';

  const newvpc = new Vpc(stack, 'VPC', {
    ipAddresses: IpAddresses.cidr('10.0.0.0/16'),
    maxAzs: 2,
    subnetConfiguration: [
      {
        cidrMask: 26,
        name: 'RunnerVPC',
        subnetType: SubnetType.PUBLIC,
      },
    ],
    natGateways: 0,
  });

  const runner = new GitlabContainerRunner(this, 'testing', {
    gitlabtoken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    ec2type: 't3.small',
    selfvpc: newvpc,
  });
  ```



  > 2020/06/27 , you can use your self exist role assign to runner

  ```python
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';
  import { Port, Peer } from 'aws-cdk-lib/aws-ec2';
  import { ManagedPolicy, Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';

  const role = new Role(this, 'runner-role', {
    assumedBy: new ServicePrincipal('ec2.amazonaws.com'),
    description: 'For Gitlab EC2 Runner Test Role',
    roleName: 'TestRole',
  });

  const runner = new GitlabContainerRunner(stack, 'testing', {
    gitlabtoken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    ec2iamrole: role,
  });
  runner.runnerRole.addManagedPolicy(
    ManagedPolicy.fromAwsManagedPolicyName('AmazonS3ReadOnlyAccess'),
  );
  ```



  > 2020/08/22 , you can change you want ebs size.

  ```python
  import { GitlabContainerRunner } from 'cdk-gitlab-runner';

  new GitlabContainerRunner(stack, 'testing', {
    gitlabtoken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    ebsSize: 50,
  });
  ```



  > 2020/11/25 , you can set the number of runners.

  ```python
  import { GitlabRunnerAutoscaling } from 'cdk-gitlab-runner';

  new GitlabRunnerAutoscaling(stack, 'testing', {
    gitlabToken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    minCapacity: 2,
    maxCapacity: 2,
  });
  ```



  > 2020/08/27 , you can use spotfleet instance be your gitlab runner,
  > after create spotfleet instance will auto output instance id.

  ```python
  import { GitlabContainerRunner, BlockDuration } from 'cdk-gitlab-runner';

  const runner = new GitlabContainerRunner(stack, 'testing', {
    gitlabToken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    ec2type: 't3.large',
    spotFleet: true,
  });
  // configure the expiration after 1 hours
  runner.expireAfter(Duration.hours(1));
  ```

  > 2020/11/19, you setting job runtime bind host volumes.
  > see more https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runnersdocker-section

  ```python
  import { GitlabContainerRunner, BlockDuration } from 'cdk-gitlab-runner';

  const runner = new GitlabContainerRunner(stack, 'testing', {
    gitlabToken: 'glrt-GITLABTOKEN',
    gitlabRunnerVersion: '15.10',
    ec2type: 't3.large',
    dockerVolumes: [
      {
        hostPath: '/tmp/cache',
        containerPath: '/tmp/cache',
      },
    ],
  });
  ```



  ![runner](image/group_runner2.png)



  > !!!!! Not Support Gitlab Runner after 15.10 and later



  [gitlab docs see more ...](https://docs.gitlab.com/ee/ci/yaml/README.html)

  ```yaml
  dockerjob:
    image: docker:18.09-dind
    variables:
    tags:
      - runner
      - awscdk
      - gitlab
    variables:
      DOCKER_TLS_CERTDIR: ""
    before_script:
      - docker info
    script:
      - docker info;
      - echo 'test 123';
      - echo 'hello world 1228'
  ```







  ![system manager](image/session.png)





  ```bash

  sudo -i


  root# docker ps -a



  root# cd /home/ec2-user/.gitlab-runner/ && ls
  config.toml
  ```



  [![Stargazers repo roster for @neilkuan/cdk-gitlab-runner](https://reporoster.com/stars/neilkuan/cdk-gitlab-runner)](https://github.com/neilkuan/cdk-gitlab-runner/stargazers)


pkgId: 8b2f1676627aa1181b4b130978d1420ed68072004b3a2d34550c469a7aa45957
name: python-cdk-image-pipeline-help
arch: noarch
version: 0.5.88
epoch: 0
release: 1
summary: Development documents and examples for cdk-image-pipeline
url: https://github.com/aws-samples/cdk-image-pipeline.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-image-pipeline-0.5.88-1.src.rpm
location_href: Packages/python-cdk-image-pipeline-help-0.5.88-1.noarch.rpm
checksum_type: sha256
description:
  L3 construct that can be used to quickly deploy a complete EC2 Image Builder Image Pipeline.
  This construct creates the required infrastructure for an Image Pipeline:
  * Infrastructure configuration which specifies the infrastructure within which to build and test your EC2 Image Builder image.
  * An instance profile associated with the infrastructure configuration
  * An EC2 Image Builder recipe defines the base image to use as your starting point to create a new image, along with the set of components that you add to customize your image and verify that everything is working as expected.
  * Image Builder uses the AWS Task Orchestrator and Executor (AWSTOE) component management application to orchestrate complex workflows. AWSTOE components are based on YAML documents that define the scripts to customize or test your image. Support for multiple components.
  * Image Builder image pipelines provide an automation framework for creating and maintaining custom AMIs and container images.


pkgId: 02b915aa84df8a53b3dd93d2479f81bf1df1d98928374d63661f00c151cd3bba
name: python-cdk-lambda-subminute-help
arch: noarch
version: 2.0.558
epoch: 0
release: 1
summary: Development documents and examples for cdk-lambda-subminute
url: https://github.com/HsiehShuJeng/cdk-lambda-subminute.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-lambda-subminute-2.0.558-1.src.rpm
location_href: Packages/python-cdk-lambda-subminute-help-2.0.558-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-Apache%202.0-green)](https://opensource.org/licenses/Apache-2.0) [![Release](https://github.com/HsiehShuJeng/cdk-lambda-subminute/workflows/Release/badge.svg)](https://github.com/HsiehShuJeng/cdk-lambda-subminute/actions/workflows/release.yml) [![npm downloads](https://img.shields.io/npm/dt/cdk-lambda-subminute?label=npm%20downloads&style=plastic)](https://img.shields.io/npm/dt/cdk-lambda-subminute?label=npm%20downloads&style=plastic) [![pypi downloads](https://img.shields.io/pypi/dm/cdk-lambda-subminute?label=pypi%20downloads&style=plastic)](https://img.shields.io/pypi/dm/cdk-lambda-subminute?label=pypi%20downloads&style=plastic) [![NuGet downloads](https://img.shields.io/nuget/dt/Lambda.Subminute?label=NuGet%20downloads&style=plastic)](https://img.shields.io/nuget/dt/Lambda.Subminute?label=NuGet%20downloads&style=plastic) [![repo languages](https://img.shields.io/github/languages/count/HsiehShuJeng/cdk-lambda-subminute?style=plastic)](https://img.shields.io/github/languages/count/HsiehShuJeng/cdk-lambda-subminute?style=plastic)

  | npm (JS/TS) | PyPI (Python) | Maven (Java) | Go | NuGet |
  | --- | --- | --- | --- | --- |
  | [Link](https://www.npmjs.com/package/cdk-lambda-subminute) | [Link](https://pypi.org/project/cdk_lambda_subminute/) | [Link](https://search.maven.org/artifact/io.github.hsiehshujeng/cdk-lambda-subminute) | [Link](https://github.com/HsiehShuJeng/cdk-lambda-subminute-go) | [Link](https://www.nuget.org/packages/Lambda.Subminute/) |

  This construct creates a state machine that can invoke a Lambda function per time unit which can be less than one minute, such as invoking every 10 seconds. You only need to craft a Lambda function and then assign it as an argument into the construct. An example is included.



  <p align="center"><img src="https://raw.githubusercontent.com/HsiehShuJeng/cdk-lambda-subminute/main/images/cdk_lambda_subminute.png"/></p>



  This construct library is reffered to thie AWS Architecture blog post, [*A serverless solution for invoking AWS Lambda at a sub-minute frequency*](https://aws.amazon.com/tw/blogs/architecture/a-serverless-solution-for-invoking-aws-lambda-at-a-sub-minute-frequency/), written by **Emanuele Menga**. I made it as a constrcut library where you only need to care about a target Lambda function, how frequent and how long you want to execute.





  You could also refer to [here](https://github.com/HsiehShuJeng/cdk-lambda-subminute/tree/main/src/demo/typescript).

  ```bash
  $ cdk --init language typescript
  $ yarn add cdk-lambda-subminute
  ```

  ```python
  class TypescriptStack extends cdk.Stack {
    constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
      super(scope, id, props);

      const targetLabmda = new Function(this, 'targetFunction', {
        code: Code.fromInline('exports.handler = function(event, ctx, cb) { return cb(null, "hi"); })'), // It's just a simple function for demonstration purpose only.
        functionName: 'testTargetFunction',
        runtime: Runtime.NODEJS_18_X,
        handler: 'index.handler',
      });
      const cronJobExample = 'cron(50/1 15-17 ? * SUN-SAT *)';
      const subminuteMaster = new LambdaSubminute(this, 'LambdaSubminute', { targetFunction: targetLabmda, cronjobExpression: cronJobExample });

      new cdk.CfnOutput(this, 'OStateMachineArn', { value: subminuteMaster.stateMachineArn });
      new cdk.CfnOutput(this, 'OIteratorFunctionArn', { value: subminuteMaster.iteratorFunction.functionArn });
    }
  }

  const app = new cdk.App();
  new TypescriptStack(app, 'TypescriptStack', {
  });
  ```



  You could also refer to [here](https://github.com/HsiehShuJeng/cdk-lambda-subminute/tree/main/src/demo/python).

  ```bash

  $ python -m ensurepip --upgrade
  $ python -m pip install --upgrade pip
  $ python -m pip install --upgrade virtualenv

  $ cdk init --language python

  $ source .venv/bin/activate
  $ cat <<EOL > requirements.txt
  aws-cdk.core
  aws-cdk.aws-lambda
  cdk-lambda-subminute
  EOL
  $ python -m pip install -r requirements.txt
  ```

  ```python
  from aws_cdk import core as cdk
  from aws_cdk.aws_lambda import Code, Function, Runtime
  from cdk_lambda_subminute import LambdaSubminute

  class PythonStack(cdk.Stack):
      def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None:
          super().__init__(scope, construct_id, **kwargs)

          target_lambda = Function(
              self, "targetFunction",
              code=Code.from_inline(
                  "exports.handler = function(event, ctx, cb) { return cb(null, \"hi\"); })"),
              function_name="testTargetFunction",
              runtime=Runtime.NODEJS_18_X,
              handler="index.handler"
          )
          cron_job_example = "cron(10/1 4-5 ? * SUN-SAT *)"
          subminute_master = LambdaSubminute(
              self, "LambdaSubminute",
              target_function=target_lambda,
              cronjob_expression=cron_job_example,
              frequency=7,
              interval_time=8)

          cdk.CfnOutput(self, "OStateMachineArn",
                        value=subminute_master.state_machine_arn)
          cdk.CfnOutput(self, "OIteratorFunctionArn",
                        value=subminute_master.iterator_function.function_arn)
  ```

  ```bash
  $ deactivate
  ```



  You could also refer to [here](https://github.com/HsiehShuJeng/cdk-lambda-subminute/tree/main/src/demo/java).

  ```bash
  $ cdk init --language java
  $ mvn package
  ```

  ```xml
  .
  .
  <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <cdk.version>2.149.0</cdk.version>
        <constrcut.verion>2.0.442</constrcut.verion>
        <junit.version>5.7.1</junit.version>
  </properties>
   .
   .
   <dependencies>
       <!-- AWS Cloud Development Kit -->
        <dependency>
              <groupId>software.amazon.awscdk</groupId>
              <artifactId>core</artifactId>
              <version>${cdk.version}</version>
        </dependency>
        <dependency>
              <groupId>software.amazon.awscdk</groupId>
              <artifactId>lambda</artifactId>
              <version>${cdk.version}</version>
        </dependency>
        <dependency>
              <groupId>io.github.hsiehshujeng</groupId>
              <artifactId>cdk-lambda-subminute</artifactId>
              <version>${constrcut.verion}</version>
        </dependency>
       .
       .
       .
   </dependencies>
  ```

  ```java
  package com.myorg;

  import software.amazon.awscdk.core.CfnOutput;
  import software.amazon.awscdk.core.CfnOutputProps;
  import software.amazon.awscdk.core.Construct;
  import software.amazon.awscdk.core.Stack;
  import software.amazon.awscdk.core.StackProps;
  import software.amazon.awscdk.services.lambda.Code;
  import software.amazon.awscdk.services.lambda.Function;
  import software.amazon.awscdk.services.lambda.FunctionProps;
  import software.amazon.awscdk.services.lambda.Runtime;
  import io.github.hsiehshujeng.cdk.lambda.subminute.LambdaSubminute;
  import io.github.hsiehshujeng.cdk.lambda.subminute.LambdaSubminuteProps;

  public class JavaStack extends Stack {
      public JavaStack(final Construct scope, final String id) {
          this(scope, id, null);
      }

      public JavaStack(final Construct scope, final String id, final StackProps props) {
          super(scope, id, props);

          Function targetLambda = new Function(this, "targetFunction",
            FunctionProps.builder()
                .code(Code.fromInline("exports.handler = function(event, ctx, cb) { return cb(null, \"hi\"); })"))
                .functionName("estTargetFunction")
                .runtime(Runtime.NODEJS_18_X)
                .handler("index.handler")
                .build());
          String cronJobExample = "cron(50/1 4-5 ? * SUN-SAT *)";
          LambdaSubminute subminuteMaster = new LambdaSubminute(this, "LambdaSubminute", LambdaSubminuteProps.builder()
                .targetFunction(targetLambda)
                .cronjobExpression(cronJobExample)
                .frequency(6)
                .intervalTime(9)
                .build());

          new CfnOutput(this, "OStateMachineArn",
                  CfnOutputProps.builder()
                    .value(subminuteMaster.getStateMachineArn())
                    .build());
          new CfnOutput(this, "OIteratorFunctionArn",
                  CfnOutputProps.builder()
                    .value(subminuteMaster.getIteratorFunction().getFunctionName())
                    .build());
      }
  }

  ```



  You could also refer to [here](https://github.com/HsiehShuJeng/cdk-lambda-subminute/tree/main/src/demo/csharp).

  ```bash
  $ cdk init --language csharp
  $ dotnet add src/Csharp package Amazon.CDK.AWS.Lambda
  $ dotnet add src/Csharp package Lambda.Subminute --version 2.0.442
  ```

  ```cs
  using Amazon.CDK;
  using Amazon.CDK.AWS.Lambda;
  using ScottHsieh.Cdk;

  namespace Csharp
  {
      public class CsharpStack : Stack
      {
          internal CsharpStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
          {
              var targetLambda = new Function(this, "targetFunction", new FunctionProps
              {
                  Code = Code.FromInline("exports.handler = function(event, ctx, cb) { return cb(null, \"hi\"); })"),
                  FunctionName = "testTargetFunction",
                  Runtime = Runtime.NODEJS_18_X,
                  Handler = "index.handler"
              });
              string cronJobExample = "cron(50/1 6-7 ? * SUN-SAT *)";
              var subminuteMaster = new LambdaSubminute(this, "LambdaSubminute", new LambdaSubminuteProps
              {
                  TargetFunction = targetLambda,
                  CronjobExpression = cronJobExample,
                  Frequency = 10,
                  IntervalTime = 6,
              });

              new CfnOutput(this, "OStateMachineArn", new CfnOutputProps
              {
                  Value = subminuteMaster.StateMachineArn
              });
              new CfnOutput(this, "OIteratorFunctionArn", new CfnOutputProps
              {
                  Value = subminuteMaster.IteratorFunction.FunctionArn
              });
          }
      }
  }
  ```



  ```bash

  cdk init app -l go

  go get github.com/HsiehShuJeng/cdk-lambda-subminute-go/cdklambdasubminute/v2@v2.0.442

  go mod tidy

  go get -u ./...
  ```



  ![image](https://raw.githubusercontent.com/HsiehShuJeng/cdk-lambda-subminute/main/images/statemachine_diagram.png)



  Originally, I utilized `PythonFuncion` in the module of [**@aws-cdk/aws-lambda-python**](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-lambda-python-readme.html) to build the iterator Lambda function. Every thing works fine, including test, on my local machine (MacBook Pro M1), until it comes to the CI in Github Actions, it awlays gave me the following message:

  ```bash

  Bundling did not produce any output. Check that content is written to /asset-output.

        64 |     }));
        65 |
      > 66 |     this.function = new PythonFunction(this, 'Iterator', {
           |                     ^
        67 |       functionName: 'lambda-subminute-iterator',
        68 |       description: 'A function for breaking the limit of 1 minute with the CloudWatch Rules.',
        69 |       logRetention: RetentionDays.THREE_MONTHS,

        at AssetStaging.bundle (node_modules/@aws-cdk/core/lib/asset-staging.ts:484:13)
        at AssetStaging.stageByBundling (node_modules/@aws-cdk/core/lib/asset-staging.ts:328:10)
        at stageThisAsset (node_modules/@aws-cdk/core/lib/asset-staging.ts:194:35)
        at Cache.obtain (node_modules/@aws-cdk/core/lib/private/cache.ts:24:13)
        at new AssetStaging (node_modules/@aws-cdk/core/lib/asset-staging.ts:219:44)
        at new Asset (node_modules/@aws-cdk/aws-s3-assets/lib/asset.ts:127:21)
        at AssetCode.bind (node_modules/@aws-cdk/aws-lambda/lib/code.ts:277:20)
        at new Function (node_modules/@aws-cdk/aws-lambda/lib/function.ts:583:29)
        at new PythonFunction (node_modules/@aws-cdk/aws-lambda-python/lib/function.ts:106:5)
        at new IteratorLambda (src/cdk-lambda-subminute.ts:66:21)
        at new LambdaSubminute (src/cdk-lambda-subminute.ts:25:22)
        at Object.<anonymous>.test (test/integ.test.ts:23:3)
  ```

  I actually have tried many different methods according to the following threads but to no avail.  I'll attempt to test some thoughts or just post the issue onto the CDK Github repo.

  * [Asset Bundling](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-s3-assets-readme.html#asset-bundling)
  * [Change the bundler's /asset-output local volume mount location #8589](https://github.com/aws/aws-cdk/issues/8589)
  * [(aws-lambda-python: PythonFunction): unable to use bundling in BitBucket #14156](https://github.com/aws/aws-cdk/issues/14516)
  * [BundlingDockerImage.cp() needs to be explained more in the README #11914](https://github.com/aws/aws-cdk/issues/11914)


pkgId: 35d44c2cf3fa1e572db0be47700f92796a4eb986f47e2ad618458f8be69f4a0c
name: python-cdk-secret-manager-wrapper-layer-help
arch: noarch
version: 2.0.793
epoch: 0
release: 1
summary: Development documents and examples for cdk-secret-manager-wrapper-layer
url: https://github.com/neilkuan/cdk-secret-manager-wrapper-layer.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-secret-manager-wrapper-layer-2.0.793-1.src.rpm
location_href: Packages/python-cdk-secret-manager-wrapper-layer-help-2.0.793-1.noarch.rpm
checksum_type: sha256
description:
  that Lambda layer uses a wrapper script to fetch information from Secrets Manager and create environmental variables.

  > idea from [source](https://github.com/aws-samples/aws-lambda-environmental-variables-from-aws-secrets-manager)



  ```python
  import { App, Stack, CfnOutput, Duration } from 'aws-cdk-lib';
  import { Effect, PolicyStatement } from 'aws-cdk-lib/aws-iam';
  import { Function, Runtime, Code, FunctionUrlAuthType } from 'aws-cdk-lib/aws-lambda';
  import { CfnSecret } from 'aws-cdk-lib/aws-secretsmanager';
  import { SecretManagerWrapperLayer } from 'cdk-secret-manager-wrapper-layer';
  const env = {
    region: process.env.CDK_DEFAULT_REGION,
    account: process.env.CDK_DEFAULT_ACCOUNT,
  };
  const app = new App();
  const stack = new Stack(app, 'testing-stack', { env });

  /**
   * Example create an Secret for testing.
   */
  const secret = new CfnSecret(stack, 'Mysecret', {
    secretString: JSON.stringify({
      KEY1: 'VALUE1',
      KEY2: 'VALUE2',
      KEY3: 'VALUE3',
    }),
  });

  const layer = new SecretManagerWrapperLayer(stack, 'SecretManagerWrapperLayer');

  const lambda = new Function(stack, 'fn', {
    runtime: Runtime.PYTHON_3_9,
    code: Code.fromInline(`
  import os
  def hander(events, contexts):
      env = {}
      env['KEY1'] = os.environ.get('KEY1', 'Not Found')
      env['KEY2'] = os.environ.get('KEY2', 'Not Found')
      env['KEY3'] = os.environ.get('KEY3', 'Not Found')
      return env
      `),
    handler: 'index.hander',
    layers: [layer],
    timeout: Duration.minutes(1),
    /**
     * you need to define this 4 environment various.
     */
    environment: {
      AWS_LAMBDA_EXEC_WRAPPER: '/opt/get-secrets-layer',
      SECRET_REGION: stack.region,
      SECRET_ARN: secret.ref,
      API_TIMEOUT: '5000',
    },
  });

  /**
   * Add Permission for lambda get secret value from secret manager.
   */
  lambda.role!.addToPrincipalPolicy(
    new PolicyStatement({
      effect: Effect.ALLOW,
      actions: ['secretsmanager:GetSecretValue'],
      // Also you can use find from context.
      resources: [secret.ref],
    }),
  );

  /**
   * For Testing.
   */
  const FnUrl = lambda.addFunctionUrl({
    authType: FunctionUrlAuthType.NONE,
  });

  new CfnOutput(stack, 'FnUrl', {
    value: FnUrl.url,
  });
  ```



  ```bash

  curl ${FnUrl}
  {"KEY2":"VALUE2","KEY1":"VALUE1","KEY3":"VALUE3"}
  ```


pkgId: 6c03a1d6e00549412c7e661e30845412f1ee822426cb20fba564aebcceda89e7
name: python-cdk-serverless-clamscan-help
arch: noarch
version: 2.9.40
epoch: 0
release: 1
summary: Development documents and examples for cdk-serverless-clamscan
url: https://github.com/awslabs/cdk-serverless-clamscan
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-serverless-clamscan-2.9.40-1.src.rpm
location_href: Packages/python-cdk-serverless-clamscan-help-2.9.40-1.noarch.rpm
checksum_type: sha256
description:
  [![npm version](https://badge.fury.io/js/cdk-serverless-clamscan.svg)](https://badge.fury.io/js/cdk-serverless-clamscan)
  [![PyPI version](https://badge.fury.io/py/cdk-serverless-clamscan.svg)](https://badge.fury.io/py/cdk-serverless-clamscan)

  An [aws-cdk](https://github.com/aws/aws-cdk) construct that uses [ClamAV®](https://www.clamav.net/) to scan newly uploaded objects to Amazon S3 for viruses. The construct provides a flexible interface for a system to act based on the results of a ClamAV virus scan. Check out this [blogpost](https://aws.amazon.com/blogs/developer/virus-scan-s3-buckets-with-a-serverless-clamav-based-cdk-construct/) for a guided walkthrough.

  ![Overview](serverless-clamscan.png)



  **Docker:** The ClamAV Lambda functions utilizes a [container image](https://aws.amazon.com/blogs/aws/new-for-aws-lambda-container-image-support/) that is built locally using [docker bundling](https://aws.amazon.com/blogs/devops/building-apps-with-aws-cdk/)



  This project uses [projen](https://github.com/projen/projen) and thus all the constructs follow language specific standards and naming patterns. For more information on how to translate the following examples into your desired language read the CDK guide on [Translating TypeScript AWS CDK code to other languages](https://docs.aws.amazon.com/cdk/latest/guide/multiple_languages.html)



  <details><summary>typescript</summary>
  <p>

  ```python
  import { RuleTargetInput } from 'aws-cdk-lib/aws-events';
  import { SnsTopic } from 'aws-cdk-lib/aws-events-targets';
  import { Bucket } from 'aws-cdk-lib/aws-s3';
  import { Topic } from 'aws-cdk-lib/aws-sns';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import { ServerlessClamscan } from 'cdk-serverless-clamscan';

  export class CdkTestStack extends Stack {
    constructor(scope: Construct, id: string, props?: StackProps) {
      super(scope, id, props);

      const bucket_1 = new Bucket(this, 'rBucket1');
      const bucket_2 = new Bucket(this, 'rBucket2');
      const bucketList = [bucket_1, bucket_2];
      const sc = new ServerlessClamscan(this, 'rClamscan', {
        buckets: bucketList,
      });
      const bucket_3 = new Bucket(this, 'rBucket3');
      sc.addSourceBucket(bucket_3);
      const infectedTopic = new Topic(this, 'rInfectedTopic');
      sc.infectedRule?.addTarget(
        new SnsTopic(infectedTopic, {
          message: RuleTargetInput.fromEventPath(
            '$.detail.responsePayload.message',
          ),
        }),
      );
    }
  }
  ```

  </p>
  </details><details><summary>python</summary>
  <p>

  ```python
  from aws_cdk import (
    Stack,
    aws_events as events,
    aws_events_targets as events_targets,
    aws_s3 as s3,
    aws_sns as sns
  )
  from cdk_serverless_clamscan import ServerlessClamscan
  from constructs import Construct

  class CdkTestStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
      super().__init__(scope, construct_id, **kwargs)

      bucket_1 = s3.Bucket(self, "rBucket1")
      bucket_2 = s3.Bucket(self, "rBucket2")
      bucketList = [ bucket_1, bucket_2 ]
      sc = ServerlessClamscan(self, "rClamScan",
        buckets=bucketList,
      )
      bucket_3 = s3.Bucket(self, "rBucket3")
      sc.add_source_bucket(bucket_3)
      infected_topic = sns.Topic(self, "rInfectedTopic")
      if sc.infected_rule != None:
        sc.infected_rule.add_target(
          events_targets.SnsTopic(
            infected_topic,
            message=events.RuleTargetInput.from_event_path('$.detail.responsePayload.message'),
          )
        )
  ```

  </p>
  </details>



  <details><summary>typescript</summary>
  <p>

  ```python
  import {
    SqsDestination,
    EventBridgeDestination,
  } from 'aws-cdk-lib/aws-lambda-destinations';
  import { Bucket } from 'aws-cdk-lib/aws-s3';
  import { Queue } from 'aws-cdk-lib/aws-sqs';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import { ServerlessClamscan } from 'cdk-serverless-clamscan';

  export class CdkTestStack extends Stack {
    constructor(scope: Construct, id: string, props?: StackProps) {
      super(scope, id, props);

      const bucket_1 = new Bucket(this, 'rBucket1');
      const bucket_2 = new Bucket(this, 'rBucket2');
      const bucketList = [bucket_1, bucket_2];
      const queue = new Queue(this, 'rQueue');
      const sc = new ServerlessClamscan(this, 'default', {
        buckets: bucketList,
        onResult: new EventBridgeDestination(),
        onError: new SqsDestination(queue),
      });
      const bucket_3 = new Bucket(this, 'rBucket3');
      sc.addSourceBucket(bucket_3);
    }
  }
  ```

  </p>
  </details><details><summary>python</summary>
  <p>

  ```python
  from aws_cdk import (
    Stack,
    aws_lambda_destinations as lambda_destinations,
    aws_s3 as s3,
    aws_sqs as sqs
  )
  from cdk_serverless_clamscan import ServerlessClamscan
  from constructs import Construct

  class CdkTestStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
      super().__init__(scope, construct_id, **kwargs)

      bucket_1 = s3.Bucket(self, "rBucket1")
      bucket_2 = s3.Bucket(self, "rBucket2")
      bucketList = [ bucket_1, bucket_2 ]
      queue = sqs.Queue(self, "rQueue")
      sc = ServerlessClamscan(self, "rClamScan",
        buckets=bucketList,
        on_result=lambda_destinations.EventBridgeDestination(),
        on_error=lambda_destinations.SqsDestination(queue),
      )
      bucket_3 = s3.Bucket(self, "rBucket3")
      sc.add_source_bucket(bucket_3)
  ```

  </p>
  </details>



  When ClamAV publishes updates to the scanner you will see “Your ClamAV installation is OUTDATED” in your scan results. While the construct creates a system to keep the database definitions up to date, you must update the scanner to detect all the latest Viruses.

  Update the docker images of the Lambda functions with the latest version of ClamAV by re-running `cdk deploy`.



  See [API.md](./API.md).



  See [CONTRIBUTING](./CONTRIBUTING.md) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: d05841cff213ea57bbe5b0e0349c96bdd52dfe80e8aaa85bdfe52d399655a5f8
name: python-cdk-skylight-help
arch: noarch
version: 1.1.647
epoch: 0
release: 1
summary: Development documents and examples for cdk-skylight
url: https://github.com/cdklabs/cdk-skylight.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-skylight-1.1.647-1.src.rpm
location_href: Packages/python-cdk-skylight-help-1.1.647-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/badge/CDK%20Skylight-Developer%20Preview-orange.svg?style=for-the-badge)



  CDK Skylight is a set of **Level 3 constructs** for the [Microsoft products on AWS](https://aws.amazon.com/windows/) ecosystem (Windows OS, SQL Server, Active Directory, Windows Containers, Amazon FSx for Windows, and so on). **CDK Skylight Constructs are a natural fit for Platform Teams building Platform as a Product.**

  A few examples are:

  1. Windows Worker with Domain join and Powershell API that allows running complex automation with a single line of code
  2. Managed Active Directory configured with DNS Topology and an API to create new AD Group with a domain-joined machine.
  3. Amazon FSx library that creates Filesystem with API to create Folder on it
  4. Windows EKS Workers that joins to specified AD domain with APIs to create and configure complex integrations such as SMB with Global Mapping and Domain authentication with gMSA plugin.

  All those examples are built with CDK Skylight libraries and can be used separately with maximum flexibility to change the default settings.

  CDK Skylight is set to address repetitive tasks and best practices involved with managing, deploying, and integrating those apps. In addition to the complexity of integrating the AWS side products, Microsoft technologies such as SQL, AD, Windows OS require OS-level integration and optimization. Skylight help in both the "AWS-side" and the "OS-side," offering a complete end-to-end configuration and integration solution of AWS products.



  The primary persona to use CDK Skylight is the platform team owners to customize the stacks and provide them to the application owners teams.

  As a vision, Project CDK-Skylight targets all Windows EC2 customers in all stages, specifically developers developing features integrated with the Microsoft-products ecosystem (SQL Server, Active Directory, Windows OS, etc.)



  CDK Skylight helps in all application lifecycle stages, starting from the developer machine to running production workloads. With CDK Skylight, the time it takes to move between stages and integrate new services is reduced dramatically.



  ```bash
  npm install cdk-skylight
  ```

  In your CDK App

  ```python
  import * as skylight from "cdk-skylight";

  new skylight.authentication.AwsManagedMicrosoftAdR53(scope: Construct, id: string, props: IAwsManagedMicrosoftAdProps)
  ```





  Library of Custom Compute components



  A Domain Windows Node Construct represents one Windows EC2 instance configured with Active Directory.

  The DomainWindowsNode can be customized to different instance sizes and additional permissions set just like any other EC2 Instance.
  You can use this construct to run elevated domain tasks with domain permissions or run your application in a single instance setup.

  The machine will be joined to the provided Active Directory domain using a custom CloudFormation bootstrap that will wait until the required reboot to join the domain. Then it will register the machine in SSM and pull tasks from the SSM State manager.

  You can send tasks to that machine using the provided methods: runPsCommands() and runPSwithDomainAdmin()

  ```python
  const windowsNodeObject = new skylight.compute.DomainWindowsNode(
    stack,
    'WindowsNode',
    {
      vpc: vpc,
      madSsmParameters: {}, //pointer to the Secret that holds the Domain Admin username and password
    }
  );

  // Special Methods:
  windowsNodeObject.runPsCommands(['echo hello-world'], 'hello');
  windowsNodeObject.runPSwithDomainAdmin(
    ['Write-Host hello-world'],
    'hello-withPS'
  );
  windowsNodeObject.openRDP('1.1.1.1/32');
  ```



  Library of Custom Authentication components



  Managed AD with Secret stored in secret manager

  The secret saved to SSM parameter store so others can use it with other Constructs (Such as Windows node or FSx)
  The provided VPC or the new created VPC will be configured to forward DNS requests to the Managed AD with Route53 Resolvers

  The construct also creates (optionally) t3.nano machine that is part of the domain that can be used to run admin-tasks (such as createADGroup)
  The createADGroup() method creates an Active Directory permission group in the domain, using the domain admin user.

  Please note: When calling createADGroup() API, a Lambda will be created to start the worker machine (Using AWS-SDK),
  then each command will be scheduled with State Manager, and the instance will be shut down after complete.

  ```python
  const ad = new skylight.authentication.AwsManagedMicrosoftAd(
    stack,
    'AwsManagedMicrosoftAdR53',
    {
      vpc: vpc,
      edition: 'Enterprise', // Optional
      secret: new Secret(stack, 'test-secret'), // Optional
      domainName: 'test-domain', // Optional
      secretName: 'custom-secret-name', // Optional
      createWorker: false, // Optional
    }
  );
  ad.managedActiveDirectory.createADGroup(
    'MyADGroup', // AD group name
    'My AD Group Created by CDK-Skylight!' //AD Description
  );
  ```



  AwsManagedMicrosoftAdR53 represents an integration pattern of Managed AD and Route 53 Resolver in a specific VPC, it will create Managed AD with the provided Secret (Secrets Manager) or generates a new Secret.

  Example:

  ```python
  const ad = new skylight.authentication.AwsManagedMicrosoftAdR53(
    stack,
    'AwsManagedMicrosoftAdR53',
    {
      vpc: vpc,
    }
  );
  ```





  A FSxWindows represents an integration pattern of Amazon FSx and Managed AD in a specific VPC.
  The Construct creates Amazon FSx for Windows

  The construct also creates t3.nano machine that is part of the domain that can be used to run admin-tasks (such as createFolder)
  The createFolder() method creates an SMB Folder in the FSx filesystem, using the domain admin user.

  Please note: When calling createFolder() API, a Lambda will be created to start the worker machine (Using AWS-SDK), then each command will be scheduled with State Manager, and the instance will be shut down after complete.

  Example:

  ```python
  this.fsxWindows = new skylight.storage.FSxWindows(this, 'FSx', {
    vpc: vpc,
    adParametersStore: adParametersStore,
  });
  this.fsxWindows.createFolder('myFolderStorageOnFSx');
  ```





  The stack creates the Windows Autoscaling group with domain join script and the SSM Documents for gMSA and Global Mapping.



  ```python
  const cluster = new WindowsEKSCluster(stack, 'ElasticCluster', {
    vpc: new aws_ec2.Vpc(stack, 'MyVpc', {}),
  }); // Creates EKS Cluster with Windows support
  ```



  This stack takes the PersistentStorage stack as input and creates the EKS cluster with permissions to operate EKS clusters.

  ```python
  const myNodes = new WindowsEKSNodes(stack, 'WindowsEKSNodes', {
    // Creates AutoScaling group for Windows Support
    vpc: new aws_ec2.Vpc(stack, 'MyVpc', {}),
  });

  myNodes.addAdDependency(secretObject);
  myNodes.addStorageDependency(secretObject, storageMount);
  myNodes.addEKSDependency(eks_cluster.eksCluster);
  myNodes.addLocalCredFile(secretObject, 'myEKSNodes', 'myWebApp');
  ```


pkgId: dc9a3c1cb8d77f82318d07efa4d852e0186e69c85ff4b573e8918430921174e7
name: python-cdk-sops-secrets-help
arch: noarch
version: 1.15.2
epoch: 0
release: 1
summary: Development documents and examples for cdk-sops-secrets
url: https://constructs.dev/packages/cdk-sops-secrets
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-sops-secrets-1.15.2-1.src.rpm
location_href: Packages/python-cdk-sops-secrets-help-1.15.2-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://github.com/dbsystel/cdk-sops-secrets/blob/main/img/banner-dl-small.png?raw=true">
  <p/>

  ![stability](https://img.shields.io/badge/Stability-stable-green) 
  [![release](https://github.com/dbsystel/cdk-sops-secrets/actions/workflows/release.yml/badge.svg)](https://github.com/dbsystel/cdk-sops-secrets/actions/workflows/release.yml)<br>

  [![cdk-construct-hub](https://img.shields.io/badge/CDK-ConstructHub-blue)](https://constructs.dev/packages/cdk-sops-secrets)<br>
  [![npm](https://img.shields.io/npm/v/cdk-sops-secrets.svg)](https://www.npmjs.com/package/cdk-sops-secrets) 
  [![npm downloads](https://img.shields.io/npm/dw/cdk-sops-secrets)](https://www.npmjs.com/package/cdk-sops-secrets)<br>
  [![pypi](https://img.shields.io/pypi/v/cdk-sops-secrets.svg)](https://pypi.org/project/cdk-sops-secrets) 
  [![pypi downloads](https://img.shields.io/pypi/dw/cdk-sops-secrets)](https://pypi.org/project/cdk-sops-secrets)<br>

  [![codecov](https://codecov.io/gh/dbsystel/cdk-sops-secrets/branch/main/graph/badge.svg?token=OT7P7HQHXB)](https://codecov.io/gh/dbsystel/cdk-sops-secrets)  
  [![security-vulnerabilities](https://img.shields.io/github/issues-search/dbsystel/cdk-sops-secrets?color=%23ff0000&label=security-vulnerabilities&query=is%3Aissue%20is%3Aopen%20label%3A%22Mend%3A%20dependency%20security%20vulnerability%22)](https://github.com/dbsystel/cdk-sops-secrets/issues?q=is%3Aissue+is%3Aopen+label%3A%22security+vulnerability%22) 



  This construct library provides a replacement for CDK SecretsManager secrets, with extended functionality for Mozilla/sops.

  <p/><center><img src="img/flow.drawio.svg"></center><p/>
  Using this library it is possible to populate Secrets with values from a Mozilla/sops file without additional scripts and steps in the CI stage. Thereby transformations like JSON conversion of YAML files and transformation into a flat, JSONPath like structure will be performed, but can be disabled.

  Secrets filled in this way can be used immediately within the CloudFormation stack and dynamic references. This construct should handle all dependencies, if you use the `secretValueFromJson()` or `secretValue()` call to access secret values.

  This way, secrets can be securely stored in git repositories and easily synchronized into AWS SecretsManager secrets.



  You can consider this package as stable. Updates will follow [Semantic Versioning](https://semver.org/).<br>
  Nevertheless, I would recommend pinning the exact version of this library in your `package.json`.



  * [AWS](https://aws.amazon.com/): I think you already knew it, but this construct will only work with an AWS account.

  * [KMS Key](https://aws.amazon.com/kms/?nc1=h_ls): It makes most sense to encrypt your secrets with AWS KMS if you want to sync and use the secret content afterwards in your AWS account.
  * [mozilla/sops](https://github.com/mozilla/sops): This construct assumes that you store your secrets encrypted via sops in your git repository.
  * [CDK](https://aws.amazon.com/cdk/?nc1=h_ls): As this is a CDK construct, it's only useful if you use the CloudDevelopmentToolkit.



  1. Create a Mozilla/sops secrets file (encrypted with an already existing KMS key) and place it somewhere in your git repository
  2. Create a secret with the SopsSecret construct inside your app

     ```python
     const secret = new SopsSecret(stack, 'SopsComplexSecretJSON', {
       sopsFilePath: 'secets/sopsfile-encrypted.json',
     });
     ```
  3. Optional: Access the secret via dynamic references

     ```python
     secret.secretValueFromJson('json.path.dotted.notation.accessor[0]').toString(),
     ```



  Even if using the main functionality should be done in 3 lines of code, there are more options to configure the constructs of this library. If you want to get an Overview of all available configuration options take a look at the [documentation at the CDK ConstructHub](https://constructs.dev/packages/cdk-sops-secrets).

  The most useful settings will be explained in the further chapters:



  If you have the need to just upload a sops encrypted binary file, just name your sops encrypted file *.binary, or specify the option "binary" as format.

  ```python
  const secret = new SopsSecret(this, 'SopsComplexSecretJSON', {
    ...
    sopsFilePath: 'secrets/sopsfile-encrypted.binary',
  });
  ```

  or

  ```python
  const secret = new SopsSecret(this, 'SopsComplexSecretJSON', {
    ...
    sopsFilePath: 'secrets/sopsfile-encrypted.something',
    sopsFileFormat: 'binary',
  });
  ```



  While creating the secret or updating the entries of a secret, the native CDK function `cdk.FileSystem.fingerprint(...)` is used to generate the version information of the AWS SecretsManager secret.
  Therefore, it is possible to reference the entries from a specific AWS SecretsManager version.

  ```python
  const versionId = cdk.FileSystem.fingerprint(`./sops/SomeSecrets.json`)
  const passphrase = ecs.Secret.fromSecretsManagerVersion(secretMgmt, { versionId: versionId }, 'MY_PRIVATE_PASSPHRASE')

  const container = TaskDef.addContainer('Container', {
     secrets: {
       MY_PRIVATE_PASSPHRASE: passphrase,
     },
  });
  ```



  As default behavior, the SopsSecret (via the SopsSync) will convert all content to JSON and flatten its structure. This is useful, because the AWS SecretsManager has some limitations if it comes to YAML and/or complex objects and decimal values. Even if you can store YAML, complex objects and even binaries in AWS SecretsManager secrets, you can't access their values via the SecretsManager API — you can only return them as is. So accessing (nested) values or values from YAML files won't be possible via [dynamic references](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html) in CloudFormation (and CDK). That's why I decided that conversion to JSON, flatten the structure and stringify all values should be the default behavior. But you can turn off all of these conversion steps:

  ```python
  const secret = new SopsSecret(this, 'SopsComplexSecretJSON', {
    convertToJSON: false, // disable converting the encrypted content to JSON
    stringify: false, // disable stringifying all values
    flatten: false, // disable flattening of the object structure
    sopsFilePath: 'secrets/sopsfile-encrypted.json',
  });
  ```



  Sometimes it can be necessary to access the IAM role of the SopsSync provider. If this is the case, you should create the provider before creating the SopsSecret, and pass the provider to it like this:

  ```python
  // Create the provider
  const provider = new SopsSyncProvider(this, 'CustomSopsSyncProvider');
  // Grant whatever you need to the provider
  const myExtraKmsKey = Key.fromKeyArn(this, 'MyExtraKmsKey', 'YourKeyArn');
  myExtraKmsKey.grantDecrypt(provider);
  // create the secret and pass the the provider to it
  const secret = new SopsSecret(this, 'SopsComplexSecretJSON', {
    sopsProvider: provider,
    secretName: 'myCoolSecret',
    sopsFilePath: 'secrets/sopsfile-encrypted.json',
  });
  ```



  Internally, SopsSync uses a lambda function. In some environments it may be necessary to place this lambda function into a VPC and configure subnets and/or security groups for it.
  This can be done by creating a custom `SopsSyncProvider`, setting the required networking configuration and passing it to the secret like this:

  ```python
  // Create the provider
  const provider = new SopsSyncProvider(this, 'CustomSopsSyncProvider', {
    vpc: myVpc,
    vpcSubnets: subnetSelection,
    securityGroups: [mySecurityGroup],
  });
  // create the secret and pass the the provider to it
  const secret = new SopsSecret(this, 'SopsSecret', {
    sopsProvider: provider,
    secretName: 'myCoolSecret',
    sopsFilePath: 'secrets/sopsfile-encrypted.json',
  });
  ```



  I decided, that the default behavior should be "INLINE" because of the following consideration:

  * Fewer permissions: If we use inline content instead of a S3 asset, the SopsSyncProvider does not need permissions to access the asset bucket and its KMS key.
  * Faster: If we don't have to upload and download things from and to S3, it should be a little faster.
  * Interchangeable: As we use the same information to generate the version of the secret, no new version of the secret should be created, if you change from INLINE to ASSET or vice versa, even if the CloudFormation resource updates.
  * I personally think sops files are not that big, that we should run into limits, but if so — we can change to asset `uploadType`.

  You can change the uplaodType via the properties:

  ```python
  const secret = new SopsSecret(this, 'SopsWithAssetUpload', {
    sopsFilePath: 'secrets/sopsfile-encrypted.json',
    uploadType: UploadType.ASSET, // instead of the default UploadType.INLINE
  });
  ```





  Even if this construct has some unit and integration tests performed, there can be bugs and issues. As everything is performed by a cloudformation custom resource provider, a good starting point is the log of the corresponding lambda function. It should be located in your AWS Account under Cloudwatch -> Log groups:

  `/aws/lambda/<YOUR-STACK-NAME>-SingletonLambdaSopsSyncProvider<SOMETHINGsomething1234>`



  Only very basic dotenv syntax is working right now. Only single line values are accepted. The format must match:

  ```dotenv
  key=value
  ```

  comments must be a single line, not after value assignments.



  This error message (and failed sync) is related to the  mozilla/sops issues [#948](https://github.com/mozilla/sops/issues/948) and [#634](https://github.com/mozilla/sops/issues/634). You must not create your secret with the `--aws-profile` flag. This profile will be written to your sops filed and is required in every runtime environment. You have to define the profile to use via the environment variable `AWS_PROFILE` instead, to avoid this.



  The lambda asset code is generated relative to the path of the index.ts in this package. With tools like nx this can lead to wrong results, so that the asset could not be found.

  You can override the asset path via the [cdk.json](https://docs.aws.amazon.com/cdk/v2/guide/get_context_var.html) or via the flag `-c`of the cdk cli.

  The context used for this override is `sops_sync_provider_asset_path`.

  So for example you can use

  ```bash
  cdk deploy -c "sops_sync_provider_asset_path=some/path/asset.zip"
  ```

  or in your cdk.json

  ```json
  {
    "context": {
      "sops_sync_provider_asset_path": "some/path/asset.zip"
    }
  }
  ```



  That's possible since version 1.8.0. You can reference the file in S3 like:

  ```python
  new SopsSecret(stack, 'SopsSecret', {
    sopsS3Bucket: 'testbucket',
    sopsS3Key: 'secret.json',
    sopsFileFormat: 'json',
    // ...
  });
  ```

  Passing those values as CloudFormation parameters should also be possible:

  ```python

  const sopsS3BucketParam = new CfnParameter(this, "s3BucketName", {
    type: "String",
    description: "The name of the Amazon S3 bucket where your sopsFile was uploaded."});

  const sopsS3KeyParam = new CfnParameter(this, "s3KeyName", {
    type: "String",
    description: "The name of the key of the sopsFile inside the Amazon S3 bucket."});

  new SopsSecret(stack, 'SopsSecret', {
    sopsS3Bucket: sopsS3BucketParam.valueAsString,
    sopsS3Key: sopsS3KeyParam.valueAsString,
    sopsFileFormat: 'json',
    // ...
  });
  ```



  I have created this project to solve a recurring problem of syncing Mozilla/sops secrets into AWS SecretsManager in a convenient, secure way.

  Other than that, or perhaps more importantly, my goal was to learn new things:

  * Write a Golang lambda
  * Writing unit tests incl. mocks in Golang
  * Reproducible builds of Golang binaries (byte-by-byte identical)
  * Build reproducible zips (byte-by-byte identical)
  * Release a NPM package
  * Setting up projects with projen
  * CI/CD with GitHub actions
  * CDK unit and integration tests



  The problem this Construct addresses is so good, already two other implementations exist:

  * [isotoma/sops-secretsmanager-cdk](https://github.com/isotoma/sops-secretsmanager-cdk): Does nearly the same. Uses CustomResource, wraps the sops CLI, does not support flatten. Found it after I published my solution to NPM :-/
  * [taimos/secretsmanager-versioning](https://github.com/taimos/secretsmanager-versioning): Different approach on the same problem. This is a CLI tool with very nice integration into CDK and also handles git versioning information.



  The Apache-2.0 license. Please have a look at the [LICENSE](LICENSE) and [LICENSE-3RD-PARTY](LICENSE-3RD-PARTY).


pkgId: 079873c67b9339860db7d7119748b10141ad7728c761cc9105b6e41c914c8678
name: python-cdk-tweet-queue-help
arch: noarch
version: 2.0.682
epoch: 0
release: 1
summary: Development documents and examples for cdk-tweet-queue
url: https://github.com/cdklabs/cdk-tweet-queue
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-tweet-queue-2.0.682-1.src.rpm
location_href: Packages/python-cdk-tweet-queue-help-2.0.682-1.noarch.rpm
checksum_type: sha256
description:
  This is an [AWS CDK](https://github.com/awslabs/aws-cdk) construct library which
  allows you to get a feed of Twitter search results into an SQS queue. It works
  by periodically polling the freely available [Twitter Standard Search
  API](https://developer.twitter.com/en/docs/tweets/search/api-reference/get-search-tweets.html) and
  sending all new tweets to an SQS queue.

  Inspired by
  [@jlhood](https://github.com/awslabs/aws-serverless-twitter-event-source/commits?author=jlhood)'s
  [aws-serverless-twitter-event-source](https://github.com/awslabs/aws-serverless-twitter-event-source)



  ![](https://github.com/eladb/cdk-tweet-queue/raw/main/images/architecture.png)

  1. A CloudWatch Event Rule triggers the poller AWS Lambda function periodically
  2. The poller reads the last checkpoint from a DynamoDB table (if exists)
  3. The poller issues a Twitter search query for all new tweets
  4. The poller enqueues all tweets to an SQS queue
  5. The poller stores the ID of the last tweet into the DynamoDB checkpoint table.
  6. Rinse & repeat.



  To issue a Twitter search request, you will need to
  [apply](https://developer.twitter.com/en/apply-for-access.html) for a Twitter
  developer account, and obtain API keys through by defining a [new
  application](http://twitter.com/oauth_clients/new).

  The Twitter API keys are read by the poller from an [AWS Secrets
  Manager](https://aws.amazon.com/secrets-manager/) entry. The entry must contain
  the following attributes: `consumer_key`, `consumer_secret`, `access_token_key`
  and `access_token_secret` (exact names).

  1. Create a new AWS Secrets Manager entry for your API keys
  2. Fill in the key values as shown below:
     ![](https://github.com/eladb/cdk-tweet-queue/raw/main/images/secretsmanager.png)
  3. Store the key
  4. Obtain the ARN of the secret (you will need it soon).



  Use `npm` to install the module in your CDK project. This will also add it to
  your `package.json` file.

  ```console
  $ npm install cdk-tweet-queue
  ```

  Add a `TweetQueue` to your CDK stack:

  ```python
  import { TweetQueue } from 'cdk-tweet-queue';

  const queue = new TweetQueue(this, 'TweetStream', {
    // this is the ARN of the secret you stored
    secretArn: 'arn:aws:secretsmanager:us-east-1:1234567891234:secret:xxxxxxxxx'

    // twitter search query
    // see https://developer.twitter.com/en/docs/tweets/search/guides/standard-operators
    query: '#awscdk',

    // optional properties
    intervalMin: 60,          // optional: polling interval in minutes
    retentionPeriodSec: 60,   // optional: queue retention period
    visibilityTimeoutSec: 60, // optional: queue visilibity timeout
  });
  ```

  Now, `queue` is an `sqs.Queue` object and can be used anywhere a queue is
  accepted. For example, you could process the queue messages using an AWS Lambda
  function by setting up an SQS event source mapping.



  The project is managed by [projen](https://github.com/projen/projen) and offers the following commands:

  * `yarn projen` - Synthesize the project configuration.
  * `yarn compile` - Compile all source code.
  * `yarn test` - Run all tests.
  * `yarn build` - Complie, test, and package the module.



  There is also an integration test that can be executed by running the following commands. You will need to set the `TWEET_QUEUE_SECRET_ARN` environment variable in order for the test to be able to use your Twitter API keys.

  ```console
  $ yarn integ:deploy
  ```

  Don't forget to destroy:

  ```console
  $ yarn integ:destroy
  ```

  You can also run any cdk command on the integration test application by running:

  ```console
  yarn integ <command>
  ```



  Apache-2.0


pkgId: 540f580796f6a44105abaa06385044e23e3b562b0a2c741dc1b6179f8c00de6a
name: python-cdk-vpc-module-help
arch: noarch
version: 0.0.12
epoch: 0
release: 1
summary: Development documents and examples for cdk-vpc-module
url: https://github.com/smallcase/cdk-vpc-module.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk-vpc-module-0.0.12-1.src.rpm
location_href: Packages/python-cdk-vpc-module-help-0.0.12-1.noarch.rpm
checksum_type: sha256
description:
  cdk-vpc-module construct library is an open-source extension of the AWS Cloud Development Kit (AWS CDK) to deploy configurable aws vpc  and its individual components in less than 50 lines of code and human readable configuration which can be managed by pull requests!



  * :white_check_mark: Option to configure custom IPv4 CIDR(10.10.0.0/24)
  * :white_check_mark: VPC Peering with  route table entry
  * :white_check_mark: Configurable NACL as per subnet group
  * :white_check_mark: NATGateway as per availabilityZones

  Using cdk a vpc can be deployed using the following sample code snippet:

  ```python
  import { Network } from "@smallcase/cdk-vpc-module/lib/constructs/network";
  import { aws_ec2 as ec2, App, Stack, StackProps } from "aws-cdk-lib";
  import { Construct } from "constructs";

  export class VPCStack extends Stack {
    constructor(scope: Construct, id: string, props: StackProps = {}) {
      const s3EndpointIamPermission = new iam.PolicyStatement({
        actions: ["s3:*"],
        resources: ['arn:aws:s3:::*'],
        principals: [new iam.AnyPrincipal()],
      })
      const monitoringEndpointIamPermission = new iam.PolicyStatement({
        actions: ["*"],
        resources: ['*'],
        principals: [new iam.AnyPrincipal()],
      })
      super(scope, id, props);
      new Network(this, 'NETWORK', {
        vpc: {
          cidr: '10.10.0.0/16',
          subnetConfiguration: [],
        },
        peeringConfigs: {
          "TEST-PEERING": { // this key will be used as your peering id, which you will have to mention below when you configure a route table for your subnets
            peeringVpcId: "vpc-0000",
            tags: {
              "Name": "TEST-PEERING to CREATED-VPC",
              "Description": "Connect"
            }
          }
        },
        subnets: [
          {
            subnetGroupName: 'NATGateway',
            subnetType: ec2.SubnetType.PUBLIC,
            cidrBlock: ['10.10.0.0/28', '10.10.0.16/28', '10.10.0.32/28'],
            availabilityZones: ['ap-south-1a', 'ap-south-1b', 'ap-south-1c'],
            ingressNetworkACL: [
              {
                cidr: ec2.AclCidr.ipv4('0.0.0.0/0'),
                traffic: ec2.AclTraffic.allTraffic(),
              },
            ],
            routes: [
            ],
            egressNetworkACL: [
              {
                cidr: ec2.AclCidr.ipv4('0.0.0.0/0'),
                traffic: ec2.AclTraffic.allTraffic(),
              },
            ],
          },
          {
            subnetGroupName: 'Public',
            subnetType: ec2.SubnetType.PUBLIC,
            cidrBlock: ['10.10.2.0/24', '10.10.3.0/24', '10.10.4.0/24'],
            availabilityZones: ['ap-south-1a', 'ap-south-1b', 'ap-south-1c'],
            ingressNetworkACL: [
              {
                cidr: ec2.AclCidr.ipv4('0.0.0.0/0'),
                traffic: ec2.AclTraffic.allTraffic(),
              },
            ],
            egressNetworkACL: [
              {
                cidr: ec2.AclCidr.ipv4('0.0.0.0/0'),
                traffic: ec2.AclTraffic.allTraffic(),
              },
            ],
            routes: [
            ],
            tags: {
              // if you use this vpc for your eks cluster, you have to tag your subnets [read more](https://aws.amazon.com/premiumsupport/knowledge-center/eks-vpc-subnet-discovery/)
              'kubernetes.io/role/elb': '1',
              'kubernetes.io/cluster/TEST-CLUSTER': 'owned',
            },
          },
          {
            subnetGroupName: 'Private',
            subnetType: ec2.SubnetType.PRIVATE_WITH_NAT,
            cidrBlock: ['10.10.5.0/24', '10.10.6.0/24', '10.10.7.0/24'],
            availabilityZones: ['ap-south-1a', 'ap-south-1b', 'ap-south-1c'],
            ingressNetworkACL: [
              {
                cidr: ec2.AclCidr.ipv4('0.0.0.0/0'),
                traffic: ec2.AclTraffic.allTraffic(),
              },
            ],
            egressNetworkACL: [
              {
                cidr: ec2.AclCidr.ipv4('0.0.0.0/0'),
                traffic: ec2.AclTraffic.allTraffic(),
              },

            ],
            routes: [
              {
              // if you use this vpc for your eks cluster, you have to tag your subnets [read more](https://aws.amazon.com/premiumsupport/knowledge-center/eks-vpc-subnet-discovery/)
                routerType: ec2.RouterType.VPC_PEERING_CONNECTION,
                destinationCidrBlock: "<destinationCidrBlock>",
                //<Your VPC PeeringConfig KEY, in this example TEST-PEERING will be your ID>
                existingVpcPeeringRouteKey: "TEST-PEERING"
              }
            ],
            tags: {
              'kubernetes.io/role/internal-elb': '1',
              'kubernetes.io/cluster/TEST-CLUSTER': 'owned',
            },
          },
          {
            subnetGroupName: 'Database',
            subnetType: ec2.SubnetType.PRIVATE_WITH_NAT,
            cidrBlock: ['10.10.14.0/27', '10.10.14.32/27', '10.10.14.64/27'],
            availabilityZones: ['ap-south-1a', 'ap-south-1b', 'ap-south-1c'],
            ingressNetworkACL: [
              {
                cidr: ec2.AclCidr.ipv4('0.0.0.0/0'),
                traffic: ec2.AclTraffic.allTraffic(),
              },
            ],
            egressNetworkACL: [
              {
                cidr: ec2.AclCidr.ipv4('0.0.0.0/0'),
                traffic: ec2.AclTraffic.allTraffic(),
              },
            ],
            routes: [
            ],
            tags: {
            },
          },
        ],
        vpcEndpoints: [
          {
            name: "s3-gw",
            service: ec2.GatewayVpcEndpointAwsService.S3,
            subnetGroupNames: ["Private","Database"],
            externalSubnets: [
              {
                id: "subnet-<id>",
                availabilityZone: "ap-south-1a",
                routeTableId: "rtb-<id>"
              },
              {
                id: "subnet-<id>",
                availabilityZone: "ap-south-1b",
                routeTableId: "rtb-<id>"
              }
            ],
            iamPolicyStatements: [s3EndpointIamPermission]
          },
          {
            name: "da-stag-monitoring-vpe",
            service: ec2.InterfaceVpcEndpointAwsService.CLOUDWATCH_MONITORING,
            subnetGroupNames: ["ManageServicePrivate"],
            iamPolicyStatements: [monitoringEndpointIamPermission],
            securityGroupRules: [
              {
                peer: ec2.Peer.ipv4("10.10.0.0/16"),
                port:  ec2.Port.tcp(443),
                description: "From Test VPC"
              }
            ],
          },
        ]
      });
    }
  }
  const envDef = {
    account: '<AWS-ID>',
    region: '<AWS-REGION>',
  };

  const app = new App();

  new VPCStack(app, 'TEST', {
    env: envDef,
    terminationProtection: true,
    tags: {
  });
  app.synth();
  ```

  Please refer [here](/API.md) to check how to use individual resource constructs.



  The quick start shows you how to create an **AWS-VPC** using this module.



  * A working [`aws`](https://aws.amazon.com/cli/) CLI installation with access to an account and administrator privileges
  * You'll need a recent [NodeJS](https://nodejs.org) installation

  To get going you'll need a CDK project. For details please refer to the [detailed guide for CDK](https://docs.aws.amazon.com/cdk/latest/guide/hello_world.html).

  Create an empty directory on your system.

  ```bash
  mkdir aws-quick-start-vpc && cd aws-quick-start-vpc
  ```

  Bootstrap your CDK project, we will use TypeScript, but you can switch to any other supported language.

  ```bash
  npx cdk init sample-vpc  --language typescript
  npx cdk bootstrap
  ```

  Install using NPM:

  ```
  npm install @smallcase/cdk-vpc-module
  ```

  Using yarn

  ```
  yarn add @smallcase/cdk-vpc-module
  ```

  Check the changed which are to be deployed

  ```bash
  ~ -> npx cdk diff
  ```

  Deploy using

  ```bash
  ~ -> npx cdk deploy
  ```

  Features
  Multiple VPC Endpoints: Define and manage multiple VPC Endpoints in one configuration.
  Flexible Subnet Selection: Attach VPC Endpoints to multiple subnet groups or external subnets.
  Custom Security Groups: Configure security groups for Interface VPC Endpoints.
  IAM Policies: Attach custom IAM policies to control access to the VPC Endpoints.
  Tagging: Apply custom tags to each VPC Endpoint.

  Defining VPC Endpoints Configuration
  You can define multiple VPC Endpoints in the vpcEndpoints: [] configuration array. Each VPC Endpoint can be customized with different subnet groups, IAM policies, security group rules, and tags.

  ```
  vpcEndpoints: [
    {
      name: "test-s3-gw",
      service: ec2.GatewayVpcEndpointAwsService.S3,
      subnetGroupNames: ["ManageServicePrivate", "ToolPrivate", "Database"],  // Subnet groups for the endpoint
      externalSubnets: [
        {
          id: "subnet-<id>",
          availabilityZone: "ap-south-1a",
          routeTableId: "rtb-<id>",
        },
        {
          id: "subnet-<id>",
          availabilityZone: "ap-south-1b",
          routeTableId: "rtb-<id>",
        }
      ],
      iamPolicyStatements: [s3EndpointIamPermission],  // Custom IAM policy for the endpoint
    },
    {
      name: "DynamoDbGatewayEndpoint",
      service: ec2.GatewayVpcEndpointAwsService.DYNAMODB,
      subnetGroupNames: ["private-subnet"],
      additionalTags: {
        Environment: "Staging",
      },
    },
  ],
  ```

  In this example:

  The S3 Gateway Endpoint is created in three subnet groups: ManageServicePrivate, ToolPrivate, and Database.
  External subnets are specified with their IDs, availability zones, and route table IDs for the S3 endpoint.
  A custom IAM policy (s3EndpointIamPermission) is attached to control access to the S3 endpoint.
  A DynamoDB Gateway Endpoint is created in the private-subnet with additional tags specifying the environment and ownership.

  Configuration Options
  Here’s a breakdown of the configuration options available:

  1. name: A unique name for the VPC Endpoint.
  2. service: The AWS service the VPC Endpoint connects to (e.g., S3, DynamoDB, Secrets Manager)
  3. subnetGroupNames: The subnet group names where the VPC Endpoint will be deployed.
  4. externalSubnets: Specify external subnets if you need to define subnets manually (each with an id, availabilityZone, and routeTableId).
  5. iamPolicyStatements: (Optional) Attach IAM policy statements to control access to the endpoint.
  6. additionalTags: (Optional) Add custom tags to the VPC Endpoint for easier identification and tracking.


pkgId: 7fd08a94c78b55a816ce5f44881b9f42a154d15892f079ce9a5f52a22c61b180
name: python-cdk8s-awscdk-resolver-help
arch: noarch
version: 0.0.214
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-awscdk-resolver
url: https://github.com/cdk8s-team/cdk8s-awscdk-resolver.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-awscdk-resolver-0.0.214-1.src.rpm
location_href: Packages/python-cdk8s-awscdk-resolver-help-0.0.214-1.noarch.rpm
checksum_type: sha256
description:
  The `AwsCdkResolver` is able to resolve any [`CfnOutput`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)
  defined by your AWS CDK application. In this example, we create an S3 `Bucket` with the AWS CDK, and pass its (deploy time generated)
  name as an environment variable to a Kubernetes `CronJob` resource.

  ```python
  import * as aws from 'aws-cdk-lib';
  import * as k8s from 'cdk8s';
  import * as kplus from 'cdk8s-plus-27';

  import { AwsCdkResolver } from '@cdk8s/awscdk-resolver';

  const awsApp = new aws.App();
  const stack = new aws.Stack(awsApp, 'aws');

  const k8sApp = new k8s.App({ resolvers: [new AwsCdkResolver()] });
  const manifest = new k8s.Chart(k8sApp, 'Manifest');

  const bucket = new aws.aws_s3.Bucket(stack, 'Bucket');
  const bucketName = new aws.CfnOutput(stack, 'BucketName', {
    value: bucket.bucketName,
  });

  new kplus.CronJob(manifest, 'CronJob', {
    schedule: k8s.Cron.daily(),
    containers: [{
      image: 'job',
      envVariables: {
        // directly passing the value of the `CfnOutput` containing
        // the deploy time bucket name
        BUCKET_NAME: kplus.EnvValue.fromValue(bucketName.value),
      }
   }]
  });

  awsApp.synth();
  k8sApp.synth();
  ```

  During cdk8s synthesis, the custom resolver will detect that `bucketName.value` is not a concrete value,
  but rather a value of a `CfnOutput`. It will then perform AWS service calls in order to fetch the
  actual value from the deployed infrastructure in your account. This means that in order
  for `cdk8s synth` to succeed, it must be executed *after* the AWS CDK resources
  have been deployed. So your deployment workflow should (conceptually) be:

  1. `cdk deploy`
  2. `cdk8s synth`

  > Note that the `AwsCdkResolver` is **only** able to fetch tokens that have a `CfnOutput` defined for them.



  Since running `cdk8s synth` will now require performing AWS service calls, it must have access
  to a set of AWS credentials. Following are the set of actions the credentials must allow:

  * `cloudformation:DescribeStacks`

  Note that the actions cdk8s require are far more scoped down than those normally required for the
  deployment of AWS CDK applications. It is therefore recommended to not reuse the same set of credentials,
  and instead create a scoped down `ReadOnly` role dedicated for cdk8s resolvers.



  As we've seen, your `cdk8s` application needs access to the objects defined in your cloud application. If both applications
  are defined within the same file, this is trivial to achieve. If they are in different files, a simple `import` statement will suffice.
  However, what if the applications are managed in two separate repositories? This makes it a little trickier, but still possible.

  In this scenario, `cdk.ts` in the AWS CDK application, stored in a dedicated repository.

  ```python
  import * as aws from 'aws-cdk-lib';

  const awsApp = new aws.App();
  const stack = new aws.Stack(awsApp, 'aws');

  const bucket = new aws.aws_s3.Bucket(stack, 'Bucket');
  const bucketName = new aws.CfnOutput(stack, 'BucketName', {
    value: bucket.bucketName,
  });

  awsApp.synth();
  ```

  In order for the `cdk8s` application to have cross repository access, the AWS CDK object instances that we want to expose need to be available
  via a package repository. To do this, break up the AWS CDK application into the following files:

  `app.ts`

  ```python
  import * as aws from 'aws-cdk-lib';

  const awsApp = new aws.App();
  const stack = new aws.Stack(awsApp, 'aws');

  const bucket = new aws.aws_s3.Bucket(stack, 'Bucket');
  // export the thing we want to have available for cdk8s applications
  export const bucketName = new aws.CfnOutput(stack, 'BucketName', {
    value: bucket.bucketName,
  });

  // note that we don't call awsApp.synth here
  ```

  `main.ts`

  ```python
  import { awsApp } from './app.ts'

  awsApp.synth();
  ```

  Now, publish the `app.ts` file to a package manager, so that your `cdk8s` application can install and import it.
  This approach might be somewhat counter intuitive, because normally we only publish classes to the package manager,
  not instances. Indeed, these types of applications introduce a new use-case that requires the sharing of instances.
  Conceptually, this is no different than writing state<sup>*</sup> to an SSM parameter or an S3 bucket, and it allows us to remain
  in the boundaries of our programming language, and the typing guarantees it provides.

  > <sup>*</sup> Actually, we are only publishing instructions for fetching state, not the state itself.

  Assuming `app.ts` was published as the `my-cdk-app` package, our `cdk8s` application will now look like so:

  ```python
  import * as k8s from 'cdk8s';
  import * as kplus from 'cdk8s-plus-27';

  // import the desired instance from the AWS CDK app.
  import { bucketName } from 'my-cdk-app';

  import { AwsCdkResolver } from '@cdk8s/awscdk-resolver';

  const k8sApp = new k8s.App({ resolvers: [new AwsCdkResolver()] });
  const manifest = new k8s.Chart(k8sApp, 'Manifest');

  new kplus.CronJob(manifest, 'CronJob', {
    schedule: k8s.Cron.daily(),
    containers: [{
      image: 'job',
      envVariables: {
        // directly passing the value of the `CfnOutput` containing
        // the deploy time bucket name
        BUCKET_NAME: kplus.EnvValue.fromValue(bucketName.value),
      }
   }]
  });

  k8sApp.synth();
  ```


pkgId: d93bcc2c78d1fbe96604f22b1fc229456d5c4b60bfb2219468ad5ab3edad9166
name: python-cdk8s-cdktf-resolver-help
arch: noarch
version: 0.0.130
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-cdktf-resolver
url: https://github.com/cdk8s-team/cdk8s-cdktf-resolver.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-cdktf-resolver-0.0.130-1.src.rpm
location_href: Packages/python-cdk8s-cdktf-resolver-help-0.0.130-1.noarch.rpm
checksum_type: sha256
description:
  The `CdkTfResolver` is able to resolve any [`TerraformOutput`](https://developer.hashicorp.com/terraform/cdktf/concepts/variables-and-outputs#output-values)
  defined by your CDKTF application. In this example, we create an S3 `Bucket` with the CDKTF, and pass its (deploy time generated)
  name as an environment variable to a Kubernetes `CronJob` resource.

  ```python
  import * as tf from "cdktf";
  import * as aws from "@cdktf/provider-aws";
  import * as k8s from 'cdk8s';
  import * as kplus from 'cdk8s-plus-26';

  import { CdkTfResolver } from '@cdk8s/cdktf-resolver';

  const awsApp = new tf.App();
  const stack = new tf.TerraformStack(awsApp, 'aws');

  const k8sApp = new k8s.App({ resolvers: [new resolver.CdktfResolver({ app: awsApp })] });
  const manifest = new k8s.Chart(k8sApp, 'Manifest', { resolver });

  const bucket = new aws.s3Bucket.S3Bucket(stack, 'Bucket');
  const bucketName = new tf.TerraformOutput(constrcut, 'BucketName', {
    value: bucket.bucket,
  });

  new kplus.CronJob(manifest, 'CronJob', {
    schedule: k8s.Cron.daily(),
    containers: [{
      image: 'job',
      envVariables: {
        // directly passing the value of the `TerraformOutput` containing
        // the deploy time bucket name
        BUCKET_NAME: kplus.EnvValue.fromValue(bucketName.value),
      }
   }]
  });

  awsApp.synth();
  k8sApp.synth();
  ```

  During cdk8s synthesis, the custom resolver will detect that `bucketName.value` is not a concrete value,
  but rather a value of a `TerraformOutput`. It will then perform `cdktf` CLI commands in order to fetch the
  actual value from the deployed infrastructure in your account. This means that in order
  for `cdk8s synth` to succeed, it must be executed *after* the CDKTF resources
  have been deployed. So your deployment workflow should (conceptually) be:

  1. `cdktf deploy`
  2. `cdk8s synth`

  > Note that the `CdkTfResolver` is **only** able to fetch tokens that have a `TerraformOutput` defined for them.



  Since running `cdk8s synth` will now require reading terraform outputs, it must have permissions to do so.
  In case a remote state file is used, this means providing a set of credentials for the account that have access
  to where the state is stored. This will vary depending on your cloud provider, but in most cases will involve giving
  read permissions on a blob storage device (e.g S3 bucket).

  Note that the permissions cdk8s require are far more scoped down than those normally required for the
  deployment of CDKTF applications. It is therefore recommended to not reuse the same set of credentials,
  and instead create a scoped down `ReadOnly` role dedicated for cdk8s resolvers.

  Following are the set of commands the resolver will execute:

  * [`cdktf output`](https://developer.hashicorp.com/terraform/cdktf/cli-reference/commands#output)



  As we've seen, your `cdk8s` application needs access to the objects defined in your cloud application. If both applications
  are defined within the same file, this is trivial to achieve. If they are in different files, a simple `import` statement will suffice.
  However, what if the applications are managed in two separate repositories? This makes it a little trickier, but still possible.

  In this scenario, `cdktf.ts` in the CDKTF application, stored in a dedicated repository.

  ```python
  import * as tf from "cdktf";
  import * as aws from "@cdktf/provider-aws";

  import { CdkTfResolver } from '@cdk8s/cdktf-resolver';

  const awsApp = new tf.App();
  const stack = new tf.TerraformStack(awsApp, 'aws');

  const bucket = new aws.s3Bucket.S3Bucket(stack, 'Bucket');
  const bucketName = new tf.TerraformOutput(constrcut, 'BucketName', {
    value: bucket.bucket,
  });

  awsApp.synth();
  ```

  In order for the `cdk8s` application to have cross repository access, the CDKTF object instances
  that we want to expose need to be available via a package repository. To do this, break up the
  CDKTF application into the following files:

  `app.ts`

  ```python
  import * as tf from "cdktf";
  import * as aws from "@cdktf/provider-aws";

  import { CdkTfResolver } from '@cdk8s/cdktf-resolver';

  // export the app so we can pass it to the cdk8s resolver
  export const awsApp = new tf.App();
  const stack = new tf.TerraformStack(awsApp, 'aws');

  const bucket = new aws.s3Bucket.S3Bucket(stack, 'Bucket');
  // export the thing we want to have available for cdk8s applications
  export const bucketName = new tf.TerraformOutput(constrcut, 'BucketName', {
    value: bucket.bucket,
  });

  // note that we don't call awsApp.synth here
  ```

  `main.ts`

  ```python
  import { awsApp } from './app.ts'

  awsApp.synth();
  ```

  Now, publish the `app.ts` file to a package manager, so that your `cdk8s` application can install and import it.
  This approach might be somewhat counter intuitive, because normally we only publish classes to the package manager,
  not instances. Indeed, these types of applications introduce a new use-case that requires the sharing of instances.
  Conceptually, this is no different than writing state<sup>*</sup> to an SSM parameter or an S3 bucket, and it allows us to remain
  in the boundaries of our programming language, and the typing guarantees it provides.

  > <sup>*</sup> Actually, we are only publishing instructions for fetching state, not the state itself.

  Assuming `app.ts` was published as the `my-cdktf-app` package, our `cdk8s` application will now look like so:

  ```python
  import * as k8s from 'cdk8s';
  import * as kplus from 'cdk8s-plus-27';

  // import the desired instance from the CDKTF app.
  import { bucketName, awsApp } from 'my-cdktf-app';

  import { CdkTfResolver } from '@cdk8s/cdktf-resolver';

  const k8sApp = new k8s.App({ resolvers: [new resolver.CdktfResolver({ app: awsApp })] });
  const manifest = new k8s.Chart(k8sApp, 'Manifest');

  new kplus.CronJob(manifest, 'CronJob', {
    schedule: k8s.Cron.daily(),
    containers: [{
      image: 'job',
      envVariables: {
        // directly passing the value of the `TerraformOutput` containing
        // the deploy time bucket name
        BUCKET_NAME: kplus.EnvValue.fromValue(bucketName.value),
      }
   }]
  });

  k8sApp.synth();
  ```


pkgId: 258da7f6da2f6d21ab7c76fd6aedc666cd3a871f0364cb138dc632352e044ac0
name: python-cdk8s-grafana-help
arch: noarch
version: 0.1.665
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-grafana
url: https://github.com/cdk8s-team/cdk8s-grafana.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-grafana-0.1.665-1.src.rpm
location_href: Packages/python-cdk8s-grafana-help-0.1.665-1.noarch.rpm
checksum_type: sha256
description:
  [![View on Construct Hub](https://constructs.dev/badge?package=cdk8s-grafana)](https://constructs.dev/packages/cdk8s-grafana)

  cdk8s-grafana is a library that lets you easily define a Grafana service for
  your kubernetes cluster along with associated dashboards and datasources, using
  a high level API.



  To apply the resources generated by this construct, the Grafana operator must be
  installed on your cluster. See
  [https://operatorhub.io/operator/grafana-operator](https://operatorhub.io/operator/grafana-operator) for full installation
  instructions.

  The following will define a Grafana cluster connected to a Prometheus
  datasource:

  ```python
  import { Grafana } from 'cdk8s-grafana';

  // inside your chart:
  const grafana = new Grafana(this, 'my-grafana', {
    defaultDataSource: {
      name: 'Prometheus',
      type: 'prometheus',
      access: 'proxy',
      url: 'http://prometheus-service:9090',
    }
  });
  ```

  Basic aspects of a dashboard can be customized:

  ```python
  const github = grafana.addDatasource('github', ...);
  const dashboard = grafana.addDashboard('my-dashboard', {
    title: 'My Dashboard',
    refreshRate: Duration.seconds(10),
    timeRange: Duration.hours(6), // show metrics from now-6h to now
    plugins: [
      {
        name: 'grafana-piechart-panel',
        version: '1.3.6',
      }
    ],
  });
  ```

  Note: the kubernetes grafana operator only supports one Grafana instance per
  namespace (see https://github.com/grafana-operator/grafana-operator/issues/174).
  This may require specifying namespaces explicitly, e.g.:

  ```python
  const devGrafana = new Grafana(this, 'my-grafana', {
    namespace: 'dev',
  });
  const prodGrafana = new Grafana(this, 'my-grafana', {
    namespace: 'prod',
  });
  ```

  The grafana operator must be installed in each namespace for the resources in
  that namespace to be recognized.



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more
  information.



  This project is licensed under the Apache-2.0 License.


pkgId: b963889d1c1ba6dc546c49626f7758a440a2cdc6df25006fad00804b94a1ece8
name: python-cdk8s-help
arch: noarch
version: 2.69.25
epoch: 0
release: 1
summary: Development documents and examples for cdk8s
url: https://github.com/cdk8s-team/cdk8s-core.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-2.69.25-1.src.rpm
location_href: Packages/python-cdk8s-help-2.69.25-1.noarch.rpm
checksum_type: sha256
description:
  [![build](https://github.com/cdk8s-team/cdk8s-core/workflows/release/badge.svg)](https://github.com/cdk8s-team/cdk8s-core/actions/workflows/release.yml)
  [![npm version](https://badge.fury.io/js/cdk8s.svg)](https://badge.fury.io/js/cdk8s)
  [![PyPI version](https://badge.fury.io/py/cdk8s.svg)](https://badge.fury.io/py/cdk8s)
  [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.cdk8s/cdk8s/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.cdk8s/cdk8s)

  **cdk8s** is a software development framework for defining Kubernetes
  applications using rich object-oriented APIs. It allows developers to leverage
  the full power of software in order to define abstract components called
  "constructs" which compose Kubernetes resources or other constructs into
  higher-level abstractions.

  > **Note:** This repository is the "core library" of cdk8s, with logic for synthesizing Kubernetes manifests using the [constructs framework](https://github.com/aws/constructs). It is published to NPM as [`cdk8s`](https://www.npmjs.com/package/cdk8s) and should not be confused with the cdk8s command-line tool [`cdk8s-cli`](https://www.npmjs.com/package/cdk8s-cli). For more general information about cdk8s, please see [cdk8s.io](https://cdk8s.io), or visit the umbrella repository located at [cdk8s-team/cdk8s](https://github.com/cdk8s-team/cdk8s).



  See [cdk8s.io](https://cdk8s.io).



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team/cdk8s).


pkgId: 87d52f2ac3b1f78d0b5b5d25fe9cb9bdde186ec132664980c00a0be182000a9e
name: python-cdk8s-image-help
arch: noarch
version: 0.2.651
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-image
url: https://github.com/cdk8s-team/cdk8s-image.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-image-0.2.651-1.src.rpm
location_href: Packages/python-cdk8s-image-help-0.2.651-1.noarch.rpm
checksum_type: sha256
description:
  An `Image` construct which takes care of building & pushing docker images that
  can be used in [CDK8s](https://github.com/awslabs/cdk8s) apps.

  The following example will build the docker image from `Dockerfile` under the
  `my-app` directory, push it to a local registry and then define a Kubernetes
  deployment that deploys containers that run this image.

  ```python
  const image = new Image(this, 'image', {
    dir: `${__dirname}/my-app`,
    registry: 'localhost:5000'
  });

  new Deployment(this, 'deployment', {
    containers: [ new Container({ image: image.url }) ],
  });
  ```



  All contributions are celebrated.



  Licensed under [Apache 2.0](./LICENSE).


pkgId: cbb5b94776c1f280a1cbb56af1d4bfc4516e1acc9178007a674b7a14b7e76536
name: python-cdk8s-jenkins-help
arch: noarch
version: 0.0.465
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-jenkins
url: https://github.com/cdk8s-team/cdk8s-jenkins.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-jenkins-0.0.465-1.src.rpm
location_href: Packages/python-cdk8s-jenkins-help-0.0.465-1.noarch.rpm
checksum_type: sha256
description:
  `cdk8s-jenkins` is a library that lets you easily define a manifest for deploying a Jenkins instance to your Kubernetes cluster.



  This library uses a Custom Resource Definition provided by jenkins, and thus requires both the CRD and the operator to be installed on the cluster.
  You can set this up by,

  1. Apply the Custom Resource Definition(CRD) for jenkins on your Kubernetes cluster.

  ```
  kubectl apply -f https://raw.githubusercontent.com/jenkinsci/kubernetes-operator/master/config/crd/bases/jenkins.io_jenkins.yaml
  ```

  1. Install the Jenkins Operator on your Kubernetes cluster.

  ```
  kubectl apply -f https://raw.githubusercontent.com/jenkinsci/kubernetes-operator/master/deploy/all-in-one-v1alpha2.yaml
  ```

  > For more information regarding applying jenkins crd and installing jenkins operator, please refer [jenkins official documentaion](https://jenkinsci.github.io/kubernetes-operator/docs/getting-started/latest/installing-the-operator/).



  The library provides a high level `Jenkins` construct to provision a Jenkins instance.
  You can just instantiate the Jenkins instance and that would add a Jenkins resource to the kubernetes manifest.

  The library provide a set of defaults, so provisioning a basic Jenkins instance requires no configuration:

  ```python
  import { Jenkins } from 'cdk8s-jenkins';

  // inside your chart:
  const jenkins = new Jenkins(this, 'my-jenkins');
  ```

  The library also enables configuring the following parmeters for the Jenkins instance:



  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    metadata: {
      namespace: 'jenkins-namespace',
      labels: { customApp: 'my-jenkins' },
    },
  });
  ```



  This allows you to toggle CSRF Protection for Jenkins.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    disableCsrfProtection: true,
  });
  ```



  These are the plugins required by the jenkins operator.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    basePlugins: [{
      name: 'configuration-as-code',
      version: '1.55',
      }],
  });
  ```

  You can also utilize `addBasePlugins` function to add base plugins to jenkins configuration after initialization.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins');
  jenkins.addBasePlugins([{
    name: 'workflow-api',
    version: '2.76',
  }]);
  ```



  These are the plugins that you can add to your jenkins instance.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    plugins: [{
      name: 'simple-theme-plugin',
      version: '0.7',
      }],
  });
  ```

  You can also utilize `addPlugins` function to add plugins to jenkins configuration after initialization.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins');
  jenkins.addPlugins([{
    name: 'simple-theme-plugin',
    version: '0.7',
  }]);
  ```



  You can define list of jenkins seed job configurations here. For more info you can take look at [jenkins documentation](https://jenkinsci.github.io/kubernetes-operator/docs/getting-started/latest/configuring-seed-jobs-and-pipelines/).

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins', {
    seedJobs: [{
      id: 'jenkins-operator',
      targets: 'cicd/jobs/*.jenkins',
      description: 'Jenkins Operator repository',
      repositoryBranch: 'master',
      repositoryUrl: 'https://github.com/jenkinsci/kubernetes-operator.git',
      }],
  });
  ```

  You can also utilize `addSeedJobs` function to add seed jobs to jenkins configuration after initialization.

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins');
  jenkins.addSeedJobs([{
    id: 'jenkins-operator',
    targets: 'cicd/jobs/*.jenkins',
    description: 'Jenkins Operator repository',
    repositoryBranch: 'master',
    repositoryUrl: 'https://github.com/jenkinsci/kubernetes-operator.git',
  }]);
  ```



  You can utilize escape hatches to make changes to the configurations that are not yet exposed by the library.

  For instance, if you would like to update the version of a base plugin:

  ```python
  const jenkins = new Jenkins(this, 'my-jenkins');
  const jenkinsApiObject = ApiObject.of(jenkins);
  jenkinsApiObject.addJsonPatch(JsonPatch.replace('/spec/master/basePlugins/1', {
    name: 'workflow-job',
    version: '3.00',
  }));
  ```

  For more information regarding escape hatches, take a look at [cdk8s documentation](https://cdk8s.io/docs/latest/concepts/escape-hatches/).



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more
  information.



  This project is licensed under the Apache-2.0 License.


pkgId: b71db9d58d4e9dc766962589a47bb6c9fa05dfd931b15b6f88307c135c289786
name: python-cdk8s-operator-help
arch: noarch
version: 0.1.322
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-operator
url: https://github.com/cdk8s-team/cdk8s-operator.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-operator-0.1.322-1.src.rpm
location_href: Packages/python-cdk8s-operator-help-0.1.322-1.noarch.rpm
checksum_type: sha256
description:
  apiVersion: "v1"
  kind: "Pod"
  metadata:
    name: "my-collection-pod-1-c89f58d7"
  spec:
    containers:
      - env: []
        image: "paulbouwer/hello-kubernetes"
        imagePullPolicy: "Always"
        name: "main"
        ports: []
        volumeMounts: []


pkgId: 7a5916421c096e5e7da0e95c6b6b3f593b16f1c3b86b2a8e9d16288fce5f2c59
name: python-cdk8s-plone-help
arch: noarch
version: 0.0.51
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-plone
url: https://github.com/bluedynamics/cdk8s-plone.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-plone-0.0.51-1.src.rpm
location_href: Packages/python-cdk8s-plone-help-0.0.51-1.noarch.rpm
checksum_type: sha256
description:
  This chart provides a library to bootstrap a Plone deployment on a Kubernetes cluster using the [CDK8S](https://cdk8s.io) framework.

  It provides

  * Backend (as API with `plone.volto` or as Classic-UI)
  * Frontend (Plone-Volto, a ReactJS based user interface)
  * Varnish using kube-httpcache. It includes a way to invalidate varnish cluster (optional)



  To use this library, create a new CDK8S project (or use an existing one)

  ```bash
  cdk8s init typescript-app
  ```

  Then add the following dependency to `package.json`:

  ```json
  {
    "dependencies": {
      "@bluedynamics/cdk8s-plone": "*"
    }
  }
  ```

  Run `npm install` to install the new dependency.



  Todo: Document in details how to install.

  ```bash
  cdk8s init python-app
  ```

  Python package name is [cdk8s-plone](https://pypi.org/project/cdk8s-plone/).



  With `cdk8s-cli` installed, create a new project:

  ```bash
  cdk8s sythn
  ```

  Add the following code to your `main.ts`:

  ```python
  ...
  import { Plone } from '@bluedynamics/cdk8s-plone';
  ...
      super(scope, id, props);

      // define resources here
      new Plone(this, 'Plone', {});
  ...
  ```

  Run `npm run build ` to generate the Kubernetes manifests.
  The manifests are stored in the `dist` directory.

  For more have a look at the [example project](https://github.com/bluedynamics/cdk8s-plone-example).



  Clone the repository and install the dependencies:

  ```bash
  ```

  nvm use lts/*
  corepack enable
  npx projen

  ```

  Then run the following command to run the test:

  ```bash
  npx projen test
  ```


pkgId: e9ba08f256e3aef73ec654b2e19d7732a02c1dbb1944c2ffdd6ab5227cb8e001
name: python-cdk8s-plus-29-help
arch: noarch
version: 2.5.10
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-plus-29
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-plus-29-2.5.10-1.src.rpm
location_href: Packages/python-cdk8s-plus-29-help-2.5.10-1.noarch.rpm
checksum_type: sha256
description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.27.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-27) | [Link](https://pypi.org/project/cdk8s-plus-27/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-27) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.27) |
  | 1.28.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-28) | [Link](https://pypi.org/project/cdk8s-plus-28/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-28) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.28) |
  | 1.29.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-29) | [Link](https://pypi.org/project/cdk8s-plus-29/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-29) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.29) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: e00120545edefe1a6ee53cf326044938c55868f93f8a64eb518f6922589370e4
name: python-cdk8s-plus-30-help
arch: noarch
version: 2.2.10
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-plus-30
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-plus-30-2.2.10-1.src.rpm
location_href: Packages/python-cdk8s-plus-30-help-2.2.10-1.noarch.rpm
checksum_type: sha256
description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.28.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-28) | [Link](https://pypi.org/project/cdk8s-plus-28/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-28) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.28) |
  | 1.29.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-29) | [Link](https://pypi.org/project/cdk8s-plus-29/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-29) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.29) |
  | 1.30.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-30) | [Link](https://pypi.org/project/cdk8s-plus-30/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-30) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.30) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 8e1b338849db79230eb0b59e8a43ce9223d1e31b25b69e188f8b1cf4e0ad3300
name: python-cdk8s-plus-31-help
arch: noarch
version: 2.0.6
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-plus-31
url: https://github.com/cdk8s-team/cdk8s-plus.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-plus-31-2.0.6-1.src.rpm
location_href: Packages/python-cdk8s-plus-31-help-2.0.6-1.noarch.rpm
checksum_type: sha256
description:
  ![Stability:Stable](https://img.shields.io/badge/stability-stable-success)

  | k8s version | npm (JS/TS)                                         | PyPI (Python)                                   | Maven (Java)                                                      | Go                                                              |
  | ----------- | --------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------- |
  | 1.29.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-29) | [Link](https://pypi.org/project/cdk8s-plus-29/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-29) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.29) |
  | 1.30.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-30) | [Link](https://pypi.org/project/cdk8s-plus-30/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-30) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.30) |
  | 1.31.0      | [Link](https://www.npmjs.com/package/cdk8s-plus-31) | [Link](https://pypi.org/project/cdk8s-plus-31/) | [Link](https://search.maven.org/artifact/org.cdk8s/cdk8s-plus-31) | [Link](https://github.com/cdk8s-team/cdk8s-plus-go/tree/k8s.31) |

  **cdk8s+** is a software development framework that provides high level
  abstractions for authoring Kubernetes applications. Built on top of the auto
  generated building blocks provided by [cdk8s](../cdk8s), this library includes a
  hand crafted *construct* for each native kubernetes object, exposing richer
  API's with reduced complexity.



  See [cdk8s.io](https://cdk8s.io/docs/latest/plus).



  If you'd like to add a new feature or fix a bug, please visit
  [CONTRIBUTING.md](CONTRIBUTING.md)!



  This project is distributed under the [Apache License, Version 2.0](./LICENSE).

  This module is part of the [cdk8s project](https://github.com/cdk8s-team).


pkgId: 3527199f19bc33b93c53c0f2b44bb912afdf89d2468444f8c8c0d8f50a311c50
name: python-cdk8s-redis-help
arch: noarch
version: 0.1.797
epoch: 0
release: 1
summary: Development documents and examples for cdk8s-redis
url: https://github.com/cdk8s-team/cdk8s-redis.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdk8s-redis-0.1.797-1.src.rpm
location_href: Packages/python-cdk8s-redis-help-0.1.797-1.noarch.rpm
checksum_type: sha256
description:
  > Redis constructs for cdk8s

  Basic implementation of a Redis construct for cdk8s. Contributions are welcome!



  The following will define a Redis cluster with a primary and 2 replicas:

  ```python
  import { Redis } from 'cdk8s-redis';

  // inside your chart:
  const redis = new Redis(this, 'my-redis');
  ```

  DNS names can be obtained from `redis.primaryHost` and `redis.replicaHost`.

  You can specify how many replicas to define:

  ```python
  new Redis(this, 'my-redis', {
    replicas: 4
  });
  ```

  Or, you can specify no replicas:

  ```python
  new Redis(this, 'my-redis', {
    replicas: 0
  });
  ```



  Distributed under the [Apache 2.0](./LICENSE) license.


pkgId: 22497bc6606866492d000d92434f9e1c7bd5e9394f39c61003b8cb0353004423
name: python-cdklabs.appsync-utils-help
arch: noarch
version: 0.0.603
epoch: 0
release: 1
summary: Development documents and examples for cdklabs.appsync-utils
url: https://github.com/cdklabs/awscdk-appsync-utils.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdklabs.appsync-utils-0.0.603-1.src.rpm
location_href: Packages/python-cdklabs.appsync-utils-help-0.0.603-1.noarch.rpm
checksum_type: sha256
description:
  This package contains various utilities for definining GraphQl Apis via AppSync using the [aws-cdk](https://github.com/aws/aws-cdk).



  `CodeFirstSchema` offers the ability to generate your schema in a code-first
  approach. A code-first approach offers a developer workflow with:

  * **modularity**: organizing schema type definitions into different files
  * **reusability**: removing boilerplate/repetitive code
  * **consistency**: resolvers and schema definition will always be synced

  The code-first approach allows for **dynamic** schema generation. You can
  generate your schema based on variables and templates to reduce code
  duplication.

  ```python
  import { GraphqlApi } from '@aws-cdk/aws-appsync-alpha';
  import { CodeFirstSchema } from 'awscdk-appsync-utils';

  const schema = new CodeFirstSchema();
  const api = new GraphqlApi(this, 'api', { name: 'myApi', schema });

  schema.addType(new ObjectType('demo', {
    definition: { id: GraphqlType.id() },
  }));
  ```



  To showcase the code-first approach. Let's try to model the following schema segment.

  ```gql
  interface Node {
    id: String
  }

  type Query {
    allFilms(after: String, first: Int, before: String, last: Int): FilmConnection
  }

  type FilmNode implements Node {
    filmName: String
  }

  type FilmConnection {
    edges: [FilmEdge]
    films: [Film]
    totalCount: Int
  }

  type FilmEdge {
    node: Film
    cursor: String
  }
  ```

  Above we see a schema that allows for generating paginated responses. For example,
  we can query `allFilms(first: 100)` since `FilmConnection` acts as an intermediary
  for holding `FilmEdges` we can write a resolver to return the first 100 films.

  In a separate file, we can declare our object types and related functions.
  We will call this file `object-types.ts` and we will have created it in a way that
  allows us to generate other `XxxConnection` and `XxxEdges` in the future.

  ```python
  import { GraphqlType, InterfaceType, ObjectType } from 'awscdk-appsync-utils';
  const pluralize = require('pluralize');

  export const args = {
    after: GraphqlType.string(),
    first: GraphqlType.int(),
    before: GraphqlType.string(),
    last: GraphqlType.int(),
  };

  export const Node = new InterfaceType('Node', {
    definition: { id: GraphqlType.string() }
  });
  export const FilmNode = new ObjectType('FilmNode', {
    interfaceTypes: [Node],
    definition: { filmName: GraphqlType.string() }
  });

  export function generateEdgeAndConnection(base: ObjectType) {
    const edge = new ObjectType(`${base.name}Edge`, {
      definition: { node: base.attribute(), cursor: GraphqlType.string() }
    });
    const connection = new ObjectType(`${base.name}Connection`, {
      definition: {
        edges: edge.attribute({ isList: true }),
        [pluralize(base.name)]: base.attribute({ isList: true }),
        totalCount: GraphqlType.int(),
      }
    });
    return { edge: edge, connection: connection };
  }
  ```

  Finally, we will go to our `cdk-stack` and combine everything together
  to generate our schema.

  ```python
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const api = new appsync.GraphqlApi(this, 'Api', {
    name: 'demo',
  });

  const objectTypes = [ Node, FilmNode ];

  const filmConnections = generateEdgeAndConnection(FilmNode);

  api.addQuery('allFilms', new ResolvableField({
    returnType: filmConnections.connection.attribute(),
    args: args,
    dataSource: api.addNoneDataSource('none'),
    requestMappingTemplate: dummyRequest,
    responseMappingTemplate: dummyResponse,
  }));

  api.addType(Node);
  api.addType(FilmNode);
  api.addType(filmConnections.edge);
  api.addType(filmConnections.connection);
  ```

  Notice how we can utilize the `generateEdgeAndConnection` function to generate
  Object Types. In the future, if we wanted to create more Object Types, we can simply
  create the base Object Type (i.e. Film) and from there we can generate its respective
  `Connections` and `Edges`.

  Check out a more in-depth example [here](https://github.com/BryanPan342/starwars-code-first).



  One of the benefits of GraphQL is its strongly typed nature. We define the
  types within an object, query, mutation, interface, etc. as **GraphQL Types**.

  GraphQL Types are the building blocks of types, whether they are scalar, objects,
  interfaces, etc. GraphQL Types can be:

  * [**Scalar Types**](https://docs.aws.amazon.com/appsync/latest/devguide/scalars.html): Id, Int, String, AWSDate, etc.
  * [**Object Types**](#Object-Types): types that you generate (i.e. `demo` from the example above)
  * [**Interface Types**](#Interface-Types): abstract types that define the base implementation of other
    Intermediate Types

  More concretely, GraphQL Types are simply the types appended to variables.
  Referencing the object type `Demo` in the previous example, the GraphQL Types
  is `String!` and is applied to both the names `id` and `version`.



  `Directives` are attached to a field or type and affect the execution of queries,
  mutations, and types. With AppSync, we use `Directives` to configure authorization.
  Appsync utils provide static functions to add directives to your CodeFirstSchema.

  * `Directive.iam()` sets a type or field's authorization to be validated through `Iam`
  * `Directive.apiKey()` sets a type or field's authorization to be validated through a `Api Key`
  * `Directive.oidc()` sets a type or field's authorization to be validated through `OpenID Connect`
  * `Directive.cognito(...groups: string[])` sets a type or field's authorization to be validated
    through `Cognito User Pools`

    * `groups` the name of the cognito groups to give access

  To learn more about authorization and directives, read these docs [here](https://docs.aws.amazon.com/appsync/latest/devguide/security.html).



  While `GraphqlType` is a base implementation for GraphQL fields, we have abstractions
  on top of `GraphqlType` that provide finer grain support.



  `Field` extends `GraphqlType` and will allow you to define arguments. [**Interface Types**](#Interface-Types) are not resolvable and this class will allow you to define arguments,
  but not its resolvers.

  For example, if we want to create the following type:

  ```gql
  type Node {
    test(argument: string): String
  }
  ```

  The CDK code required would be:

  ```python
  import { Field, GraphqlType, InterfaceType } from 'awscdk-appsync-utils';

  const field = new Field({
    returnType: GraphqlType.string(),
    args: {
      argument: GraphqlType.string(),
    },
  });
  const type = new InterfaceType('Node', {
    definition: { test: field },
  });
  ```



  `ResolvableField` extends `Field` and will allow you to define arguments and its resolvers.
  [**Object Types**](#Object-Types) can have fields that resolve and perform operations on
  your backend.

  You can also create resolvable fields for object types.

  ```gql
  type Info {
    node(id: String): String
  }
  ```

  The CDK code required would be:

  ```python
  declare const api: appsync.GraphqlApi;
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const info = new ObjectType('Info', {
    definition: {
      node: new ResolvableField({
        returnType: GraphqlType.string(),
        args: {
          id: GraphqlType.string(),
        },
        dataSource: api.addNoneDataSource('none'),
        requestMappingTemplate: dummyRequest,
        responseMappingTemplate: dummyResponse,
      }),
    },
  });
  ```

  To nest resolvers, we can also create top level query types that call upon
  other types. Building off the previous example, if we want the following graphql
  type definition:

  ```gql
  type Query {
    get(argument: string): Info
  }
  ```

  The CDK code required would be:

  ```python
  declare const api: appsync.GraphqlApi;
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const query = new ObjectType('Query', {
    definition: {
      get: new ResolvableField({
        returnType: GraphqlType.string(),
        args: {
          argument: GraphqlType.string(),
        },
        dataSource: api.addNoneDataSource('none'),
        requestMappingTemplate: dummyRequest,
        responseMappingTemplate: dummyResponse,
      }),
    },
  });
  ```

  Learn more about fields and resolvers [here](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html).



  Intermediate Types are defined by Graphql Types and Fields. They have a set of defined
  fields, where each field corresponds to another type in the system. Intermediate
  Types will be the meat of your GraphQL Schema as they are the types defined by you.

  Intermediate Types include:

  * [**Interface Types**](#Interface-Types)
  * [**Object Types**](#Object-Types)
  * [**Enum Types**](#Enum-Types)
  * [**Input Types**](#Input-Types)
  * [**Union Types**](#Union-Types)



  **Interface Types** are abstract types that define the implementation of other
  intermediate types. They are useful for eliminating duplication and can be used
  to generate Object Types with less work.

  You can create Interface Types ***externally***.

  ```python
  const node = new InterfaceType('Node', {
    definition: {
      id: GraphqlType.string({ isRequired: true }),
    },
  });
  ```

  To learn more about **Interface Types**, read the docs [here](https://graphql.org/learn/schema/#interfaces).



  **Object Types** are types that you declare. For example, in the [code-first example](#code-first-example)
  the `demo` variable is an **Object Type**. **Object Types** are defined by
  GraphQL Types and are only usable when linked to a GraphQL Api.

  You can create Object Types in two ways:

  1. Object Types can be created ***externally***.

     ```python
     const schema = new CodeFirstSchema();
     const api = new appsync.GraphqlApi(this, 'Api', {
       name: 'demo',
       schema,
     });
     const demo = new ObjectType('Demo', {
       definition: {
         id: GraphqlType.string({ isRequired: true }),
         version: GraphqlType.string({ isRequired: true }),
       },
     });

     schema.addType(demo);
     ```

     > This method allows for reusability and modularity, ideal for larger projects.
     > For example, imagine moving all Object Type definition outside the stack.

     `object-types.ts` - a file for object type definitions

     ```python
     import { ObjectType, GraphqlType } from 'awscdk-appsync-utils';
     export const demo = new ObjectType('Demo', {
       definition: {
         id: GraphqlType.string({ isRequired: true }),
         version: GraphqlType.string({ isRequired: true }),
       },
     });
     ```

     `cdk-stack.ts` - a file containing our cdk stack

     ```python
     declare const schema: CodeFirstSchema;
     schema.addType(demo);
     ```
  2. Object Types can be created ***externally*** from an Interface Type.

     ```python
     const node = new InterfaceType('Node', {
       definition: {
         id: GraphqlType.string({ isRequired: true }),
       },
     });
     const demo = new ObjectType('Demo', {
       interfaceTypes: [ node ],
       definition: {
         version: GraphqlType.string({ isRequired: true }),
       },
     });
     ```

     > This method allows for reusability and modularity, ideal for reducing code duplication.

  To learn more about **Object Types**, read the docs [here](https://graphql.org/learn/schema/#object-types-and-fields).



  **Enum Types** are a special type of Intermediate Type. They restrict a particular
  set of allowed values for other Intermediate Types.

  ```gql
  enum Episode {
    NEWHOPE
    EMPIRE
    JEDI
  }
  ```

  > This means that wherever we use the type Episode in our schema, we expect it to
  > be exactly one of NEWHOPE, EMPIRE, or JEDI.

  The above GraphQL Enumeration Type can be expressed in CDK as the following:

  ```python
  declare const api: GraphqlApi;
  const episode = new EnumType('Episode', {
    definition: [
      'NEWHOPE',
      'EMPIRE',
      'JEDI',
    ],
  });
  api.addType(episode);
  ```

  To learn more about **Enum Types**, read the docs [here](https://graphql.org/learn/schema/#enumeration-types).



  **Input Types** are special types of Intermediate Types. They give users an
  easy way to pass complex objects for top level Mutation and Queries.

  ```gql
  input Review {
    stars: Int!
    commentary: String
  }
  ```

  The above GraphQL Input Type can be expressed in CDK as the following:

  ```python
  declare const api: appsync.GraphqlApi;
  const review = new InputType('Review', {
    definition: {
      stars: GraphqlType.int({ isRequired: true }),
      commentary: GraphqlType.string(),
    },
  });
  api.addType(review);
  ```

  To learn more about **Input Types**, read the docs [here](https://graphql.org/learn/schema/#input-types).



  **Union Types** are a special type of Intermediate Type. They are similar to
  Interface Types, but they cannot specify any common fields between types.

  **Note:** the fields of a union type need to be `Object Types`. In other words, you
  can't create a union type out of interfaces, other unions, or inputs.

  ```gql
  union Search = Human | Droid | Starship
  ```

  The above GraphQL Union Type encompasses the Object Types of Human, Droid and Starship. It
  can be expressed in CDK as the following:

  ```python
  declare const api: appsync.GraphqlApi;
  const string = GraphqlType.string();
  const human = new ObjectType('Human', { definition: { name: string } });
  const droid = new ObjectType('Droid', { definition: { name: string } });
  const starship = new ObjectType('Starship', { definition: { name: string } }););
  const search = new UnionType('Search', {
    definition: [ human, droid, starship ],
  });
  api.addType(search);
  ```

  To learn more about **Union Types**, read the docs [here](https://graphql.org/learn/schema/#union-types).



  Every schema requires a top level Query type. By default, the schema will look
  for the `Object Type` named `Query`. The top level `Query` is the **only** exposed
  type that users can access to perform `GET` operations on your Api.

  To add fields for these queries, we can simply run the `addQuery` function to add
  to the schema's `Query` type.

  ```python
  declare const api: appsync.GraphqlApi;
  declare const filmConnection: InterfaceType;
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const string = GraphqlType.string();
  const int = GraphqlType.int();
  api.addQuery('allFilms', new ResolvableField({
    returnType: filmConnection.attribute(),
    args: { after: string, first: int, before: string, last: int},
    dataSource: api.addNoneDataSource('none'),
    requestMappingTemplate: dummyRequest,
    responseMappingTemplate: dummyResponse,
  }));
  ```

  To learn more about top level operations, check out the docs [here](https://docs.aws.amazon.com/appsync/latest/devguide/graphql-overview.html).



  Every schema **can** have a top level Mutation type. By default, the schema will look
  for the `ObjectType` named `Mutation`. The top level `Mutation` Type is the only exposed
  type that users can access to perform `mutable` operations on your Api.

  To add fields for these mutations, we can simply run the `addMutation` function to add
  to the schema's `Mutation` type.

  ```python
  declare const api: appsync.GraphqlApi;
  declare const filmNode: ObjectType;
  declare const dummyRequest: appsync.MappingTemplate;
  declare const dummyResponse: appsync.MappingTemplate;

  const string = GraphqlType.string();
  const int = GraphqlType.int();
  api.addMutation('addFilm', new ResolvableField({
    returnType: filmNode.attribute(),
    args: { name: string, film_number: int },
    dataSource: api.addNoneDataSource('none'),
    requestMappingTemplate: dummyRequest,
    responseMappingTemplate: dummyResponse,
  }));
  ```

  To learn more about top level operations, check out the docs [here](https://docs.aws.amazon.com/appsync/latest/devguide/graphql-overview.html).



  Every schema **can** have a top level Subscription type. The top level `Subscription` Type
  is the only exposed type that users can access to invoke a response to a mutation. `Subscriptions`
  notify users when a mutation specific mutation is called. This means you can make any data source
  real time by specify a GraphQL Schema directive on a mutation.

  **Note**: The AWS AppSync client SDK automatically handles subscription connection management.

  To add fields for these subscriptions, we can simply run the `addSubscription` function to add
  to the schema's `Subscription` type.

  ```python
  declare const api: appsync.GraphqlApi;
  declare const film: InterfaceType;

  api.addSubscription('addedFilm', new Field({
    returnType: film.attribute(),
    args: { id: GraphqlType.id({ isRequired: true }) },
    directives: [Directive.subscribe('addFilm')],
  }));
  ```

  To learn more about top level operations, check out the docs [here](https://docs.aws.amazon.com/appsync/latest/devguide/real-time-data.html).



  The SourceApiAssociationMergeOperation construct provides the ability to merge a source api to a Merged Api
  and invoke a merge within a Cloudformation custom resource. If the merge operation fails with a conflict, the
  Cloudformation update will fail and rollback the changes to the source API in the stack.

  ```python
  import * as cdk from 'aws-cdk-lib';

  const sourceApi1ToMerge = new appsync.GraphqlApi(this, 'FirstSourceAPI', {
    name: 'FirstSourceAPI',
    definition: appsync.Definition.fromFile(path.join(__dirname, 'appsync.merged-api-1.graphql')),
  });

  const sourceApi2ToMerge = new appsync.GraphqlApi(this, 'SecondSourceAPI', {
    name: 'SecondSourceAPI',
    definition: appsync.Definition.fromFile(path.join(__dirname, 'appsync.merged-api-2.graphql')),
  });

  const remoteMergedApi = appsync.GraphqlApi.fromGraphqlApiAttributes(this, 'ImportedMergedApi', {
    graphqlApiId: 'MyApiId',
    graphqlApiArn: 'MyApiArn',
  });

  const remoteExecutionRole = iam.Role.fromRoleArn(this, 'ExecutionRole', 'arn:aws:iam::ACCOUNT:role/MyExistingRole');
  const association1 = new appsync.SourceApiAssociation(this, 'SourceApiAssociation1', {
     sourceApi: sourceApi1ToMerge,
     mergedApi: remoteMergedApi,
     mergeType: appsync.MergeType.MANUAL_MERGE,
     mergedApiExecutionRole: remoteExecutionRole,
  });

  const association2 = new appsync.SourceApiAssociation(this, 'SourceApiAssociation2', {
     sourceApi: sourceApi2ToMerge,
     mergedApi: remoteMergedApi,
     mergeType: appsync.MergeType.MANUAL_MERGE,
     mergedApiExecutionRole: remoteExecutionRole,
  });

  // The version id can be any identifier defined by the developer. Changing the version identifier allows you to control
  // whether a merge operation will take place during deployment.
  SourceApiAssociationMergeOperation(this, 'MergeOperation1', {
    sourceApiAssociation: association1,
    versionIdentifier: '1',
  });

  // Optionally, you can add the alwaysMergeOnStackUpdate flag instead which will ensure that the merge operation occurs
  // during every stack update, regardless if there was a change or not. Note that this may lead to merge operations that
  //do not actually change the MergedAPI.
  SourceApiAssociationMergeOperation(this, 'MergeOperation2', {
    sourceApiAssociation: association2,
    alwaysMergeOnStackUpdate: true,
  });
  ```



  This library leans towards high level and experimental features for appsync cdk users. If you have an idea for additional utilities please create an issue describing the feature.

  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: 3e9d78ffa4a10dd54a1956dc4a1a7ab25adbdde2c8a7f03e87d86a8820f13a2a
name: python-cdklabs.cdk-enterprise-iac-help
arch: noarch
version: 0.0.521
epoch: 0
release: 1
summary: Development documents and examples for cdklabs.cdk-enterprise-iac
url: https://github.com/cdklabs/cdk-enterprise-iac.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdklabs.cdk-enterprise-iac-0.0.521-1.src.rpm
location_href: Packages/python-cdklabs.cdk-enterprise-iac-help-0.0.521-1.noarch.rpm
checksum_type: sha256
description:
  Generated API.md below:
  <details>
      <summary>Expand to view API docs</summary><!--
  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  SPDX-License-Identifier: Apache-2.0
  -->

  Utilities for using CDK within enterprise constraints.

  Typescript
  ```zsh
  npm install @cdklabs/cdk-enterprise-iac
  ```
  Python
  ```zsh
  pip install cdklabs.cdk-enterprise-iac
  ```

  Within large enterprises, builders can come up against enterprise imposed constraints when deploying on AWS.
  This could be simple things such as "All IAM roles must have a specific Permissions Boundary attached".
  This could also be more restrictive such as strict separation of duties, only allowing certain teams the ability to deploy specific AWS resources (e.g. Networking team can deploy VPCs, Subnets, and route tables. Security team can deploy IAM resources. Developers can deploy Compute. DBAs can deploy Databases, etc.)
  Enterprises with very restrictive environments like these would benefit from taking a closer look at their policies to see how they can allow builders to safely deploy resources with less friction. However in many enterprises this is easier said than done, and builders are still expected to deliver.
  This project is meant to reduce friction for builders working within these enterprise constraints while the enterprise determines what policies make the most sense for their organization, and is in no way prescriptive.

  There are many tools available, all detailed in [`API.md`](./API.md).
  A few examples of these tools below:

  Example for `AddPermissionBoundary` in Typescript project.
  ```python

  import aws_cdk as cdk
  from ...lib.my_project_stack import MyStack
  from aws_cdk import Aspects
  from cdklabs.cdk_enterprise_iac import AddPermissionBoundary
  app = cdk.App()
  MyStack(app, "MyStack")
  Aspects.of(app).add(
      AddPermissionBoundary(
          permissions_boundary_policy_name="MyPermissionBoundaryName",
          instance_profile_prefix="MY_PREFIX_",  # optional, Defaults to ''
          policy_prefix="MY_POLICY_PREFIX_",  # optional, Defaults to ''
          role_prefix="MY_ROLE_PREFIX_"
      ))
  ```
  Example for `AddPermissionBoundary` in Python project.
  ```python
  import aws_cdk as cdk
  from cdklabs.cdk_enterprise_iac import AddPermissionBoundary
  from test_py.test_py_stack import TestPyStack
  app = cdk.App()
  TestPyStack(app, "TestPyStack")
  cdk.Aspects.of(app).add(AddPermissionBoundary(
      permissions_boundary_policy_name="MyPermissionBoundaryName",
      instance_profile_prefix="MY_PREFIX_",  # optional, Defaults to ""
      policy_prefix="MY_POLICY_PREFIX_",  # optional, Defaults to ""
      role_prefix="MY_ROLE_PREFIX_"  # optional, Defaults to ""
  ))
  app.synth()
  ```

  In many enterprises, there are separate teams with different IAM permissions than developers deploying CDK applications.
  For example there might be a networking team with permissions to deploy `AWS::EC2::SecurityGroup` and `AWS::EC2::EIP`, or a security team with permissions to deploy `AWS::IAM::Role` and `AWS::IAM::Policy`, but the developers deploying the CDK don't have those permissions.
  When a developer doesn't have permissions to deploy necessary resources in their CDK application, writing good code becomes difficult to manage when a cdk deploy will quickly error due to not being able to deploy something like an `AWS::IAM::Role` which is foundational to any project deployed into AWS.
  An enterprise should *allow* builders to deploy these resources via CDK for [many reasons](https://github.com/aws/aws-cdk/wiki/Security-And-Safety-Dev-Guide#allowing-creation-of-iam-roles-without-privilege-escalation), and can use [Permissions Boundaries](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) to prevent privilege escalation. For enterprises that haven't yet utilized Permissions Boundaries, the `ResourceExtractor` can make it easier for builders to write good CDK while complying with enterprise policies.
  Using the `ResourceExtractor` Aspect, developers can write their CDK code as though they had sufficient IAM permissions, but extract those resources into a separate stack for an external team to deploy on their behalf.
  Take the following example stack:
  ```python

  from aws_cdk import App, Aspects, RemovalPolicy, Stack
  from aws_cdk.aws_lambda import Code, Function, Runtime
  from aws_cdk.aws_s3 import Bucket
  app = App()
  app_stack = Stack(app, "MyAppStack")
  func = Function(app_stack, "TestLambda",
      code=Code.from_asset(path.join(__dirname, "lambda-handler")),
      handler="index.handler",
      runtime=Runtime.PYTHON_3_11
  )
  bucket = Bucket(app_stack, "TestBucket",
      auto_delete_objects=True,
      removal_policy=RemovalPolicy.DESTROY
  )
  bucket.grant_read_write(func)
  app.synth()
  ```
  The synthesized Cloudformation would include *all* AWS resources required, including resources a developer might not have permissions to deploy
  The above example would include the following snippet in the synthesized Cloudformation
  ```yaml
  TestLambdaServiceRoleC28C2D9C:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action: 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
        Version: 2012-10-17
      
    TestLambda2F70C45E:
      Type: 'AWS::Lambda::Function'
      Properties:
        Role: !GetAtt
          - TestLambdaServiceRoleC28C2D9C
          - Arn
        
  ```
  While including `bucket.grantReadWrite(func)` in the CDK application ensures an IAM role with least privilege IAM policies for the application, the creation of IAM resources such as Roles and Policies may be restricted to a security team, resulting in the synthesized Cloudformation template not being deployable by a developer.
  Using the `ResourceExtractor`, we can pull out an arbitrary list of Cloudformation resources that a developer *doesn't* have permissions to provision, and create a separate stack that can be sent to a security team.
  ```python

  from aws_cdk import App, Aspects, RemovalPolicy, Stack
  from aws_cdk.aws_lambda import Code, Function, Runtime
  from aws_cdk.aws_s3 import Bucket

  from cdklabs.cdk_enterprise_iac import ResourceExtractor
  app = App()
  app_stack = Stack(app, "MyAppStack")

  extracted_stack = Stack(app, "ExtractedStack")
  func = Function(app_stack, "TestLambda",
      code=Code.from_asset(path.join(__dirname, "lambda-handler")),
      handler="index.handler",
      runtime=Runtime.PYTHON_3_11
  )
  bucket = Bucket(app_stack, "TestBucket",
      auto_delete_objects=True,
      removal_policy=RemovalPolicy.DESTROY
  )
  bucket.grant_read_write(func)

  synthed_app = app.synth()

  Aspects.of(app).add(
      ResourceExtractor(
          
          stack_artifacts=synthed_app.stacks,
          
          resource_types_to_extract=["AWS::IAM::Role", "AWS::IAM::Policy", "AWS::IAM::ManagedPolicy", "AWS::IAM::InstanceProfile"
          ],
          
          extract_destination_stack=extracted_stack
      ))

  app.synth(force=True)
  ```
  In the example above, *all* resources are created in the `appStack`, and an empty `extractedStack` is also created.
  We apply the `ResourceExtractor` Aspect, specifying the Cloudformation resource types the developer is unable to deploy due to insufficient IAM permissions.
  Now when we list stacks in the CDK project, we can see an added stack
  ```zsh
  $ cdk ls
  MyAppStack
  ExtractedStack
  ```
  Taking a look at these synthesized stacks, in the `ExtractedStack` we'll find:
  ```yaml
  Resources:
    TestLambdaServiceRoleC28C2D9C:
      Type: 'AWS::IAM::Role'
      Properties:
        AssumeRolePolicyDocument:
          Statement:
            - Action: 'sts:AssumeRole'
              Effect: Allow
              Principal:
                Service: lambda.amazonaws.com
          Version: 2012-10-17
        
  Outputs:
    ExportAppStackTestLambdaServiceRoleC28C2D9C:
      Value:
        'Fn::GetAtt':
          - TestLambdaServiceRoleC28C2D9C
          - Arn
      Export:
        Name: 'AppStack:TestLambdaServiceRoleC28C2D9C'  # Exported name
  ```
  And inside the synthesized `MyAppStack` template:
  ```yaml
  Resources:
    TestLambda2F70C45E:
      Type: 'AWS::Lambda::Function'
      Properties:
        Role: !ImportValue 'AppStack:TestLambdaServiceRoleC28C2D9C'  # Using ImportValue instrinsic function to use pre-created IAM role
        
  ```
  In this scenario, a developer is able to provide an external security team with sufficient IAM privileges to deploy the `ExtractedStack`.
  Once deployed, a developer can run `cdk deploy MyAppStack` without errors due to insufficient IAM privileges

  When resources are extracted from a stack, there must be a method to reference the resources that have been extracted.
  There are three methods (see `ResourceExtractorShareMethod` enum)
  * `CFN_OUTPUT`
  * `SSM_PARAMETER`
  * `API_LOOKUP`

  The default sharing method is `CFN_OUTPUT`, which uses Cloudformation Export/Import to Export values in the extracted stack (see [Outputs](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html)), and use the [Fn::ImportValue](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html) intrinsic function to reference those values.
  This works fine, but some teams may prefer a looser coupling between the extracted stack deployed by an external team and the rest of the CDK infrastructure.

  In this method, the extracted stack generates Parameters in AWS Systems Manager Parameter Store, and modifies the CDK application to look up the generated parameter using [`aws_ssm.StringParameter.valueFromLookup()`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ssm.StringParameter.html#static-valuewbrfromwbrlookupscope-parametername) at synthesis time.
  Example on using this method:
  ```python

  from cdklabs.cdk_enterprise_iac import ResourceExtractor, ResourceExtractorShareMethod
  Aspects.of(app).add(
      ResourceExtractor(
          stack_artifacts=synthed_app.stacks,
          resource_types_to_extract=["AWS::IAM::Role", "AWS::IAM::Policy", "AWS::IAM::ManagedPolicy", "AWS::IAM::InstanceProfile"
          ],
          extract_destination_stack=extracted_stack,
          value_share_method=ResourceExtractorShareMethod.SSM_PARAMETER
      ))
  ```

  The `API_LOOKUP` sharing method is a work in progress, and not yet supported

  Some resources that get extracted might reference resources that aren't yet created.
  In our example CDK application we include the line
  ```python

  bucket.grant_read_write(func)
  ```
  This creates an `AWS::IAM::Policy` that includes the necessary Actions scoped down to the S3 bucket.
  When the `AWS::IAM::Policy` is extracted, it's unable to use `Ref` or `Fn::GetAtt` to reference the S3 bucket since the S3 bucket wasn't extracted.
  In this case we substitute the reference with a "partial ARN" that makes a best effort to scope the resources in the IAM policy statement to the ARN of the yet-to-be created S3 bucket.
  There are multiple resource types supported out of the box (found in [`createDefaultTransforms`](src/patches/resource-extractor/resourceTransformer.ts)). In the event you have a resource not yet supported, you'll receive a `MissingTransformError`. In this case you can either open an [issue](https://github.com/cdklabs/cdk-enterprise-iac/issues) with the resource in question, or you can include the `additionalTransforms` property.
  Consider the following:
  ```python

  vpc = Vpc(stack, "TestVpc")
  db = DatabaseInstance(stack, "TestDb",
      vpc=vpc,
      engine=DatabaseInstanceEngine.POSTGRES
  )
  func = Function(stack, "TestLambda", {
      "code": Code.from_asset(path.join(__dirname, "lambda-handler")),
      "handler": "index.handler",
      "runtime": Runtime.PYTHON_3_11
  })
  db.secret.grant_read(func)
  synthed_app = app.synth()
  Aspects.of(app).add(
      ResourceExtractor(
          extract_destination_stack=extracted_stack,
          stack_artifacts=synthed_app.stacks,
          value_share_method=ResourceExtractorShareMethod.CFN_OUTPUT,
          resource_types_to_extract=["AWS::IAM::Role", "AWS::IAM::Policy"],
          additional_transforms={
              "AWS::SecretsManager::SecretTargetAttachment": f"arn:{Aws.PARTITION}:secretsmanager:{Aws.REGION}:{Aws.ACCOUNT_ID}:secret:some-expected-value*"
          }
      ))
  app.synth(force=True)
  ```
  In this case, there is a `AWS::SecretsManager::SecretTargetAttachment` generated to complete the final link between a Secrets Manager secret and the associated database by adding the database connection information to the secret JSON, which returns the ARN of the generated secret.
  In the context of extracting the IAM policy, we want to tell the `ResourceExtractor` how to handle the resource section of the IAM policy statement so that it is scoped down sufficiently.
  In this case rather than using a `Ref: LogicalIdForTheSecretTargetAttachment` we construct the ARN we want to use.
  Details in [API.md](API.md)


pkgId: 99d6eb7857f3726f9b3ec9fe76476991bf7aa4a15746980bea09695baf0c16d1
name: python-cdklabs.cdk-hyperledger-fabric-network-help
arch: noarch
version: 0.8.746
epoch: 0
release: 1
summary: Development documents and examples for cdklabs.cdk-hyperledger-fabric-network
url: https://github.com/cdklabs/cdk-hyperledger-fabric-network.git
rpm_license: MIT-0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdklabs.cdk-hyperledger-fabric-network-0.8.746-1.src.rpm
location_href: Packages/python-cdklabs.cdk-hyperledger-fabric-network-help-0.8.746-1.noarch.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/github/license/cdklabs/cdk-hyperledger-fabric-network?color=green)](https://opensource.org/licenses/MIT)
  [![release](https://img.shields.io/github/v/release/cdklabs/cdk-hyperledger-fabric-network?color=green)](https://github.com/cdklabs/cdk-hyperledger-fabric-network/releases)
  [![npm:version](https://img.shields.io/npm/v/@cdklabs/cdk-hyperledger-fabric-network?color=blue)](https://www.npmjs.com/package/@cdklabs/cdk-hyperledger-fabric-network)
  [![PyPi:version](https://img.shields.io/pypi/v/cdklabs.cdk-hyperledger-fabric-network?color=blue)](https://pypi.org/project/cdklabs.cdk-hyperledger-fabric-network/)
  [![Maven:version](https://img.shields.io/maven-central/v/io.github.cdklabs/cdk-hyperledger-fabric-network?color=blue&label=maven)](https://central.sonatype.dev/artifact/io.github.cdklabs/cdk-hyperledger-fabric-network/0.8.147)
  [![NuGet:version](https://img.shields.io/nuget/v/Cdklabs.CdkHyperledgerFabricNetwork?color=blue)](https://www.nuget.org/packages/Cdklabs.CdkHyperledgerFabricNetwork)

  This repository contains a CDK construct to deploy a Hyperledger Fabric network
  running on Amazon Managed Blockchain. It builds out a member and its nodes, a VPC
  and associated endpoint to access them, and a set of users enrolled on the network.

  The following functionality is planned for future releases:

  * Create channels on nodes
  * Instantiate chaincode on nodes



  Note that this construct requires [AWS CDK v2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_install).



  ```bash
  npm install --save @cdklabs/cdk-hyperledger-fabric-network
  ```



  ```bash
  pip3 install cdklabs.cdk-hyperledger-fabric-network
  ```



  Add the following to `pom.xml`:

  ```xml
  <dependency>
    <groupId>io.github.cdklabs</groupId>
    <artifactId>cdk-hyperledger-fabric-network</artifactId>
  </dependency>
  ```



  ```bash
  dotnet add package Cdklabs.CdkHyperledgerFabricNetwork
  ```



  A minimally complete deployment is shown below. By default, a standard network
  will be created running Hyperledger Fabric 1.4 with a single `bc.t3.small` node.

  ```python
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import { HyperledgerFabricNetwork } from '@cdklabs/cdk-hyperledger-fabric-network';

  class MyStack extends Stack {
    constructor(scope: Construct, id: string, props?: StackProps) {
      super(scope, id, props);
      new HyperledgerFabricNetwork(this, 'Example', {
        networkName: 'MyNetwork',
        memberName: 'MyMember',
      });
    }
  }
  ```

  The equivalent Python code is as follows:

  ```python
  from aws_cdk import Stack
  from cdklabs.cdk_hyperledger_fabric_network import HyperledgerFabricNetwork

  class MyStack(Stack):
      def __init__(self, scope, id, **kwargs):
          super().__init__(scope, id, **kwargs)
          HyperledgerFabricNetwork(
              self, 'Example',
              network_name='MyNetwork',
              member_name='MyMember',
          )
  ```

  The following is a more complex instantiation illustrating some of the options available.

  ```python
  new HyperledgerFabricNetwork(this, 'Example', {
    networkName: 'MyNetwork',
    networkDescription: 'This is my Hyperledger Fabric network',
    memberName: 'MyMember',
    networkDescription: 'This is my Hyperledger Fabric member',
    frameworkVersion: hyperledger.FrameworkVersion.VERSION_1_2,
    proposalDurationInHours: 48,
    thresholdPercentage: 75,
    nodes: [
      {
        availabilityZone: 'us-east-1a',
        instanceType: hyperledger.InstanceType.STANDARD5_LARGE,
      },
      {
        availabilityZone: 'us-east-1b',
        instanceType: hyperledger.InstanceType.STANDARD5_LARGE,
      },
    ],
    users: [
      { userId: 'AppUser1', affilitation: 'MyMember' },
      { userId: 'AppUser2', affilitation: 'MyMember.department1' },
    ],
  });
  ```

  See the [API Documentation](API.md) for details on all available input and output parameters.



  * [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/home.html)
  * [Amazon Managed Blockchain](https://aws.amazon.com/managed-blockchain/)
  * [Hyperledger Fabric](https://hyperledger-fabric.readthedocs.io/)
  * [Node Fabric SDK](https://hyperledger.github.io/fabric-sdk-node/release-1.4/index.html)
  * [Fabric Chaincode Node](https://hyperledger.github.io/fabric-chaincode-node/)



  Pull requests are welcomed. Please review the [Contributing Guidelines](CONTRIBUTING.md)
  and the [Code of Conduct](CODE_OF_CONDUCT.md).



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  * Jud Neer (judneer@amazon.com)
  * Vignesh Rajasingh (vrajasin@amazon.com)



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


pkgId: 5eb8e7dc16e017b996496f6cbe3158ab62961712db7fcb4f7341cf9bb9926b8e
name: python-cdklabs.ecs-codedeploy-help
arch: noarch
version: 0.0.354
epoch: 0
release: 1
summary: Development documents and examples for cdklabs.ecs-codedeploy
url: https://github.com/cdklabs/cdk-ecs-codedeploy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdklabs.ecs-codedeploy-0.0.354-1.src.rpm
location_href: Packages/python-cdklabs.ecs-codedeploy-help-0.0.354-1.noarch.rpm
checksum_type: sha256
description:
  [![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg)](https://constructs.dev/packages/@cdklabs/cdk-ecs-codedeploy)
  [![npm version](https://badge.fury.io/js/@cdklabs%2Fcdk-ecs-codedeploy.svg)](https://badge.fury.io/js/@cdklabs%2Fcdk-ecs-codedeploy)
  [![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.github.cdklabs/cdk-ecs-codedeploy/badge.svg)](https://maven-badges.herokuapp.com/maven-central/io.github.cdklabs/cdk-ecs-codedeploy)
  [![PyPI version](https://badge.fury.io/py/cdklabs.ecs-codedeploy.svg)](https://badge.fury.io/py/cdklabs.ecs-codedeploy)
  [![NuGet version](https://badge.fury.io/nu/Cdklabs.CdkEcsCodeDeploy.svg)](https://badge.fury.io/nu/Cdklabs.CdkEcsCodeDeploy)
  [![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/cdklabs/cdk-ecs-codedeploy)
  [![Mergify](https://img.shields.io/endpoint.svg?url=https://api.mergify.com/badges/cdklabs/cdk-ecs-codedeploy&style=flat)](https://mergify.io)

  This project contains CDK constructs to create CodeDeploy ECS deployments.



  <details><summary><strong>TypeScript</strong></summary>

  ```bash
  yarn add @cdklabs/cdk-ecs-codedeploy
  ```

  </details><details><summary><strong>Java</strong></summary>

  See https://mvnrepository.com/artifact/io.github.cdklabs/cdk-ecs-codedeploy

  </details><details><summary><strong>Python</strong></summary>

  See https://pypi.org/project/cdklabs.ecs-codedeploy/

  </details><details><summary><strong>C#</strong></summary>

  See https://www.nuget.org/packages/Cdklabs.CdkEcsCodeDeploy/

  </details>



  CodeDeploy for ECS can manage the deployment of new task definitions to ECS services.  Only 1 deployment construct can be defined for a given EcsDeploymentGroup.

  ```python




  EcsDeployment(
      deployment_group=deployment_group,
      target_service=TargetService(
          task_definition=task_definition,
          container_name="mycontainer",
          container_port=80
      )
  )
  ```

  The deployment will use the AutoRollbackConfig for the EcsDeploymentGroup unless it is overridden in the deployment:

  ```python




  EcsDeployment(
      deployment_group=deployment_group,
      target_service=TargetService(
          task_definition=task_definition,
          container_name="mycontainer",
          container_port=80
      ),
      auto_rollback=codeDeploy.AutoRollbackConfig(
          failed_deployment=True,
          deployment_in_alarm=True,
          stopped_deployment=False
      )
  )
  ```

  By default, the deployment will timeout after 30 minutes. The timeout value can be overridden:

  ```python




  EcsDeployment(
      deployment_group=deployment_group,
      target_service=TargetService(
          task_definition=task_definition,
          container_name="mycontainer",
          container_port=80
      ),
      timeout=Duration.minutes(60)
  )
  ```



  CodeDeploy can leverage Cloudwatch Alarms to trigger automatic rollbacks. The `ApiCanary` construct simplifies the process for creating CloudWatch Synthetics Canaries to monitor APIs. The following code demonstrates a canary that monitors https://xkcd.com/908/info.0.json and checks the JSON response to assert that `safe_title` has the value of `'The Cloud'`.

  ```python
  canary = ApiCanary(stack, "Canary",
      base_url="https://xkcd.com",
      duration_alarm_threshold=Duration.seconds(5),
      thread_count=5,
      steps=[ApiTestStep(
          name="info",
          path="/908/info.0.json",
          jmes_path="safe_title",
          expected_value="The Cloud"
      )
      ]
  )
  ```



  An L3 construct named `ApplicationLoadBalancedCodeDeployedFargateService` extends [ApplicationLoadBalancedFargateService](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs_patterns.ApplicationLoadBalancedFargateService.html) and adds support for deploying new versions of the service with AWS CodeDeploy. Additionally, an Amazon CloudWatch Synthetic canary is created via the `ApiCanary` construct and is monitored by the CodeDeploy deployment to trigger rollback if the canary begins to alarm.

  ```python



  service = ApplicationLoadBalancedCodeDeployedFargateService(stack, "Service",
      cluster=cluster,
      task_image_options=ApplicationLoadBalancedTaskImageOptions(
          image=image
      ),
      api_test_steps=[ApiTestStep(
          name="health",
          path="/health",
          jmes_path="status",
          expected_value="ok"
      )]
  )
  ```



  ```bash
  yarn install
  yarn build
  yarn test
  ```

  To run an integration test and update the snapshot, run:

  ```bash
  yarn integ:ecs-deployment:deploy
  ```

  To recreate snapshots for integration tests, run:

  ```bash
  yarn integ:snapshot-all
  ```



  See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.



  This project is licensed under the Apache-2.0 License.


pkgId: 9dd673233084c9e88cf69130a8afea4d3974b4b0c0146d67f93ff713bcd3b26f
name: python-cdktf-cdk8s-help
arch: noarch
version: 0.10.52
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdk8s
url: https://github.com/cdktf/cdktf-cdk8s.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdk8s-0.10.52-1.src.rpm
location_href: Packages/python-cdktf-cdk8s-help-0.10.52-1.noarch.rpm
checksum_type: sha256
description:
  ![Status: Tech Preview](https://img.shields.io/badge/status-experimental-EAAA32) [![Releases](https://img.shields.io/github/release/cdktf/cdktf-cdk8s.svg)](https://github.com/cdktf/cdktf-cdk8s/releases)
  [![LICENSE](https://img.shields.io/github/license/cdktf/cdktf-cdk8s.svg)](https://github.com/cdktf/cdktf-cdk8s/blob/main/LICENSE)
  [![build](https://github.com/cdktf/cdktf-cdk8s/actions/workflows/build.yml/badge.svg)](https://github.com/cdktf/cdktf-cdk8s/actions/workflows/build.yml)

  A compatibility layer for using [cdk8s](https://cdk8s.io/) constructs within Terraform CDK.

  The cdk8s adapter is in technical preview, which means it's a community supported project. It still requires extensive testing and polishing to mature into a HashiCorp officially supported project. Please [file issues](https://github.com/cdktf/cdktf-cdk8s/issues/new/choose) generously and detail your experience while using the library. We welcome your feedback.

  By using the software in this repository, you acknowledge that:

  * The cdk8s adapter is still in development, may change, and has not been released as a commercial product by HashiCorp and is not currently supported in any way by HashiCorp.
  * The cdk8s adapter is provided on an "as-is" basis, and may include bugs, errors, or other issues.
  * The cdk8s adapter is NOT INTENDED FOR PRODUCTION USE, use of the Software may result in unexpected results, loss of data, or other unexpected results, and HashiCorp disclaims any and all liability resulting from use of the cdk8s adapter.
  * HashiCorp reserves all rights to make all decisions about the features, functionality and commercial release (or non-release) of the cdk8s adapter, at any time and without any obligation or liability whatsoever.



  * `cdktf` >= 0.20.0
  * `cdk8s` >= 2.8.0
  * `constructs` >= 10.3.0



  ```python
  import { App, TerraformStack } from "cdktf";
  import { App as CDK8sApp, Chart } from "cdk8s";
  import { CDK8sProvider } from "cdktf-cdk8s";

  import { MyCdk8sChart } from "./my-cdk8s-chart";

  export class MyKubernetesStack extends TerraformStack {
    constructor(scope: Construct, name: string) {
      super(scope, name);

      const cdk8sApp = new CDK8sApp();

      // Configure your cdk8s application like usual
      new HelloKube(cdk8sApp, "my-chart");

      // For properties see https://registry.terraform.io/providers/hashicorp/kubernetes/latest/docs
      // Extends on the Provider class from @cdktf/provider-kubernetes
      new CDK8sProvider(this, "cdk8s-dev", {
        configPath: "./kubeconfig.yaml",
        configContext: "my-dev-cluster",

        // Only the cdk8sApp property is added
        // There is no need to run synth on the cdk8sApp, this is done by the provider
        cdk8sApp,
      });
    }
  }

  const app = new App();
  new MyStack(app, "cdktf-cdk8s");
  app.synth();
  ```



  We welcome your contribution. Please understand that the experimental nature of this repository means that contributing code may be a bit of a moving target. If you have an idea for an enhancement or bug fix, and want to take on the work yourself, please first [create an issue](https://github.com/cdktf/cdktf-cdk8s/issues/new/choose) so that we can discuss the implementation with you before you proceed with the work.

  You can review our [contribution guide](https://github.com/cdktf/.github/blob/main/CONTRIBUTING.md) to begin.


pkgId: 215822628cac495da30b58a9256fec426a4c23769f6a277ed5e30afad49ae7ea
name: python-cdktf-cdktf-provider-acme-help
arch: noarch
version: 11.9.2
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-acme
url: https://github.com/cdktf/cdktf-provider-acme.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-acme-11.9.2-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-acme-help-11.9.2-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.28.2/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-acme](https://www.npmjs.com/package/@cdktf/provider-acme).

  `npm install @cdktf/provider-acme`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-acme](https://pypi.org/project/cdktf-cdktf-provider-acme).

  `pipenv install cdktf-cdktf-provider-acme`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme).

  `dotnet add package HashiCorp.Cdktf.Providers.Acme`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-acme</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-acme-go`](https://github.com/cdktf/cdktf-provider-acme-go) package.

  `go get github.com/cdktf/cdktf-provider-acme-go/acme/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-acme-go/blob/main/acme/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-acme).



  This project is explicitly not tracking the Terraform acme provider version 1:1. In fact, it always tracks `latest` of `~> 2.10` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.28.2)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 677ed0ac11b469d1707b018ff20d56668d0c5cddf201fa1a1f559b0f38610559
name: python-cdktf-cdktf-provider-acme-help
arch: noarch
version: 11.9.3
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-acme
url: https://github.com/cdktf/cdktf-provider-acme.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-acme-11.9.3-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-acme-help-11.9.3-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.28.3/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-acme](https://www.npmjs.com/package/@cdktf/provider-acme).

  `npm install @cdktf/provider-acme`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-acme](https://pypi.org/project/cdktf-cdktf-provider-acme).

  `pipenv install cdktf-cdktf-provider-acme`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Acme).

  `dotnet add package HashiCorp.Cdktf.Providers.Acme`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-acme).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-acme</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-acme-go`](https://github.com/cdktf/cdktf-provider-acme-go) package.

  `go get github.com/cdktf/cdktf-provider-acme-go/acme/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-acme-go/blob/main/acme/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-acme).



  This project is explicitly not tracking the Terraform acme provider version 1:1. In fact, it always tracks `latest` of `~> 2.10` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform acme provider](https://registry.terraform.io/providers/vancluever/acme/2.28.3)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 8a67904be1a1e09c607832bdc81ad509f03a20b6aa6ff8f03239fe9432891b31
name: python-cdktf-cdktf-provider-aws-help
arch: noarch
version: 19.48.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-aws
url: https://github.com/cdktf/cdktf-provider-aws.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-aws-19.48.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-aws-help-19.48.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.82.1/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-aws](https://www.npmjs.com/package/@cdktf/provider-aws).

  `npm install @cdktf/provider-aws`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-aws](https://pypi.org/project/cdktf-cdktf-provider-aws).

  `pipenv install cdktf-cdktf-provider-aws`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Aws).

  `dotnet add package HashiCorp.Cdktf.Providers.Aws`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-aws).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-aws</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-aws-go`](https://github.com/cdktf/cdktf-provider-aws-go) package.

  `go get github.com/cdktf/cdktf-provider-aws-go/aws/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-aws-go/blob/main/aws/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-aws).



  This project is explicitly not tracking the Terraform aws provider version 1:1. In fact, it always tracks `latest` of `~> 5.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform aws provider](https://registry.terraform.io/providers/hashicorp/aws/5.82.1)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 3b7b7c8b33b5c2e8b9f2856bee1849cc8d9881b28ab6535058399b7776b2a717
name: python-cdktf-cdktf-provider-azurerm-help
arch: noarch
version: 13.14.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-azurerm
url: https://github.com/cdktf/cdktf-provider-azurerm.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-azurerm-13.14.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-azurerm-help-13.14.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform azurerm provider](https://registry.terraform.io/providers/hashicorp/azurerm/4.14.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-azurerm](https://www.npmjs.com/package/@cdktf/provider-azurerm).

  `npm install @cdktf/provider-azurerm`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-azurerm](https://pypi.org/project/cdktf-cdktf-provider-azurerm).

  `pipenv install cdktf-cdktf-provider-azurerm`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Azurerm](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Azurerm).

  `dotnet add package HashiCorp.Cdktf.Providers.Azurerm`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-azurerm](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-azurerm).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-azurerm</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-azurerm-go`](https://github.com/cdktf/cdktf-provider-azurerm-go) package.

  `go get github.com/cdktf/cdktf-provider-azurerm-go/azurerm/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-azurerm-go/blob/main/azurerm/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-azurerm).



  This project is explicitly not tracking the Terraform azurerm provider version 1:1. In fact, it always tracks `latest` of `~> 4.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform azurerm provider](https://registry.terraform.io/providers/hashicorp/azurerm/4.14.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 83be028742d23d48811cab34a678cdfc5700c12437baca67d87122a8e4e29c47
name: python-cdktf-cdktf-provider-databricks-help
arch: noarch
version: 13.27.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-databricks
url: https://github.com/cdktf/cdktf-provider-databricks.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-databricks-13.27.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-databricks-help-13.27.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform databricks provider](https://registry.terraform.io/providers/databricks/databricks/1.62.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-databricks](https://www.npmjs.com/package/@cdktf/provider-databricks).

  `npm install @cdktf/provider-databricks`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-databricks](https://pypi.org/project/cdktf-cdktf-provider-databricks).

  `pipenv install cdktf-cdktf-provider-databricks`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Databricks](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Databricks).

  `dotnet add package HashiCorp.Cdktf.Providers.Databricks`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-databricks](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-databricks).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-databricks</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-databricks-go`](https://github.com/cdktf/cdktf-provider-databricks-go) package.

  `go get github.com/cdktf/cdktf-provider-databricks-go/databricks/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-databricks-go/blob/main/databricks/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-databricks).



  This project is explicitly not tracking the Terraform databricks provider version 1:1. In fact, it always tracks `latest` of `~> 1.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform databricks provider](https://registry.terraform.io/providers/databricks/databricks/1.62.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 46d050bdd6678237b3f782347c335a6a858c6e41681a0cb3378b9298e27be396
name: python-cdktf-cdktf-provider-datadog-help
arch: noarch
version: 11.15.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-datadog
url: https://github.com/cdktf/cdktf-provider-datadog.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-datadog-11.15.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-datadog-help-11.15.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform datadog provider](https://registry.terraform.io/providers/DataDog/datadog/3.50.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-datadog](https://www.npmjs.com/package/@cdktf/provider-datadog).

  `npm install @cdktf/provider-datadog`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-datadog](https://pypi.org/project/cdktf-cdktf-provider-datadog).

  `pipenv install cdktf-cdktf-provider-datadog`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Datadog](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Datadog).

  `dotnet add package HashiCorp.Cdktf.Providers.Datadog`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-datadog](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-datadog).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-datadog</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-datadog-go`](https://github.com/cdktf/cdktf-provider-datadog-go) package.

  `go get github.com/cdktf/cdktf-provider-datadog-go/datadog/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-datadog-go/blob/main/datadog/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-datadog).



  This project is explicitly not tracking the Terraform datadog provider version 1:1. In fact, it always tracks `latest` of `~> 3.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform datadog provider](https://registry.terraform.io/providers/DataDog/datadog/3.50.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 2c0dfeea96154597c4b60e831de8f2fec0cb27c32e2c8a2510d9f1f3f84b8239
name: python-cdktf-cdktf-provider-digitalocean-help
arch: noarch
version: 11.12.1
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-digitalocean
url: https://github.com/cdktf/cdktf-provider-digitalocean.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-digitalocean-11.12.1-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-digitalocean-help-11.12.1-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform digitalocean provider](https://registry.terraform.io/providers/digitalocean/digitalocean/2.46.1/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-digitalocean](https://www.npmjs.com/package/@cdktf/provider-digitalocean).

  `npm install @cdktf/provider-digitalocean`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-digitalocean](https://pypi.org/project/cdktf-cdktf-provider-digitalocean).

  `pipenv install cdktf-cdktf-provider-digitalocean`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Digitalocean](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Digitalocean).

  `dotnet add package HashiCorp.Cdktf.Providers.Digitalocean`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-digitalocean](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-digitalocean).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-digitalocean</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-digitalocean-go`](https://github.com/cdktf/cdktf-provider-digitalocean-go) package.

  `go get github.com/cdktf/cdktf-provider-digitalocean-go/digitalocean/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-digitalocean-go/blob/main/digitalocean/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-digitalocean).



  This project is explicitly not tracking the Terraform digitalocean provider version 1:1. In fact, it always tracks `latest` of `~> 2.19` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform digitalocean provider](https://registry.terraform.io/providers/digitalocean/digitalocean/2.46.1)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: ca4523e3265eaa06da7000e0235288d476349a07f0295ff9321af05e0b9d7aa4
name: python-cdktf-cdktf-provider-google-beta-help
arch: noarch
version: 14.13.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-google-beta
url: https://github.com/cdktf/cdktf-provider-googlebeta.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-google-beta-14.13.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-google-beta-help-14.13.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform google-beta provider](https://registry.terraform.io/providers/hashicorp/google-beta/6.14.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-google-beta](https://www.npmjs.com/package/@cdktf/provider-google-beta).

  `npm install @cdktf/provider-google-beta`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-google_beta](https://pypi.org/project/cdktf-cdktf-provider-google_beta).

  `pipenv install cdktf-cdktf-provider-google_beta`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.GoogleBeta](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.GoogleBeta).

  `dotnet add package HashiCorp.Cdktf.Providers.GoogleBeta`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-google-beta](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-google-beta).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-google-beta</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-googlebeta-go`](https://github.com/cdktf/cdktf-provider-googlebeta-go) package.

  `go get github.com/cdktf/cdktf-provider-googlebeta-go/googlebeta/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-googlebeta-go/blob/main/googlebeta/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-google-beta).



  This project is explicitly not tracking the Terraform google-beta provider version 1:1. In fact, it always tracks `latest` of `~> 6.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform google-beta provider](https://registry.terraform.io/providers/hashicorp/google-beta/6.14.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: f852ef36d144e9d6e3183523131ad8305a7eacbe92b0b253c849c08a78760074
name: python-cdktf-cdktf-provider-google-help
arch: noarch
version: 14.13.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-google
url: https://github.com/cdktf/cdktf-provider-google.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-google-14.13.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-google-help-14.13.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform google provider](https://registry.terraform.io/providers/hashicorp/google/6.14.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-google](https://www.npmjs.com/package/@cdktf/provider-google).

  `npm install @cdktf/provider-google`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-google](https://pypi.org/project/cdktf-cdktf-provider-google).

  `pipenv install cdktf-cdktf-provider-google`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Google](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Google).

  `dotnet add package HashiCorp.Cdktf.Providers.Google`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-google](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-google).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-google</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-google-go`](https://github.com/cdktf/cdktf-provider-google-go) package.

  `go get github.com/cdktf/cdktf-provider-google-go/google/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-google-go/blob/main/google/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-google).



  This project is explicitly not tracking the Terraform google provider version 1:1. In fact, it always tracks `latest` of `~> 6.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform google provider](https://registry.terraform.io/providers/hashicorp/google/6.14.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 63bc065eddeb0f70b868dfa017f0309df75678b3f115b8f3d9e6ac6674f4356d
name: python-cdktf-cdktf-provider-hcp-help
arch: noarch
version: 9.21.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-hcp
url: https://github.com/cdktf/cdktf-provider-hcp.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-hcp-9.21.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-hcp-help-9.21.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform hcp provider](https://registry.terraform.io/providers/hashicorp/hcp/0.101.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-hcp](https://www.npmjs.com/package/@cdktf/provider-hcp).

  `npm install @cdktf/provider-hcp`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-hcp](https://pypi.org/project/cdktf-cdktf-provider-hcp).

  `pipenv install cdktf-cdktf-provider-hcp`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Hcp](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Hcp).

  `dotnet add package HashiCorp.Cdktf.Providers.Hcp`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-hcp](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-hcp).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-hcp</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-hcp-go`](https://github.com/cdktf/cdktf-provider-hcp-go) package.

  `go get github.com/cdktf/cdktf-provider-hcp-go/hcp/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-hcp-go/blob/main/hcp/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-hcp).



  This project is explicitly not tracking the Terraform hcp provider version 1:1. In fact, it always tracks `latest` of `~> 0.45` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform hcp provider](https://registry.terraform.io/providers/hashicorp/hcp/0.101.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 47d2a5428573961787ab916989afe22af9ce2a4fd20d4bb057bc5afca4782d7d
name: python-cdktf-cdktf-provider-mongodbatlas-help
arch: noarch
version: 7.9.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-mongodbatlas
url: https://github.com/cdktf/cdktf-provider-mongodbatlas.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-mongodbatlas-7.9.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-mongodbatlas-help-7.9.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform mongodbatlas provider](https://registry.terraform.io/providers/mongodb/mongodbatlas/1.23.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-mongodbatlas](https://www.npmjs.com/package/@cdktf/provider-mongodbatlas).

  `npm install @cdktf/provider-mongodbatlas`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-mongodbatlas](https://pypi.org/project/cdktf-cdktf-provider-mongodbatlas).

  `pipenv install cdktf-cdktf-provider-mongodbatlas`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Mongodbatlas](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Mongodbatlas).

  `dotnet add package HashiCorp.Cdktf.Providers.Mongodbatlas`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-mongodbatlas](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-mongodbatlas).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-mongodbatlas</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-mongodbatlas-go`](https://github.com/cdktf/cdktf-provider-mongodbatlas-go) package.

  `go get github.com/cdktf/cdktf-provider-mongodbatlas-go/mongodbatlas/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-mongodbatlas-go/blob/main/mongodbatlas/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-mongodbatlas).



  This project is explicitly not tracking the Terraform mongodbatlas provider version 1:1. In fact, it always tracks `latest` of `~> 1.8` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform mongodbatlas provider](https://registry.terraform.io/providers/mongodb/mongodbatlas/1.23.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 225710d6887479130f5fba2a399f6d3d5b3ee34ec0942de45a4603262ebbc852
name: python-cdktf-cdktf-provider-opentelekomcloud-help
arch: noarch
version: 11.1.20
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-opentelekomcloud
url: https://github.com/cdktf/cdktf-provider-opentelekomcloud.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-opentelekomcloud-11.1.20-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-opentelekomcloud-help-11.1.20-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform opentelekomcloud provider](https://registry.terraform.io/providers/opentelekomcloud/opentelekomcloud/1.36.27/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-opentelekomcloud](https://www.npmjs.com/package/@cdktf/provider-opentelekomcloud).

  `npm install @cdktf/provider-opentelekomcloud`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-opentelekomcloud](https://pypi.org/project/cdktf-cdktf-provider-opentelekomcloud).

  `pipenv install cdktf-cdktf-provider-opentelekomcloud`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Opentelekomcloud](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Opentelekomcloud).

  `dotnet add package HashiCorp.Cdktf.Providers.Opentelekomcloud`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-opentelekomcloud](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-opentelekomcloud).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-opentelekomcloud</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-opentelekomcloud-go`](https://github.com/cdktf/cdktf-provider-opentelekomcloud-go) package.

  `go get github.com/cdktf/cdktf-provider-opentelekomcloud-go/opentelekomcloud/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-opentelekomcloud-go/blob/main/opentelekomcloud/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-opentelekomcloud).



  This project is explicitly not tracking the Terraform opentelekomcloud provider version 1:1. In fact, it always tracks `latest` of `~> 1.26` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform opentelekomcloud provider](https://registry.terraform.io/providers/opentelekomcloud/opentelekomcloud/1.36.27)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 14fb46b8c21c0f65274ee45050778209abecd4ea815eff41565ba91eb73b066a
name: python-cdktf-cdktf-provider-pagerduty-help
arch: noarch
version: 13.14.2
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-pagerduty
url: https://github.com/cdktf/cdktf-provider-pagerduty.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-pagerduty-13.14.2-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-pagerduty-help-13.14.2-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform pagerduty provider](https://registry.terraform.io/providers/PagerDuty/pagerduty/3.18.2/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-pagerduty](https://www.npmjs.com/package/@cdktf/provider-pagerduty).

  `npm install @cdktf/provider-pagerduty`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-pagerduty](https://pypi.org/project/cdktf-cdktf-provider-pagerduty).

  `pipenv install cdktf-cdktf-provider-pagerduty`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Pagerduty](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Pagerduty).

  `dotnet add package HashiCorp.Cdktf.Providers.Pagerduty`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-pagerduty](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-pagerduty).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-pagerduty</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-pagerduty-go`](https://github.com/cdktf/cdktf-provider-pagerduty-go) package.

  `go get github.com/cdktf/cdktf-provider-pagerduty-go/pagerduty/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-pagerduty-go/blob/main/pagerduty/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-pagerduty).



  This project is explicitly not tracking the Terraform pagerduty provider version 1:1. In fact, it always tracks `latest` of `~> 3.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform pagerduty provider](https://registry.terraform.io/providers/PagerDuty/pagerduty/3.18.2)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 09b6ca24cbc232fe8581da3c7b51c278eca05778a004a9a96d899ec45ab9e4f3
name: python-cdktf-cdktf-provider-spotinst-help
arch: noarch
version: 13.38.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-spotinst
url: https://github.com/cdktf/cdktf-provider-spotinst.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-spotinst-13.38.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-spotinst-help-13.38.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform spotinst provider](https://registry.terraform.io/providers/spotinst/spotinst/1.202.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-spotinst](https://www.npmjs.com/package/@cdktf/provider-spotinst).

  `npm install @cdktf/provider-spotinst`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-spotinst](https://pypi.org/project/cdktf-cdktf-provider-spotinst).

  `pipenv install cdktf-cdktf-provider-spotinst`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Spotinst](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Spotinst).

  `dotnet add package HashiCorp.Cdktf.Providers.Spotinst`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-spotinst](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-spotinst).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-spotinst</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-spotinst-go`](https://github.com/cdktf/cdktf-provider-spotinst-go) package.

  `go get github.com/cdktf/cdktf-provider-spotinst-go/spotinst/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-spotinst-go/blob/main/spotinst/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-spotinst).



  This project is explicitly not tracking the Terraform spotinst provider version 1:1. In fact, it always tracks `latest` of `~> 1.0` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform spotinst provider](https://registry.terraform.io/providers/spotinst/spotinst/1.202.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 974a5cc57bd70ff71d8b0a438d9e568826aaf1100795b819d3f973c4e343d58a
name: python-cdktf-cdktf-provider-tfe-help
arch: noarch
version: 11.11.0
epoch: 0
release: 1
summary: Development documents and examples for cdktf-cdktf-provider-tfe
url: https://github.com/cdktf/cdktf-provider-tfe.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-cdktf-provider-tfe-11.11.0-1.src.rpm
location_href: Packages/python-cdktf-cdktf-provider-tfe-help-11.11.0-1.noarch.rpm
checksum_type: sha256
description:
  This repo builds and publishes the [Terraform tfe provider](https://registry.terraform.io/providers/hashicorp/tfe/0.62.0/docs) bindings for [CDK for Terraform](https://cdk.tf).





  The npm package is available at [https://www.npmjs.com/package/@cdktf/provider-tfe](https://www.npmjs.com/package/@cdktf/provider-tfe).

  `npm install @cdktf/provider-tfe`



  The PyPI package is available at [https://pypi.org/project/cdktf-cdktf-provider-tfe](https://pypi.org/project/cdktf-cdktf-provider-tfe).

  `pipenv install cdktf-cdktf-provider-tfe`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Tfe](https://www.nuget.org/packages/HashiCorp.Cdktf.Providers.Tfe).

  `dotnet add package HashiCorp.Cdktf.Providers.Tfe`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-tfe](https://mvnrepository.com/artifact/com.hashicorp/cdktf-provider-tfe).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-provider-tfe</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-provider-tfe-go`](https://github.com/cdktf/cdktf-provider-tfe-go) package.

  `go get github.com/cdktf/cdktf-provider-tfe-go/tfe/<version>`

  Where `<version>` is the version of the prebuilt provider you would like to use e.g. `v11`. The full module name can be found
  within the [go.mod](https://github.com/cdktf/cdktf-provider-tfe-go/blob/main/tfe/go.mod#L1) file.



  Find auto-generated docs for this provider here:

  * [Typescript](./docs/API.typescript.md)
  * [Python](./docs/API.python.md)
  * [Java](./docs/API.java.md)
  * [C#](./docs/API.csharp.md)
  * [Go](./docs/API.go.md)

  You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktf/provider-tfe).



  This project is explicitly not tracking the Terraform tfe provider version 1:1. In fact, it always tracks `latest` of `~> 0.33` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).

  These are the upstream dependencies:

  * [CDK for Terraform](https://cdk.tf)
  * [Terraform tfe provider](https://registry.terraform.io/providers/hashicorp/tfe/0.62.0)
  * [Terraform Engine](https://terraform.io)

  If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.



  Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:

  * [Create bug report](https://cdk.tf/bug)
  * [Create feature request](https://cdk.tf/feature)





  This is mostly based on [Projen](https://github.com/projen/projen), which takes care of generating the entire repository.



  There's a custom [project builder](https://github.com/cdktf/cdktf-provider-project) which encapsulate the common settings for all `cdktf` prebuilt providers.



  The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).



  The repository is managed by [CDKTF Repository Manager](https://github.com/cdktf/cdktf-repository-manager/).


pkgId: 088a070a376c1a9d3900ed2d9432b083a2bcddc5ec921697ad5396d784ac88e5
name: python-cdktf-gitlab-runner-help
arch: noarch
version: 0.0.1117
epoch: 0
release: 1
summary: Development documents and examples for cdktf-gitlab-runner
url: https://github.com/neilkuan/cdktf-gitlab-runner.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-gitlab-runner-0.0.1117-1.src.rpm
location_href: Packages/python-cdktf-gitlab-runner-help-0.0.1117-1.noarch.rpm
checksum_type: sha256
description:
  [![NPM version](https://badge.fury.io/js/cdktf-gitlab-runner.svg)](https://badge.fury.io/js/cdktf-gitlab-runner)
  [![PyPI version](https://badge.fury.io/py/cdktf-gitlab-runner.svg)](https://badge.fury.io/py/cdktf-gitlab-runner)
  ![Release](https://github.com/neilkuan/cdktf-gitlab-runner/workflows/release/badge.svg)

  ![Downloads](https://img.shields.io/badge/-DOWNLOADS:-brightgreen?color=gray)
  ![npm](https://img.shields.io/npm/dt/cdktf-gitlab-runner?label=npm&color=orange)
  ![PyPI](https://img.shields.io/pypi/dm/cdktf-gitlab-runner?label=pypi&color=blue)



  Use CDK fo Terraform to create gitlab runner, and use [gitlab runner](https://gitlab.com/gitlab-org/gitlab-runner) to help you execute your Gitlab Pipeline Job.

  > GitLab Runner is the open source project that is used to run your CI/CD jobs and send the results back to GitLab. [(source repo)](https://gitlab.com/gitlab-org/gitlab-runner)



  * Instance Manager Group
  * Auto Register Gitlab Runner
  * Auto Unregister Gitlab Runner ([when destroy and shutdown](https://cloud.google.com/compute/docs/shutdownscript))
  * Support [preemptible](https://cloud.google.com/compute/docs/instances/preemptible)



  ```bash
  mkdir demo
  cd demo
  cdktf init --template typescript --local
  ```



  ```bash
  yarn add cdktf-gitlab-runner
  or
  npm i cdktf-gitlab-runner
  ```



  ```python
  import * as gcp from '@cdktf/provider-google';
  import * as cdktf from 'cdktf';
  import { Construct } from 'constructs';
  import { GitlabRunnerAutoscaling } from './index';


  export class IntegDefaultStack extends cdktf.TerraformStack {
    constructor(scope: Construct, id: string) {
      super(scope, id);
      const local = 'asia-east1';
      const projectId = `${process.env.PROJECT_ID}`;
      const provider = new gcp.GoogleProvider(this, 'GoogleAuth', {
        region: local,
        zone: local+'-c',
        project: projectId,
      });
      new GitlabRunnerAutoscaling(this, 'GitlabRunnerAutoscaling', {
        gitlabToken: `${process.env.GITLAB_TOKEN}`,
        provider,
      });
    }
  }


  const app = new cdktf.App();
  new IntegDefaultStack(app, 'gitlab-runner');
  app.synth();
  ```


pkgId: fec670cb8f4cdecd4c0003244579e8111dd6d9ac283aea5bcc40d5d5f588094f
name: python-cdktf-tf-module-stack-help
arch: noarch
version: 5.0.43
epoch: 0
release: 1
summary: Development documents and examples for cdktf-tf-module-stack
url: https://github.com/cdktf/cdktf-tf-module-stack.git
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdktf-tf-module-stack-5.0.43-1.src.rpm
location_href: Packages/python-cdktf-tf-module-stack-help-5.0.43-1.noarch.rpm
checksum_type: sha256
description:
  ![Status: Tech Preview](https://img.shields.io/badge/status-experimental-EAAA32) [![Releases](https://img.shields.io/github/release/cdktf/cdktf-tf-module-stack.svg)](https://github.com/cdktf/cdktf-tf-module-stack/releases)
  [![LICENSE](https://img.shields.io/github/license/cdktf/cdktf-tf-module-stack.svg)](https://github.com/cdktf/cdktf-tf-module-stack/blob/main/LICENSE)
  [![build](https://github.com/cdktf/cdktf-tf-module-stack/actions/workflows/build.yml/badge.svg)](https://github.com/cdktf/cdktf-tf-module-stack/actions/workflows/build.yml)

  A drop-in replacement for cdktf.TerraformStack that lets you define Terraform modules as constructs.

  *cdktf-tf-module-stack* is in technical preview, which means it's a community supported project. It still requires extensive testing and polishing to mature into a HashiCorp officially supported project. Please [file issues](https://github.com/cdktf/cdktf-tf-module-stack/issues/new/choose) generously and detail your experience while using the library. We welcome your feedback.

  By using the software in this repository, you acknowledge that:

  * *cdktf-tf-module-stack* is still in development, may change, and has not been released as a commercial product by HashiCorp and is not currently supported in any way by HashiCorp.
  * *cdktf-tf-module-stack* is provided on an "as-is" basis, and may include bugs, errors, or other issues.
  * *cdktf-tf-module-stack* is NOT INTENDED FOR PRODUCTION USE, use of the Software may result in unexpected results, loss of data, or other unexpected results, and HashiCorp disclaims any and all liability resulting from use of *cdktf-tf-module-stack*.
  * HashiCorp reserves all rights to make all decisions about the features, functionality and commercial release (or non-release) of *cdktf-tf-module-stack*, at any time and without any obligation or liability whatsoever.



  * `cdktf` >= 0.20.0
  * `constructs` >= 10.0.25





  The npm package is available at [https://www.npmjs.com/package/@cdktf/tf-module-stack](https://www.npmjs.com/package/@cdktf/tf-module-stack).

  `npm install @cdktf/tf-module-stack`

  NOTE: Originally, this package was named `cdktf-tf-module-stack`, and the legacy versions (<= 0.2.0) can be found on npm [here](https://www.npmjs.com/package/cdktf-tf-module-stack).



  The PyPI package is available at [https://pypi.org/project/cdktf-tf-module-stack](https://pypi.org/project/cdktf-tf-module-stack).

  `pipenv install cdktf-tf-module-stack`



  The Nuget package is available at [https://www.nuget.org/packages/HashiCorp.Cdktf.TfModuleStack](https://www.nuget.org/packages/HashiCorp.Cdktf.TfModuleStack).

  `dotnet add package HashiCorp.Cdktf.TfModuleStack`



  The Maven package is available at [https://mvnrepository.com/artifact/com.hashicorp/cdktf-tf-module-stack](https://mvnrepository.com/artifact/com.hashicorp/cdktf-tf-module-stack).

  ```
  <dependency>
      <groupId>com.hashicorp</groupId>
      <artifactId>cdktf-tf-module-stack</artifactId>
      <version>[REPLACE WITH DESIRED VERSION]</version>
  </dependency>
  ```



  The go package is generated into the [`github.com/cdktf/cdktf-tf-module-stack-go`](https://github.com/cdktf/cdktf-tf-module-stack-go) package.

  `go get github.com/cdktf/cdktf-tf-module-stack-go/tfmodulestack`





  ```python
  import { App } from "cdktf";
  import {
    TFModuleStack,
    TFModuleVariable,
    TFModuleOutput,
    ProviderRequirement,
  } from "@cdktf/tf-module-stack";
  import { Resource } from '@cdktf/provider-null/lib/resource';

  class MyAwesomeModule extends TFModuleStack {
    constructor(scope: Construct, id: string) {
      super(scope, id);

      new ProviderRequirement(this, "null", "~> 2.0");
      const resource = new Resource(this, "resource");

      new TFModuleVariable(this, "my_var", {
        type: "string",
        description: "A variable",
        default: "default",
      });

      new TFModuleOutput(this, "my_output", {
        value: resource.id,
      });
    }
  }

  const app = new App();
  new MyAwesomeModule(app, "my-awesome-module");
  app.synth();
  ```



  ```python
  from constructs import Construct
  from cdktf import App, TerraformStack
  from imports.null.resource import Resource
  from cdktf_tf_module_stack import TFModuleStack, TFModuleVariable, TFModuleOutput, ProviderRequirement


  class MyAwesomeModule(TFModuleStack):
      def __init__(self, scope: Construct, ns: str):
          super().__init__(scope, ns)

          ProviderRequirement(self, "null", provider_version_constraint="~> 2.0")

          TFModuleVariable(self, "my_var", type="string", description="A variable", default="default")

          resource = Resource(self, "resource")

          TFModuleOutput(self, "my_output", value=resource.id)


  app = App()
  MyAwesomeModule(app, "my-awesome-module")
  app.synth()
  ```

  This will synthesize a Terraform JSON file that looks like this:

  ```json
  {
    "output": {
      "my_output": [
        {
          "value": "${null_resource.resource.id}"
        }
      ]
    },
    "resource": {
      "null_resource": {
        "resource": {}
      }
    },
    "terraform": {
      "required_providers": {
        "null": {
          "source": "null",
          "version": "~> 2.0"
        }
      },
      "variable": {
        "my_var": {
          "default": "default",
          "description": "A variable",
          "type": "string"
        }
      }
    }
  }
  ```

  Please note that the provider section is missing, so that the Terraform Workspace using the generated module can be used with any provider matching the version.


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


pkgId: 1bf2f130f400fce2b3062c7e83192cd86800c4abbb7459547bc5185cae573704
name: python-cdmx-njsscan-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for cdmx-njsscan
url: https://github.com/cdmx1/njsscan
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdmx-njsscan-1.0.2-1.src.rpm
location_href: Packages/python-cdmx-njsscan-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  - nodejs-extensions:
    - .js
    template-extensions:
    - .new
    - .hbs
    - ''
    ignore-filenames:
    - skip.js
    ignore-paths:
    - __MACOSX
    - skip_dir
    - node_modules
    ignore-extensions:
    - .jsx
    ignore-rules:
    - regex_injection_dos
    - pug_jade_template
    severity-filter:
    - WARNING
    - ERROR
  ```

  You can suppress findings from javascript source files by adding the comment `// njsscan-ignore: rule_id1, rule_id2` to the line that trigger the findings.
  Example:
  ```javascript
  app.get('/some/redirect', function (req, res) {
      var target = req.param("target");
      res.redirect(target); // njsscan-ignore: express_open_redirect
  });
  ```

  You can enable njsscan in your CI/CD or DevSecOps pipelines.

  Add the following to the file `.github/workflows/njsscan.yml`.
  ```yaml
  name: njsscan
  on:
    push:
      branches: [ master, main ]
    pull_request:
      branches: [ master, main ]
  jobs:
    njsscan:
      runs-on: ubuntu-latest
      name: njsscan check
      steps:
      - name: Checkout the code
        uses: actions/checkout@v4.2.2
      - uses: actions/setup-python@v5.3.0
        with:
          python-version: '3.12'
      - name: nodejsscan scan
        id: njsscan
        uses: ajinabraham/njsscan-action@master
        with:
          args: '.'
  ```
  Example: [dvna with njsscan github action](https://github.com/ajinabraham/dvna/actions?query=workflow%3Anjsscan)

  Add the following to the file `.github/workflows/njsscan_sarif.yml`.
  ```yaml
  name: njsscan sarif
  on:
    push:
      branches: [ master, main ]
    pull_request:
      branches: [ master, main ]
  jobs:
    njsscan:
      runs-on: ubuntu-latest
      name: njsscan code scanning
      steps:
      - name: Checkout the code
        uses: actions/checkout@v4.2.2
      - uses: actions/setup-python@v5.3.0
        with:
          python-version: '3.12'
      - name: nodejsscan scan
        id: njsscan
        uses: ajinabraham/njsscan-action@master
        with:
          args: '. --sarif --output results.sarif || true'
      - name: Upload njsscan report
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: results.sarif
  ```
  ![nodejsscan web ui](https://user-images.githubusercontent.com/4301109/99230041-cfe29500-27bc-11eb-8baa-d5b30e21348d.png)

  Add the following to the file `.gitlab-ci.yml`.
  ```yaml
  stages:
      - test
  njsscan:
      image: python
      before_script:
          - pip3 install --upgrade njsscan
      script:
          - njsscan .
  ```
  Example: [dvna with njsscan gitlab](https://gitlab.com/ajinabraham/dvna/-/jobs/602110439)

  Add the following to the file `.travis.yml`.
  ```yaml
  language: python
  install:
      - pip3 install --upgrade njsscan
  script:
      - njsscan .
  ```

  Add the following to the file `.circleci/config.yaml`
  ```yaml
  version: 2.1
  jobs:
    njsscan:
      docker:
        - image: cimg/python:3.9.6
      steps:
        - checkout
        - run:
            name: Install njsscan
            command: pip install --upgrade njsscan
        - run:
             name: njsscan check
             command: njsscan .
  ```


  ```bash
  docker pull opensecurity/njsscan
  docker run -v /path-to-source-dir:/src opensecurity/njsscan /src
  ```

  ```
  docker build -t njsscan .
  docker run -v /path-to-source-dir:/src njsscan /src
  ```


pkgId: ebbbce1e275e7ea59db8306522c091d532b923e9cee64db7edeca0a1a4ecd3ed
name: python-cdp-sdk-help
arch: noarch
version: 0.13.0
epoch: 0
release: 1
summary: Development documents and examples for cdp-sdk
url: https://pypi.org/project/cdp-sdk/
rpm_license: LICENSE.md
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdp-sdk-0.13.0-1.src.rpm
location_href: Packages/python-cdp-sdk-help-0.13.0-1.noarch.rpm
checksum_type: sha256
description:
  The CDP Python SDK enables the simple integration of crypto into your app.
  By calling Coinbase's CDP APIs, the SDK allows you to provision crypto wallets,
  send crypto into/out of those wallets, track wallet balances, and trade crypto from
  one asset into another.

  **CDP SDK v0 is a pre-alpha release, which means that the APIs and SDK methods are subject to change. We will continuously release updates to support new capabilities and improve the developer experience.**



  - [CDP API Documentation](https://docs.cdp.coinbase.com/platform-apis/docs/welcome)
  - [CDP SDK Python Documentation](https://coinbase.github.io/cdp-sdk-python/)



  - Python 3.10+
  - Poetry for package management and tooling
    - [Poetry Installation Instructions](https://python-poetry.org/docs/#installation)



  Before using the SDK, ensure that you have the correct version of Python installed. The SDK requires Python 3.10 or higher. You can check your Python version by running the following code:

  ```bash
  python --version
  pip --version
  ```

  If you need to upgrade your Python version, you can download and install the latest version of Python from the [official Python website](https://www.python.org/downloads/).
  For `pip`, refer to the [official pip documentation](https://pip.pypa.io/en/stable/installation/) for installation instructions.



  ```bash
  pip install cdp-sdk
  ```

  if you prefer to manage dependencies with Poetry:
  ```bash
  poetry add cdp-sdk
  ```



  To start a Python REPL:

  ```bash
  python
  ```





  To start, [create a CDP API key](https://portal.cdp.coinbase.com/access/api). Then, initialize the CDP SDK by passing your API key name and API key's private key via the `configure` method:

  ```python
  from cdp import *

  api_key_name = "Copy your API key name here."

  api_key_private_key = "Copy your API key's private key here."

  Cdp.configure(api_key_name, api_key_private_key)

  print("CDP SDK has been successfully configured with CDP API key.")
  ```

  Another way to initialize the SDK is by sourcing the API key from the JSON file that contains your API key,
  downloaded from the CDP portal.

  ```python
  Cdp.configure_from_json("~/Downloads/cdp_api_key.json")

  print("CDP SDK has been successfully configured from JSON file.")
  ```

  This will allow you to authenticate with the Platform APIs.

  If you are using a CDP [Server-Signer](https://docs.cdp.coinbase.com/mpc-wallet/docs/serversigners) to manage your private keys, enable it with

  ```python
  Cdp.use_server_signer = True
  ```

  Now create a wallet. Wallets are created with a single default address.

  ```python

  wallet1 = Wallet.create()

  print(f"Wallet successfully created: {wallet1}")
  ```

  Wallets come with a single default address, accessible via `default_address`:

  ```python

  address = wallet1.default_address
  ```



  Wallets do not have funds on them to start. For Base Sepolia testnet, we provide a `faucet` method to fund your wallet with
  testnet ETH. You are allowed one faucet claim per 24-hour window.

  ```python

  faucet_tx = wallet1.faucet()


  faucet_tx.wait()

  print(f"Faucet transaction successfully completed: {faucet_tx}")
  ```



  See [Transfers](https://docs.cdp.coinbase.com/wallets/docs/transfers) for more information.

  Now that your faucet transaction has successfully completed, you can send the funds in your wallet to another wallet.
  The code below creates another wallet, and uses the `transfer` function to send testnet ETH from the first wallet to
  the second:

  ```python

  wallet2 = Wallet.create()

  print(f"Wallet successfully created: {wallet2}")

  transfer = wallet1.transfer(0.00001, "eth", wallet2).wait()

  print(f"Transfer successfully completed: {transfer}")
  ```



  To transfer USDC without needing to hold ETH for gas, you can use the `transfer` method with the `gasless` option set to `True`.

  ```python

  wallet3 = Wallet.create()

  print(f"Wallet successfully created: {wallet3}")


  usdc_faucet_tx = wallet1.faucet("usdc")


  usdc_faucet_tx.wait()

  print(f"Faucet transaction successfully completed: {usdc_faucet_tx}")

  transfer = wallet1.transfer(0.00001, "usdc", wallet3, gasless=True).wait()
  ```



  ```python

  list(address.transfers())
  ```



  See [Trades](https://docs.cdp.coinbase.com/wallets/docs/trades) for more information.

  ```python
  wallet = Wallet.create("base-mainnet")

  print(f"Wallet successfully created: {wallet}")
  print(f"Send `base-mainnet` ETH to wallets default address: {wallet.default_address.address_id}")

  trade = wallet.trade(0.00001, "eth", "usdc").wait()

  print(f"Trade successfully completed: {trade}")
  ```



  ```python

  list(address.trades())
  ```



  The SDK creates wallets with [Developer-Managed (1-1)](https://docs.cdp.coinbase.com/mpc-wallet/docs/wallets#developer-managed-wallets) keys by default, which means you are responsible for securely storing the keys required to re-instantiate wallets. The below code walks you through how to export a wallet and store it in a secure location.

  ```python

  data = wallet.export_data()
  ```

  In order to persist the data for the wallet, you will need to implement a store method to store the data export in a secure location. If you do not store the wallet in a secure location you will lose access to the wallet and all of the funds on it.

  ```python



  store(data.to_dict())
  ```

  For convenience during testing, we provide a `save_seed` method that stores the wallet's seed in your local file system. This is an insecure method of storing wallet seeds and should only be used for development purposes.

  To encrypt the saved data, set encrypt to `True`. Note that your CDP API key also serves as the encryption key for the data persisted locally. To re-instantiate wallets with encrypted data, ensure that your SDK is configured with the same API key when invoking `save_seed` and `load_seed`.

  ```python

  file_path = "my_seed.json"


  wallet.save_seed(file_path, encrypt=True)

  print(f"Seed for wallet {wallet.id} successfully saved to {file_path}.")
  ```

  The below code demonstrates how to re-instantiate a wallet from the data export.

  ```python


  fetched_data = fetch(wallet.id)


  imported_wallet = Wallet.import_data(fetched_data)
  ```

  To import Wallets that were persisted to your local file system using `save_seed`, use the below code.

  ```python

  fetched_wallet = Wallet.fetch(wallet.id)



  fetched_wallet.load_seed(file_path)
  ```


  A webhook is a way to provide other applications with real-time information from the blockchain. When an event occurs on a blockchain address, it can send a POST request to a URL you specify. You can create a webhook to receive notifications about events that occur in your wallet or crypto address, such as when a user makes a transfer.
  ```python
  from cdp.client.models.webhook import WebhookEventType
  from cdp.client.models.webhook import WebhookEventFilter

  wh1 = Webhook.create(
      notification_uri="https://your-app.com/callback",
      event_type=WebhookEventType.ERC20_TRANSFER,
      event_filters=[WebhookEventFilter(from_address="0x71d4d7d5e9ce0f41e6a68bd3a9b43aa597dc0eb0")]
  )
  print(wh1)
  ```


  A webhook can be attached to an existing wallet to monitor events that occur on the wallet, i.e. all addresses associated with this wallet. A list of supported blockchain events can be found [here](https://docs.cdp.coinbase.com/get-started/docs/webhooks/event-types).
  ```python
  import cdp

  wallet1 = Wallet.create()
  wh1 = wallet1.create_webhook("https://your-app.com/callback")
  print(wh1)
  ```


  Examples, demo apps, and further code samples can be found in the [CDP SDK Python Documentation](https://docs.cdp.coinbase.com/cdp-apis/docs/welcome).



  See [CONTRIBUTING.md](CONTRIBUTING.md) for more information.


pkgId: 6ac07bea087953efc50c03fbc7c336135a63f69836a11f331a01b9b07a514d55
name: python-cdsodatacli-help
arch: noarch
version: 2024.12.17
epoch: 0
release: 1
summary: Development documents and examples for cdsodatacli
url: https://pypi.org/project/cdsodatacli/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cdsodatacli-2024.12.17-1.src.rpm
location_href: Packages/python-cdsodatacli-help-2024.12.17-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  [![Build status](https://github.com/umr-lops/cdsodatacli/workflows/build/badge.svg?branch=main&event=push)](https://github.com/umr-lops/cdsodatacli/actions?query=workflow%3Abuild)
  [![Python Version](https://img.shields.io/pypi/pyversions/cdsodatacli.svg)](https://pypi.org/project/cdsodatacli/)
  [![Dependencies Status](https://img.shields.io/badge/dependencies-up%20to%20date-brightgreen.svg)](https://github.com/umr-lops/cdsodatacli/pulls?utf8=%E2%9C%93&q=is%3Apr%20author%3Aapp%2Fdependabot)

  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Security: bandit](https://img.shields.io/badge/security-bandit-green.svg)](https://github.com/PyCQA/bandit)
  [![Pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/umr-lops/cdsodatacli/blob/main/.pre-commit-config.yaml)
  [![Semantic Versions](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--versions-e10079.svg)](https://github.com/umr-lops/cdsodatacli/releases)
  [![License](https://img.shields.io/github/license/umr-lops/cdsodatacli)](https://github.com/umr-lops/cdsodatacli/blob/main/LICENSE)
  ![Coverage Report](assets/images/coverage.svg)

  odata client for Copernicus Data Space catalog

  </div>





  * create a copy of the config.yml  called localconfig.yml where `cdsodatacli` is installed in your python environement.
  ```bash
  cp config.yml localconfig.yml
  ```
   * edit the localconfig.yml to set your own path for output directories and CDSE accounts
  ```bash
   vi  localconfig.yml
   ```



  ```bash
  queryCDS -h

  queryCDS --collection SENTINEL-1 --startdate 20230101T00:00:00 --stopdate 20230105T10:10:10 --mode IW --product SLC --querymode seq --geometry "POINT (-5.02 48.4)"
  ```

  or use the method `cdsodatacli.query.fetch_data()`



  ```bash
  downloadFromCDS -h
  ```



  ```bash
  pip install -U cdsodatacli
  ```




  [![License](https://img.shields.io/github/license/umr-lops/cdsodatacli)](https://github.com/umr-lops/cdsodatacli/blob/main/LICENSE)

  This project is licensed under the terms of the `MIT` license. See [LICENSE](https://github.com/umr-lops/cdsodatacli/blob/main/LICENSE) for more details.



  ```bibtex
  @misc{cdsodatacli,
    author = {umr-lops},
    title = {odata client for Copernicus Data Space catalog},
    year = {2023},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/umr-lops/cdsodatacli}}
  }
  ```



  This project was generated with [`python-package-template`](https://github.com/TezRomacH/python-package-template)


pkgId: 78fbee8757cc59bfc2058d57cf17530964b45cefe53d599ab73d2f177cd45213
name: python-cefi-help
arch: noarch
version: 5.3.5
epoch: 0
release: 1
summary: Development documents and examples for cefi
url: https://pypi.org/project/cefi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cefi-5.3.5-1.src.rpm
location_href: Packages/python-cefi-help-5.3.5-1.noarch.rpm
checksum_type: sha256
description:
  <br>
    <table style="border: 1px solid transparent">
      <tr>
        <td>
    <a href="http://talky.readthedocs.io"><img src="https://img.shields.io/badge/Wiki-%23000000.svg?style=for-the-badge&logo=wikipedia&logoColor=white"></a>
    <a href="https://github.com/mraniki/tt/"><img src="https://img.shields.io/badge/github-%23000000.svg?style=for-the-badge&logo=github&logoColor=white"></a><br>
    <a href="https://hub.docker.com/r/mraniki/tt"><img src="https://img.shields.io/docker/pulls/mraniki/tt?style=for-the-badge"></a>
    <br>
        </td>
        <td align="center"><img width="200" alt="Logo" src="https://github.com/mraniki/cefi/blob/main/docs/_static/logo-full.png"></td>
      </tr>
      <tr>
        <td>
          <a href="https://pypi.org/project/cefi/"><img src="https://img.shields.io/pypi/v/cefi?style=for-the-badge&logo=PyPI&logoColor=white"></a><br>
          <a href="https://pypi.org/project/cefi/"><img src="https://img.shields.io/pypi/dm/cefi?style=for-the-badge&logo=PyPI&logoColor=white&label=pypi&labelColor=grey"></a><br>
          <a href="https://github.com/mraniki/cefi/"><img src="https://img.shields.io/github/actions/workflow/status/mraniki/cefi/%F0%9F%91%B7Flow.yml?style=for-the-badge&logo=GitHub&logoColor=white"></a><br>
      <a href="https://talky.readthedocs.io/"><img src="https://readthedocs.org/projects/cex/badge/?version=latest&style=for-the-badge"></a><br>
      <a href="https://codebeat.co/projects/github-com-mraniki-cefi-main"><img src="https://codebeat.co/badges/6aecf822-ea11-499c-80d9-37cd3f35b923"/></a><br>
      <a href="https://app.codacy.com/gh/mraniki/cefi/dashboard"><img src="https://app.codacy.com/project/badge/Grade/2e375e4df911416980496bfd568f0d76"/></a><br>
      <a href="https://codecov.io/gh/mraniki/cefi"> <img src="https://codecov.io/gh/mraniki/cefi/branch/main/graph/badge.svg?token=BTIoKrcXNq"/></a><br>
        </td>
        <td align="left">
          Interact with centralized trading platforms (CEX)<br>
          supported by CCXT, Capital.com, DEGIRO, IBKR and others.
        </td>
      </tr>
    </table>

    <h5>How to use it</h5>
    <pre>
    <code>


      cex = CexTrader()

      balance = await cex.get_balances()
      print("balance ", balance)

      symbol = "BTC"
      quote = await cex.get_quotes(symbol)
      print("quote ", quote)

      order = {
          "action": "BUY",
          "instrument": "BTC",
          "quantity": 1,
      }
      order = await cex.submit_order(order)
      print("order ", order)

    </code>
    </pre>
    <h5>Documentation</h5>
    <a href="https://talky.readthedocs.io/projects/cefi/en/latest/"><img src="https://img.shields.io/badge/Documentation-000000?style=for-the-badge&logo=readthedocs&logoColor=white"></a><br>


pkgId: 6ad955b8f9b0ccb4788fa822cac4bf3ccfb1fe7e454f39ca00d549b23f2ef9ba
name: python-celai-help
arch: noarch
version: 0.3.33
epoch: 0
release: 1
summary: Development documents and examples for celai
url: https://github.com/cel-ai/celai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-celai-0.3.33-1.src.rpm
location_href: Packages/python-celai-help-0.3.33-1.noarch.rpm
checksum_type: sha256
description:
  <!-- A centered logo of celia -->
  <!-- <p align="center">
    <img src="https://raw.githubusercontent.com/cel-ai/celai/30b489b21090e3c3f00ffea66d0ae4ac812bd839/cel/assets/celia_logo.png" width="250" />
  </p> -->
  <div align="center">
      <img src="https://github.com/cel-ai/celai/actions/workflows/python-package.yml/badge.svg">
  </div>
  <hr>

  <p align="center">
    <img src="https://raw.githubusercontent.com/cel-ai/celai/d11d1c81f8193e3de580f6a21376a246fa2d473f/cel/assets/celai_connectors.png" width="600" />
  </p>




  Cel.ai is a AI Driven Communication Platform. Designed to accelerate the development of omnichannel virtual assistants. Whether you need to integrate with messaging platforms like WhatsApp, Telegram, or VoIP services such as VAPI.com, Cel.ai provides the tools and flexibility to get your assistant up and running quickly.

  Don't waste time building on top of hosted platforms that limit your control and flexibility. Cel.ai is designed to be self-hosted, giving you the freedom to customize and extend the platform to meet your needs.

  Supported Connectors:
  - WhatsApp
  - Telegram
  - VAPI.ai
  - Chatwoot

  Off the shelf, Cel.ai provides a powerful tools such as:

  - Multi Asssitant Router
    - Logic Router based on state variables
    - Agentic Router based on user itent and context
    - Semantic Router (coming soon)
  - Tooling
  - Events: `message`, `image`, `new_conversation`, and more
  - Powered by Langchain
  - Langsmith user tracing
  - Moderation Middlewares
  - Blacklist Middlewares
  - Invitations
  - Ngrok native integration
  - User Sequential Message Processing

  [Documentation](https://cel-ai.github.io/celai/)




  Cel.ai provides a powerful multi-assistant router that allows you to create complex conversational assistants easily. This architecture allows you to scale in a modular way, adding new assistants as needed. The routing can be done based on state variables, user intent, or context.

  Agentic Router is the most powerful router in Cel.ai. It allows you to triage messages to different assistants based on user intent and context. It keeps prompts small and focused, allowing for more accurate responses.

  Keep prompts at mininal length and focused on a single task will ensure that the user experience is optimal and the response cost are kept low.

  For example, if you are building a virtual assistant for a hotel, you can have different assistants for booking/reservation, cancellation, room service, and check-out. The Agentic Router will automatically route messages to the correct assistant based on the user's intent.


  <p align="center">
    <img src="https://raw.githubusercontent.com/cel-ai/celai/refs/heads/main/cel/assets/celai_router_diagram.png" width="700" />
  </p>



  Cel.ai provides a powerful in-context routing system. Messages are routed to the correct assistant based on the user's intent and context.

  Assistant can have its own set of prompts and responses, but share the same context.

  State and History stores are shared between all assistants, allowing for a seamless user experience. Ensuring all assistants are in sync with the user's context.




  pip install from github:
  ```bash
  pip install celai
  ```


  Let's create a simple assistant that can be accessed via Telegram. First, you'll need to create a new Telegram bot and get the API token. You can do this by following the instructions in the [Telegram documentation](https://core.telegram.org/bots#6-botfather).

  This example uses OpenAI's GPT-4o model to create a simple assistant that can help users buy Bitcoins. To use the OpenAI API, you'll need to sign up for an API key on the [OpenAI website](https://platform.openai.com/).





  Make sure to set the `OPENAI_API_KEY` environment variable with your OpenAI API key:

  ```bash
  export OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>
  ```



  The easy way to get a public HTTPS URL for your assistant is to use [ngrok](https://ngrok.com/). Cel.ai has built-in support for ngrok, so you can easily delegate the public URL creation to Cel.ai. To use ngrok, you'll need a Ngrok authtoken. You can get one by signing up on the [ngrok website](https://ngrok.com/). Then set the `NGROK_AUTH_TOKEN` environment variable:

  ```bash
  export NGRO_AUTH_TOKEN=<YOUR_NGROK_AUTH_TOKEN>
  ```

  Then you can create a new Python script with the following code, don't forget to
  replace `<YOUR_TELEGRAM_TOKEN>` with the token you received from Telegram:

  ```python

  import os
  from cel.connectors.telegram import TelegramConnector
  from cel.gateway.message_gateway import MessageGateway
  from cel.assistants.macaw.macaw_assistant import MacawAssistant
  from cel.prompt.prompt_template import PromptTemplate



  prompt = """You are an AI assistant. Called Celia. You can help a user to buy Bitcoins."""
  prompt_template = PromptTemplate(prompt)




  ast = MacawAssistant(prompt=prompt_template)

  gateway = MessageGateway(
      assistant=ast,
      host="127.0.0.1", port=5004,
  )


  conn = TelegramConnector(
      token="<YOUR_TELEGRAM_TOKEN>"
  )


  gateway.register_connector(conn)




  gateway.run(enable_ngrok=True)
  ```


pkgId: 4f45a40096b14d81f26e413ee8b0d6cb006bb320998f8b3059f12a47b39cad8d
name: python-celery-help
arch: noarch
version: 5.4.0
epoch: 0
release: 1
summary: Development documents and examples for celery
url: https://docs.celeryq.dev/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-celery-5.4.0-1.src.rpm
location_href: Packages/python-celery-help-5.4.0-1.noarch.rpm
checksum_type: sha256
description:
  This project relies on your generous donations.
  If you are using Celery to create a commercial product, please consider becoming our `backer`_ or our `sponsor`_ to ensure Celery's future.


pkgId: 8712776caac7ecbcd08b059325362e0435c714f6993801fb4888aa1b7c3f7a6d
name: python-celgcp-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for celgcp
url: https://pypi.org/project/celgcp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-celgcp-1.0.0-1.src.rpm
location_href: Packages/python-celgcp-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  **This is not an official Google product.**

  This module allows to evaluate the Google Cloud [IAM Conditions](https://cloud.google.com/iam/docs/conditions-overview) where [CEL](https://cloud.google.com/iam/docs/conditions-overview#cel) is the expression language.


  hm98765@github



  1. Install the package
      ```bash
      pip install celgcp
      ```
      or
      ```
      poetry add celgcp
      ```
  2. Import the class and exception
      ```python
      from celgcp.celgcp import CELEvaluator, CELEvaluatorException
      ```
  3. Create a CEL Expression
      ```python
      cel_source = """
      resource.matchTag('prj/dataset', 'value_1')
      && resource.name.startsWith('projects/my-project/datasets/foo')
      """
      ```
  4. Create an instance of the CELEvaluator
      ```python
      cel_evaluator = CELEvaluator(cel_source)
      ```
  5. Create the activation context
      ```python
       activation = {
          "resource": celpy.json_to_cel(
              {
                  "name": "projects/my-project/datasets/foo/bar",
                  "Tags": [
                      {"prj/dataset": "value_1"},
                      {"prj/table": "value_2"},
                      {"prj/mytag": "value_38"},
                      {"tagKeys/123456789012": "tagValues/567890123456"},
                      {"tagKeys/987654321": "tagValues/111111"},
                  ],
              },
          ),
      }
      ```
  6. call the evaluate method
      ```python
      result = cel_evaluator.evaluate(activation)
      ```


  A complete example

  ```python

      from datetime import datetime
      import celpy
      from celgcp.celgcp import CELEvaluator, CELEvaluatorException

      cel_source = """
      resource.matchTag('prj/dataset', 'value_1')
      && resource.name.startsWith('projects/my-project/datasets/foo')
      && request.time < timestamp("2024-03-21T01:14:51Z")
      """

      date_string = "2021-03-21T01:14:51Z"
      datetime_object = datetime.strptime(date_string, "%Y-%m-%dT%H:%M:%SZ")

      activation = {
          "request": celpy.json_to_cel({"time": datetime_object}),
          "resource": celpy.json_to_cel(
              {
                  "name": "projects/my-project/datasets/foo/bar",
                  "Tags": [
                      {"prj/dataset": "value_1"},
                      {"prj/table": "value_2"},
                      {"prj/mytag": "value_38"},
                      {"tagKeys/123456789012": "tagValues/567890123456"},
                      {"tagKeys/987654321": "tagValues/111111"},
                  ],
              },
          ),
      }

      cel_evaluator = CELEvaluator(cel_source)
      result = cel_evaluator.evaluate(activation)

  ```


  - [Python](https://www.python.org/)


  The dependencies are listed in the pyproject.toml


  Apache 2.0; see [LICENSE](LICENSE) for details.




  poetry run pytest ./tests/tests.py


  This is not an officially supported Google product. This project is not
  eligible for the [Google Open Source Software Vulnerability Rewards
  Program](https://bughunters.google.com/open-source-security).


pkgId: b8af11924e99adf338b1e1fc4fa54bfa28d3ba52ee14dfed6b06068a7a48d18f
name: python-celitech-sdk-help
arch: noarch
version: 1.3.23
epoch: 0
release: 1
summary: Development documents and examples for celitech-sdk
url: https://pypi.org/project/celitech-sdk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-celitech-sdk-1.3.23-1.src.rpm
location_href: Packages/python-celitech-sdk-help-1.3.23-1.noarch.rpm
checksum_type: sha256
description:
  Welcome to the Celitech SDK documentation. This guide will help you get started with integrating and using the Celitech SDK in your project.

  [![This SDK was generated by liblab](https://public-liblab-readme-assets.s3.us-east-1.amazonaws.com/built-by-liblab-icon.svg)](https://liblab.com/?utm_source=readme)



  - API version: `1.1.0`
  - SDK version: `1.3.23`



  Welcome to the CELITECH API documentation! Useful links: [Homepage](https://www.celitech.com) | [Support email](mailto:support@celitech.com) | [Blog](https://www.celitech.com/blog/)



  - [Setup & Configuration](#setup--configuration)
    - [Supported Language Versions](#supported-language-versions)
    - [Installation](#installation)
  - [Authentication](#authentication)
    - [OAuth Authentication](#oauth-authentication)
    - [Environment Variables](#environment-variables)
  - [Setting a Custom Timeout](#setting-a-custom-timeout)
  - [Sample Usage](#sample-usage)
  - [Services](#services)
  - [Models](#models)
  - [License](#license)





  This SDK is compatible with the following versions: `Python >= 3.7`



  To get started with the SDK, we recommend installing using `pip`:

  ```bash
  pip install celitech-sdk
  ```





  The Celitech API uses OAuth for authentication.

  You need to provide the OAuth parameters when initializing the SDK.

  ```py
  sdk = Celitech(
      client_id="CLIENT_ID",
      client_secret="CLIENT_SECRET"
  )
  ```

  If you need to set or update the OAuth parameters after the SDK initialization, you can use:

  ```py
  sdk.set_client_id("CLIENT_ID")
  sdk.set_client_secret("CLIENT_SECRET")
  ```



  These are the environment variables for the SDK:

  | Name          | Description             |
  | :------------ | :---------------------- |
  | CLIENT_ID     | Client ID parameter     |
  | CLIENT_SECRET | Client Secret parameter |

  Environment variables are a way to configure your application outside the code. You can set these environment variables on the command line or use your project's existing tooling for managing environment variables.

  If you are using a `.env` file, a template with the variable names is provided in the `.env.example` file located in the same directory as this README.



  You can set a custom timeout for the SDK's HTTP requests as follows:

  ```py
  from celitech import Celitech

  sdk = Celitech(timeout=10000)
  ```



  Below is a comprehensive example demonstrating how to authenticate and call a simple endpoint:

  ```py
  from celitech import Celitech

  sdk = Celitech(
      client_id="CLIENT_ID",
      client_secret="CLIENT_SECRET"
  )

  result = sdk.destinations.list_destinations()

  print(result)

  ```



  The SDK provides various services to interact with the API.

  <details>
  <summary>Below is a list of all available services:</summary>

  | Name         |
  | :----------- |
  | o_auth       |
  | destinations |
  | packages     |
  | purchases    |
  | e_sim        |

  </details>



  The SDK includes several models that represent the data structures used in API requests and responses. These models help in organizing and managing the data efficiently.

  <details>
  <summary>Below is a list of all available models:</summary>

  | Name                             | Description |
  | :------------------------------- | :---------- |
  | GetAccessTokenRequest            |             |
  | GetAccessTokenOkResponse         |             |
  | ListDestinationsOkResponse       |             |
  | ListPackagesOkResponse           |             |
  | ListPurchasesOkResponse          |             |
  | CreatePurchaseRequest            |             |
  | CreatePurchaseOkResponse         |             |
  | TopUpEsimRequest                 |             |
  | TopUpEsimOkResponse              |             |
  | EditPurchaseRequest              |             |
  | EditPurchaseOkResponse           |             |
  | GetPurchaseConsumptionOkResponse |             |
  | GetEsimOkResponse                |             |
  | GetEsimDeviceOkResponse          |             |
  | GetEsimHistoryOkResponse         |             |
  | GetEsimMacOkResponse             |             |

  </details>



  This SDK is licensed under the MIT License.

  See the [LICENSE](LICENSE) file for more details.


