# packages

pkgId: a3f3d7e7a9b4ff44d6916d3409b79d679c1e92c76fa480348f614a07d205ff2f
name: python-braintrust-help
arch: noarch
version: 0.0.177
epoch: 0
release: 1
summary: Development documents and examples for braintrust
url: https://www.braintrust.dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-braintrust-0.0.177-1.src.rpm
location_href: Packages/python-braintrust-help-0.0.177-1.noarch.rpm
checksum_type: sha256
description:
  A Python library for logging data to Braintrust. `braintrust` is distributed as
  a [library on PyPI](https://pypi.org/project/braintrust/). It is open source and
  [available on GitHub](https://github.com/braintrustdata/braintrust-sdk/tree/main/py).



  Install the library with pip.

  ```bash
  pip install braintrust
  ```

  Then, run a simple experiment with the following code (replace `YOUR_API_KEY` with
  your Braintrust API key):

  ```python
  from braintrust import Eval

  def is_equal(expected, output):
      return expected == output

  Eval(
    "Say Hi Bot",
    data=lambda: [
        {
            "input": "Foo",
            "expected": "Hi Foo",
        },
        {
            "input": "Bar",
            "expected": "Hello Bar",
        },
    ],  # Replace with your eval dataset
    task=lambda input: "Hi " + input,  # Replace with your LLM call
    scores=[is_equal],
  )
  ```


pkgId: 46b9f9503778ac8deb42d011da0acfb637970389d7dbab6e97fbce27aff9cccb
name: python-branca-help
arch: noarch
version: 0.8.1
epoch: 0
release: 1
summary: Development documents and examples for branca
url: https://github.com/python-visualization/branca
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-branca-0.8.1-1.src.rpm
location_href: Packages/python-branca-help-0.8.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Package](https://img.shields.io/pypi/v/branca.svg)](https://pypi.python.org/pypi/branca)
  [![Build Status](https://github.com/python-visualization/branca/actions/workflows/test_code.yml/badge.svg?branch=main)](https://github.com/python-visualization/branca/actions/workflows/test_code.yml)
  [![Gitter](https://badges.gitter.im/python-visualization/folium.svg)](https://gitter.im/python-visualization/folium)



  This library is a spinoff from [folium](https://github.com/python-visualization/folium). It can be used to generate HTML + JS. It is based on Jinja2.

  - Documentation: https://python-visualization.github.io/branca/
  - Examples: https://nbviewer.org/github/python-visualization/branca/tree/main/examples/


pkgId: b38c91e03c994674e6e9201335092827242b1528099b6e5641f276bad64fe1ff
name: python-breakfast-puzzles-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for breakfast-puzzles
url: https://pypi.org/project/breakfast-puzzles/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-breakfast-puzzles-0.2.5-1.src.rpm
location_href: Packages/python-breakfast-puzzles-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  Breakfast Puzzles
  Copyright (C) 2021 Tom Fryers
  This program is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or (at your
  option) any later version.
  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
  Public License for more details.
  You should have received a copy of the GNU General Public License along
  with this program. If not, see <https://www.gnu.org/licenses/>.


pkgId: 4a91360f678c2943d54329def891ac7b00451c4889526e9b8d234fd5beb58d1e
name: python-breeze-chms-api-help
arch: noarch
version: 1.4.4.1
epoch: 0
release: 1
summary: Development documents and examples for breeze-chms-api
url: https://github.com/dawillcox/pyBreezeChMS
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-breeze-chms-api-1.4.4.1-1.src.rpm
location_href: Packages/python-breeze-chms-api-help-1.4.4.1-1.noarch.rpm
checksum_type: sha256
description:
  Python interface to BreezeChMS REST API.
  This is an adaption of [PyBreezeChMS](https://github.com/alexortizrosado/pyBreezeChMS),
  the "official" Python implementation of the [Breeze API](https://app.breezechms.com/api).
  However, the owner of said repository is apparently no longer with Breeze,
  and doesn't respond to email or issues in that repository. This is distributed
  as a [PyPI package](https://pypi.org/project/breeze-chms-api/).
  Since I've wanted several changes and enhancements, I've cloned that original
  and extended it. However, what started as a minor cleanup, mostly with
  the goal of making it a pip-installable package, it turned into
  quite a project. While vestiges of the original version remain, it's
  a pretty major rewrite. Some things that motivated that:
  * Upgrade to Python 3.6 or later; earlier versions are no longer supported.
  * Using at least a current (maybe not latest) PEP coding standard.
  * A number of method parameter names in the Python implementation differ
  from the underlying implementation in the REST description. I found
  that confusing, so parameter names in this implementation match the
  REST description.
  * I found a number of bugs in my testing.
  * In my many years of coding, my credo has been "anything worth coding"
  is worth coding once," so a great many repetitive instances of
  similar code have been consolidated.
  Consequentially, I'm calling this a new work, inspired by and including
  a few internal pieces of the original.
  And a note: I found that the original Python implementation doesn't
  implement all the REST APIs. Volunteer management, for example, is
  missing. I haven't added them. Maybe in a future release.

      $ pip install breeze-chms-api
  This will automatically install the required packages.

  The preferred method is to set up configuration files
  for [combine_settings](https://pypi.org/project/combine-settings/)
  to specify the two parameters need to access the breeze_api:
  * `breeze_url`: Your breeze access url.
  * `api_key`: Your organization's API key.
  Those settings must be in a file named `breeze_maker.yml`.
  With those configuration files set up appropriately, you can instantiate
  a `BreezeAPI` simply by:
  ```python
  from breeze_chms_api import breeze
  breeze_api = breeze.breeze_api()
  ```
  `breeze.breeze_api()` also passes other keyword parameters through to `config_builder`
  if needed. You can also override the default configuration file name with
  the `config_name` parameter.
  If you don't want to use `config_builder` you can pass `breeze_url` and `breeze_api`
  directly to `breeze.breeze_api()`.
  To get a JSON of all people:
  ```python
  people = breeze_api.list_people()
  ```

  * `get_account_summary`: Retrieve details of your account.
  * `list_people`: Get information about people.
  * `get_profile_fields`: Your organization's profile fields.
  * `get_field_spec_by_id`: Get profile field specification by id
  * `get_field_spec_by_name:` Get profile field specification for named field
  * `get_person_details`: Details about a specific person from id.
  * `add_person`: Add a person.
  * `update_person`: Update a person's information.
  * `list_calendars`: Get a list of calendars.
  * `list_events`: Get a list of selected events.
  * `list_event`: Get information about a specific event.
  * `add_event`: Add an event
  * `event_check_in`: Check someone in to an event.
  * `event_check_out`: Remove someone from an event.
  * `delete_attendance`: Delete attendance records for a person from an event.
  * `list_eligible_people`: List people eligible for an event.
  * `list_attendance`: List attendance for an event.
  * `add_contribution`: Add a contribution.
  * `edit_contribution`: Edit an existing contribution.
  * `delete_contribution`: Delete a contribution.
  * `list_form_entries`: Get submitted forms.
  * `remove_form_entry`: Remove specified form entry.
  * `list_form_fields`: List the fields in a given form.
  * `list_contributions`: List selected contributions.
  * `list_funds`: List your contribution funds.
  * `list_campaigns`: List pledge campaigns.
  * `list_pledges`: List pledges in a campaign.
  * `get_tags`: Get information about your tags.
  * `get_tag_folders`: And your tag folders.
  * `assign_tag`: Assign a person to a tag.
  * `unassign_tag` and unassign them.
  The parameters and returns of all of the above are described in the
  [Breeze API Reference Guide](https://app.breezechms.com/api). Look there,
  or the source of this package as necessary.
  For deails of this Python implementation see
  [this documentation](https://github.com/dawillcox/pyBreezeChMS/blob/master/DOCUMENTATION.md).

      pip install coverage combine-settings
      coverage run -m unittest
      coverage report -m

  Never made an open source contribution before? Wondering how contributions work in the in our project? Here's a quick rundown!
  1. Find an issue that you are interested in addressing or a feature that you would like to add.
  2. Fork the repository associated with the issue to your local GitHub organization. This means that you will have a copy of the repository under `your-GitHub-username/pyBreezeChMS`.
  3. Clone the repository to your local machine using git clone https://github.com/github-username/pyBreezeChMS.git.
  4. Create a new branch for your fix using `git checkout -b branch-name-here`.
  5. Make the appropriate changes for the issue you are trying to address or the feature that you want to add.
  6. Use `git add insert-paths-of-changed-files-here` to add the file contents of the changed files to the "snapshot" git uses to manage the state of the project, also known as the index.
  7. Use `git commit -m "Insert a short message of the changes made here"` to store the contents of the index with a descriptive message.
  8. Push the changes to the remote repository using `git push origin branch-name-here`.
  9. Submit a pull request to the upstream repository.
  10. Title the pull request with a short description of the changes made and the issue or bug number associated with your change. For example, you can title an issue like so "Added more log outputting to resolve #4352".
  11. In the description of the pull request, explain the changes that you made, any issues you think exist with the pull request you made, and any questions you have for the maintainer. It's OK if your pull request is not perfect (no pull request is), the reviewer will be able to help you fix any problems and improve it!
  12. Wait for the pull request to be reviewed by a maintainer.
  13. Make changes to the pull request if the reviewing maintainer recommends them.
  14. Celebrate your success after your pull request is merged!

  Code released under the [Apache 2.0](https://github.com/aortiz32/pyBreezeChMS/blob/master/LICENSE) license.

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



  1. [Installation](#installation)
  2. [Command Overview](#command-overview)
  3. [Build Commands](#build-commands)
     - [`breeze build model`](#breeze-build-model)
     - [`breeze build yml`](#breeze-build-yml)
     - [`breeze build source`](#breeze-build-source)
  4. [Add Commands](#add-commands)
     - [`breeze add test`](#breeze-add-test)
  5. [Templates](#templates)
     - [Template Placeholders](#template-placeholders)
     - [Example Templates](#example-templates)
  6. [Examples](#examples)
  7. [Best Practices](#best-practices)
  8. [Support and Contributions](#support-and-contributions)
  9. [Conclusion](#conclusion)



  run `pip install breeze-dbt-cli` in your dbt projects virtual environment.



  Breeze organizes its functionality into several command groups:

  - **build**: Commands to generate models, YAML files, and sources.
  - **add**: Commands to add tests to models or sources.

  Use `breeze --help` to display the help message and list of available commands.



  Commands under the `build` group help in creating models, YAML files, and sources.



  Generate `.sql` files with a boilerplate `SELECT` statement for each model under `models/folder_name/model_name/model_name.sql`.



  ```bash
  breeze build model [OPTIONS] PATH MODEL_NAMES...
  ```



  - **PATH** *(required)*: The folder path where the models .sql files will be created. By default, .sql files get created under their own subdirectory named after the model within the path provided. To omit this behaviour and create .sql files directly in the path provided, use `--no-subfolder` or `-n` flag.
  - **MODEL_NAMES** *(required)*: One or more model names for which to generate `.sql` files.



  - **--force, -f**: Overwrite existing `.sql` files if they exist.
  - **--template, -t**: Path to a custom SQL template file.
  - **--no-subfolder, -n**: If specified, the `.sql` file will be created directly in the provided path instead of a subfolder named after the model.



  - Generate `.sql` files for `model1` and `model2` in `models/stg/model1/` and `models/stg/model2/` respectively:

  ```bash
  breeze build model stg model1 model2
  ```

  -  Generate `.sql` files for `model1` and `model2` in in `models/stg/`, without creating separate subfolders for each model:

  ```bash
  breeze build model staging model1 model2 --no-subfolder
  ```

  - Generate `.sql` file for `model1` in `models/stg/model1/` using a custom template located in `templates/model1_template.sql` and overwrite existing file:

  ```bash
  breeze build model stg model1 --template templates/model1_template.sql --force
  ```



  Generate YAML files for one or more models. The YAML file will be created in the same directory as the corresponding `.sql` file for the model.



  ```bash
  breeze build yml [OPTIONS] MODEL_NAMES...
  ```



  - **MODEL_NAMES** *(required)*: One or more model names for which to generate YAML files.



  - **--force, -f**: Overwrite existing files if they exist.
  - **--template, -t**: Path to a custom YAML template file.



  - Generate YAML files for `model1` and `model2`:

  ```bash
  breeze build yml model1 model2
  ```

  - Generate `.yml` file for `model1` using a custom template located in `templates/model1_template.yml` and overwrite existing file:

  ```bash
  breeze build yml model1 --template templates/model1_template.yml --force
  ```



  Generate YAML files for one or more sources. By default, the YAML file is created under `models/schema_name/source_name.yml`. However, you can specify a custom path using the `--path` flag.



  ```bash
  breeze build source [OPTIONS] SCHEMA_NAME SOURCE_NAMES...
  ```



  - **SCHEMA_NAME** *(required)*: The schema name of the sources.
  - **SOURCE_NAMES** *(required)*: One or more source names for which to generate YAML files.



  - **--all, -a**: Build YAML files for all sources in the schema.
  - **--force, -f**: Overwrite existing files if they exist.
  - **--template, -t**: Path to a custom YAML template file.
  - **--path, -p**: Specify a custom directory where the source YAML file will be saved. If the path does not exist, it will be created.



  - Generate source YAML files for `source1` and `source2` under `models/schema_name/`:

  ```bash
  breeze build source my_schema source1 source2
  ```

  - Generate source YAML file for `source1` using a custom template located in `tempaltes/source_template.yml` and save it in `models/sources/postgres/`:

  ```bash
  breeze build source my_schema source1 --template tempaltes/source_template.yml --path sources/postgres
  ```

  - Force overwrite an existing YAML for `source1` in `models/schema_name/source1.yml`:

  ```bash
  breeze build source raw source1 --force
  ```

  - Write and force overwrite and all YAMLs for sources in `raw` schema in `models/schema_name/` using the custom template located in `tempaltes/source_template.yml`:

  ```bash
  breeze build source raw --all --force --template tempaltes/source_template.yml
  ```



  Commands under the `add` group assist in adding tests to models or sources.



  Add one or more tests to a model or source. If columns are specified, the tests are added to those columns. If no columns are specified, the tests are added at the model or source level.



  ```bash
  breeze add test [OPTIONS] TEST_NAMES...
  ```



  - **TEST_NAMES** *(required)*: One or more test names to add (e.g., `not_null`, `unique`).



  - **--model, -m**: The model name to add the test(s) to.
  - **--source, -s**: The source name to add the test(s) to.
  - **--columns, -c**: Comma-separated column names to add the test(s) to.



  - Add multiple tests to specific columns in a model:

  ```bash
  breeze add test not_null unique --model customers --columns "customer_id, email"
  ```

  - Add a test at the model level:

  ```bash
  breeze add test unique --model orders
  ```

  - Add multiple tests to specific columns in a source:

  ```bash
  breeze add test not_null accepted_values --source status --columns status_code
  ```



  Breeze allows you to use custom templates for generating `.sql` and `.yml` files. You can specify a custom template using the `--template` option with the `build` commands.



  You can include the following placeholders in your templates:

  - **{{ model_name }}**: Name of the model.
  - **{{ source_name }}**: Name of the source table.
  - **{{ schema_name }}**: Name of the schema.
  - **{{ database }}**: Name of the database.
  - **{{ columns }}**: List of columns (used in loops).

  Within loops, each column has:

  - **{{ column.name }}**: Column name.
  - **{{ column.data_type }}**: Data type of the column.





  ```yaml
  version: 2

  models:
    - name: {{ model_name }}
      description: 'Describe {{ model_name }} here.'
      tags: []
      columns:
      {% for column in columns %}
        - name: {{ column.name }}
          data_type: {{ column.data_type }}
          description: ''
          
          
      {% endfor %}
  ```



  ```yaml
  version: 2

  sources:
    - name: {{ schema_name }}
      description: ''
      database: {{ database }}
      schema: {{ schema_name }}
      tables:
      - name: {{ source_name }}
        description: ''
        tags: []
        columns:
        {% for column in columns %}
          - name: {{ column.name }}
            data_type: {{ column.data_type }}
            description: ''
            
            
        {% endfor %}
  ```



  ```sql
  -- Custom SQL Template stg tables
  WITH

  source AS (
      SELECT *
      FROM {{ source('raw', 'source_name') }}
  ),

  SELECT * FROM source
  ```



  - **Run `dbt compile` or `dbt build` before generating YAML files**: This ensures that the `manifest.json` is up-to-date, which Breeze uses to gather model information.

  - **Use the `--force` flag cautiously**: Overwriting existing files can lead to loss of manual changes. Ensure you have backups or use version control.

  - **Validate Generated Files**: After generating or modifying files, validate the YAML syntax and dbt configurations.

  - **Enclose Columns with Spaces in Quotes**: When specifying columns with spaces in their names or spaces after commas, enclose the columns in quotes.



  If you encounter issues or have suggestions for new features, please consider contributing to the project or opening an issue on the project's repository.



  Breeze simplifies dbt project development by automating repetitive tasks and enforcing consistency across models and sources. By leveraging custom templates and automated test additions, you can focus on developing robust data transformations.


pkgId: cfb14081ddbfbe7d5f1f38df377d7a5030e0f41b02958b304b3c1ccaf26453e8
name: python-brenthy-tools-beta-help
arch: noarch
version: 4.0.5
epoch: 0
release: 1
summary: Development documents and examples for brenthy-tools-beta
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-brenthy-tools-beta-4.0.5-1.src.rpm
location_href: Packages/python-brenthy-tools-beta-help-4.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Here lives the source code for Brenthy, the framework for developing and deploying new kinds of blockchain in the Python programming language.



  Main docs:
  - [Introduction to Brenthy](/Documentation/Brenthy/Meaning/IntroductionToBrenthy.md)
  - [Running from Source](/Documentation/Brenthy/User/RunningFromSource.md)
  - [Installation](/Documentation/Brenthy/User/InstallingBrenthy.md)
  - Create Blockchains for Brenthy: _coming soon..._

  Overview of all docs: [/Documentation/DocsOverview.md](/Documentation/DocsOverview.md)



  Walytis is the novel blockchain Brenthy was originally built for.
  Read the [Introduction to Walytis](/Documentation/Walytis/Meaning/IntroductionToWalytis.md) to learn more.
  The source code for Walytis is located under [./blockchains/Walytis_Beta](./blockchains/Walytis_Beta/ReadMe.md)

url:
  https://ipfs.io/ipns/k2k4r8nismm5mmgrox2fci816xvj4l4cudnuc55gkfoealjuiaexbsup/Sites/BrenthyAndWalytis/


pkgId: 95a78565e9808192f4b96c93a3c12ee0b8e0a4ce1bed445e3c01bd32194eb423
name: python-brickflows-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for brickflows
url: https://github.com/Nike-Inc/brickflow
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-brickflows-1.3.0-1.src.rpm
location_href: Packages/python-brickflows-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Thanks to all the [contributors](https://github.com/Nike-Inc/brickflow/blob/main/CONTRIBUTORS.md) who have helped ideate, develop and bring Brickflow to its current state.

  We're delighted that you're interested in contributing to our project! To get started,
  please carefully read and follow the guidelines provided in our [contributing](https://github.com/Nike-Inc/brickflow/blob/main/CONTRIBUTING.md) document.

  Brickflow documentation can be found [here](https://engineering.nike.com/brickflow/).


  1. Install brickflows
  ```shell
  pip install brickflows
  ```
  2. Install [Databricks CLI](https://docs.databricks.com/en/dev-tools/cli/databricks-cli.html)
  ```shell
  curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sudo sh
  ```
  3. Configure Databricks cli with workspace token. This configures your `~/.databrickscfg` file.
  ```shell
  databricks configure --token
  ```

  1. Create your first workflow using brickflow
  ```shell
  mkdir hello-world-brickflow
  cd hello-world-brickflow
  brickflow projects add
  ```
  2. Provide the following inputs
  ```shell
  Project name: hello-world-brickflow
  Path from repo root to project root (optional) [.]: .
  Path from project root to workflows dir: workflows
  Git https url: https://github.com/Nike-Inc/brickflow.git
  Brickflow version [auto]:<hit enter>
  Spark expectations version [0.5.0]: 0.8.0
  Skip entrypoint [y/N]: N
  ```
  _Note: You can provide your own github repo url._
  3. Create a new file hello_world_wf.py in the workflows directory
  ```shell
  touch workflows/hello_world_wf.py
  ```
  4. Copy the following code in hello_world_wf.py file
  ```python
  from brickflow import (
      ctx,
      Cluster,
      Workflow,
      NotebookTask,
  )
  from airflow.operators.bash import BashOperator
  cluster = Cluster(
      name="job_cluster",
      node_type_id="m6gd.xlarge",
      spark_version="13.3.x-scala2.12",
      min_workers=1,
      max_workers=2,
  )
  wf = Workflow(
      "hello_world_workflow",
      default_cluster=cluster,
      tags={
          "product_id": "brickflow_demo",
      },
      common_task_parameters={
          "catalog": "<uc-catalog-name>",
          "database": "<uc-schema-name>",
      },
  )
  @wf.task

  def start():
      print(f"Environment: {ctx.env}")
  @wf.notebook_task

  def example_notebook():
      return NotebookTask(
          notebook_path="notebooks/example_notebook.py",
          base_parameters={
              "some_parameter": "some_value",  # in the notebook access these via dbutils.widgets.get("some_parameter")
          },
      )
  @wf.task(depends_on=[start, example_notebook])

  def list_lending_club_data_files():
      return BashOperator(
          task_id=list_lending_club_data_files.__name__,
          bash_command="ls -lrt /dbfs/databricks-datasets/samples/lending_club/parquet/",
      )
  @wf.task(depends_on=list_lending_club_data_files)

  def lending_data_ingest():
      ctx.spark.sql(
          f"""
          CREATE TABLE IF NOT EXISTS
          {ctx.dbutils_widget_get_or_else(key="catalog", debug="development")}.\
          {ctx.dbutils_widget_get_or_else(key="database", debug="dummy_database")}.\
          {ctx.dbutils_widget_get_or_else(key="brickflow_env", debug="local")}_lending_data_ingest
          USING DELTA -- this is default just for explicit purpose
          SELECT * FROM parquet.`dbfs:/databricks-datasets/samples/lending_club/parquet/`
      """
      )
  ```
  _Note: Modify the values of catalog/database for common_task_parameters._
  5. Create a new file example_notebook.py in the notebooks directory
  ```shell
  mkdir notebooks
  touch notebooks/example_notebook.py
  ```
  6. Copy the following code in the example_notebook.py file
  ```python

  print("hello world")
  ```

  ```shell
  brickflow projects deploy --project hello-world-brickflow -e local
  ```

  1. Login to databricks workspace
  2. Go to the workflows and select the workflow
  <p align="center">
  <img src=https://raw.githubusercontent.com/Nike-Inc/brickflow/master/docs/img/workflow.png?raw=true width=1000></p>
  4. click on the run button

  Refer to the [examples](https://github.com/Nike-Inc/brickflow/tree/main/examples/brickflow_examples) for more examples.


pkgId: 89df3afe10ec276c3b5456bcf4ff904f0c562f535a12503b3b1e6c56061687a1
name: python-bridgecrew-help
arch: noarch
version: 3.2.335
epoch: 0
release: 1
summary: Development documents and examples for bridgecrew
url: https://github.com/bridgecrewio/bridgecrew
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bridgecrew-3.2.335-1.src.rpm
location_href: Packages/python-bridgecrew-help-3.2.335-1.noarch.rpm
checksum_type: sha256
description:
  [![build status](https://github.com/bridgecrewio/bridgecrew-py/workflows/release/badge.svg)](https://github.com/bridgecrewio/bridgecrew-py/actions?query=workflow%3Arelease)
  [![PyPI](https://img.shields.io/pypi/v/bridgecrew)](https://pypi.org/project/checkov/)

  Wraps checkov with a bridgecrew cli (does exactly the same)


pkgId: 75d32ea724ba4950b516b9608268a95149c464e95ad1e1d5c2bca1720c00b730
name: python-briton-help
arch: noarch
version: 0.3.12
epoch: 0
release: 1
summary: Development documents and examples for briton
url: https://pypi.org/project/briton/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-briton-0.3.12-1.src.rpm
location_href: Packages/python-briton-help-0.3.12-1.noarch.rpm
checksum_type: sha256
description:
  The python side of Briton. Briton server is written in C++ for high performance
  and provides a grpc endpoint for interaction. A major function of this python
  libarary is to provide easier interaction with the Briton Server. e.g. there's
  logic to startup the Briton server and ensure it's healthy. It also provides
  adapters for using Briton from Truss. For certain features, such as draft model
  based speculative decoding, a subtantial chunk of the implementation is in this
  library.


pkgId: b899dc04ebaefe90888a0842a58470abc8722cc3df1c14d88a04af4e8e550cda
name: python-bs-drm-adapter-help
arch: noarch
version: 2.8.34
epoch: 0
release: 1
summary: Development documents and examples for bs-drm-adapter
url: https://git.beenius.tv/devops/tools/bs-drm-adapter
rpm_license: Other/Proprietary License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bs-drm-adapter-2.8.34-1.src.rpm
location_href: Packages/python-bs-drm-adapter-help-2.8.34-1.noarch.rpm
checksum_type: sha256
description:
  Beenius DRM adapter is a service that provides DRM entitlement information to requesting DRM systems.

  Supported DRM systems are:
  * Castlabs

  See Configuration and Using the application sections of this document for details on application usage.


  Currently only semi manual installation is supported. Python 3.6 is required to run the service.


  Install EPEL repository, python36 and virtualenv packages
  ```bash
  yum install -y epel-release
  yum install -y python36 python36-virtualenv
  ```


  Install required dependencies for compiling Python 3.6
  ```bash
  yum install -y gcc zlib-devel openssl-devel
  ```

  Download Python 3.6, compile it, create symbolic links (example for Python 3.6.8)
  ```bash

  cd /tmp
  wget https://www.python.org/ftp/python/3.6.8/Python-3.6.8.tgz
  tar -zxvf Python-3.6.8.tgz


  cd Python-3.6.8
  ./configure --prefix=/usr/local/
  make && make altinstall


  sudo ln -s /usr/local/bin/python3.6 /usr/local/bin/python3
  sudo ln -s /usr/local/bin/pip3.6 /usr/local/bin/pip3
  ```

  Update pip and install virtualenv module (as root)
  ```bash
  pip3 install --upgrade pip
  pip3 install virtualenv
  ```


  Copy source code directory to target machine. This guide assumes `/tmp/bs-drm-adapter`


  Install systemd service file
  ```bash
  cd /tmp/bs-drm-adapter
  cp os/bs-drm-adapter.service /etc/systemd/system
  systemctl daemon-reload
  ```

  Prepare virtual environment
  ```bash

  virtualenv-3 -p python3 /opt/bs-drm-adapter
  ```


  Install sysv init script file, logrotate file, register service, prepare pid file directory
  ```bash
  cd /tmp/bs-drm-adapter
  install -m 0755 os/bs-drm-adapter.init /etc/init.d/bs-drm-adapter
  chkconfig --add bs-drm-adapter
  install -o beenius -g beenius -d /var/run/bs-drm-adapter
  ```

  Prepare virtual environment
  ```bash

  virtualenv -p python3 /opt/bs-drm-adapter
  ```


  Prepare directory paths, copy configuration file, systemd unit file and create a virtual environment. This assumes
  beenius user exists on the system. If it doesn't create it first.
  ```bash

  cd /tmp/bs-drm-adapter
  install -o beenius -g beenius -d /var/log/bs-drm-adapter


  cp os/bs-drm-adapter-uwsgi.yml /etc/sysconfig/


  cp os/bs-drm-adapter.yml /etc/sysconfig/
  ```

  Activate virtual environment and install the application
  ```bash
  cd /tmp/bs-drm-adapter
  . /opt/bs-drm-adapter/bin/activate
  pip install .
  deactivate
  ```



  UWSGI server is configured in `/etc/sysconfig/bs-drm-adapter-uwsgi.yml` configuration file. If you plan to use Nginx's
  `uwsgi_pass` directive to reverse proxy requests to the application make sure you comment out `socket` directive and
  comment the `http` one.


  Application configuration file is `/etc/sysconfig/bs-drm-adapter.yml`. Application requires that `drm_adapter_mode` is
  set to required adapter mode. Adapter specific options can be configured in `drm_adapter_options` dictionary.
  `service_routing_host` has to be set to IPrAPI endpoint on Beenius server for integration with OB API.

  Example configuration for Castlabs adapter
  ```yaml
  service_routing_host: http://192.168.122.75:765
  force_device_id_check
  drm_adapter_mode: castlabs
  drm_adapter_options:
    redirect_url: http://192.168.122.75:80/denied
    profile: purchase
  ```

  Restart of application is required when configuration is changed. If running on multiple servers with reverse proxy make
  sure that configuration files are in sync between them.



  | Option                             | Mandatory| Default | Description                                                                      |
  |------------------------------------|:--------:|:-------:|----------------------------------------------------------------------------------|
  | log_level                          | yes      | /       | Service log level `[DEBUG, INFO, WARNING, ERROR, CRITICAL]`                      |
  | service_routing_host               | yes      | /       | Beenius IPrAPI endpoint `scheme://host:port`                                     |
  | drm_adapter_mode                   | yes      | /       | DRM adapter vendor mode                                                          |
  | drm_adapter_options                | no       | none    | DRM adapter specific options                                                     |
  | minimum_entitlement_validity       | no       | 0       | Minimum validity of entitlement in seconds `int`                                 |
  | content_entitlement_check          | no       | true    | Send content_uid when performing entitlement check `[true/false]`                |
  | force_device_id_check              | no       | true    | Force using provided device_id when performing entitlement check `[true/false]`  |
  | map_profile_to_subscriber          | no       | false   | Enable mapping of profileUid to subscriberUid `[true/false]`                     |
  | map_profile_fallback_to_subscriber | no       | false   | Fallback to subscriberUid if profileUid mapping fails `[true/false]`             |

  Minimum validity of entitlements can be increased by setting `minimum_entitlement_validity` property. This can be used
  to ensure entitlements are not re-requested in short period of time when initially obtained before end of existing
  billing period (normally end of month). It will also affect content availability when it is explicitly purchased for
  short duration though.

  Adapter supports mapping of profileUid to subscriberUid by enabling `map_profile_to_subscriber`. This is useful in cases
  when consumer applications are unaware of subscriberUid and are sending profileUid in entitlement requests to DRM
  system. Additionally, fallback to subscriberUid can be enabled by `map_profile_fallback_to_subscriber`. This is useful
  during transition periods when some consumer applications send subscriberUid and some profileUid.


  Supported adapter modes are:
  * castlabs




  | Option | Description                                                                                                                               |
  |--------|-------------------------------------------------------------------------------------------------------------------------------------------|
  | redirect_url  | A URL the user can be redirected to on error (if supported by player and DRM system).                                               |
  | profile       | The profile describes how the content may be used. Supported are 'purchase', 'rental'. Refer to Castlabs documentation for details. |
  | crt_response_properties | Custom properties for customer rights token. Must be properly formatted YAML which will be transalted to JSON and merged with default CRT parameters. |

  Configuration `force_device_id_check` should be set to `false` when integrating with Castlabs.


  When specifying custom CRT properties using crt_response_properties configuration key make sure that it's value is a
  properly formatted YAML. This YAML will then be translated to JSON and merged with CRT properties provided by the
  CastlabsAdapter class. There is no schema validation for the properties configured so make sure they conform with
  [Castlabs' CRT specification](https://fe.drmtoday.com/frontend/documentation/integration/customer_rights_token.html).

  Following parameters MUST NOT be set in the *crt_response_properties* as they are already provided by CastlabsAdapter
  class:
  - accountingId
  - assetId
  - profile
  - message

  Example configuration:
  ```yaml
    crt_response_properties:
      storeLicense: true
      overrides:
        selectors:
          - selector-2
        crt:
          op:
            config:
              UHD:
                WidevineM:
                  deny: true
              HD:
                WidevineM:
                  require HDCP: HDCP_V1
                  allowRevokedDevice: true
              SD:
                WidevineM:
                  require HDCP: HDCP_NONE
                  allowRevokedDevice: false
              AUDIO:
                WidevineM:
                  require HDCP: HDCP_NONE
                  allowRevokedDevice: false
  ```

  Resulting JSON response:
  ```json
  {
      "accountingId": "cl_channel1-125c4d72-5d0f-4e22-8032-9f3ee34bfd51",
      "assetId": "cl_channel1",
      "profile": {
          "rental": {
              "absoluteExpiration": "2021-07-01T00:00:00+00:00",
              "playDuration": 86400000
          }
      },
      "message": "granted",
      "storeLicense": true,
      "overrides": {
          "selectors": [
              "selector-2"
          ],
          "crt": {
              "op": {
                  "config": {
                      "UHD": {
                          "WidevineM": {
                              "deny": true
                          }
                      },
                      "HD": {
                          "WidevineM": {
                              "require HDCP": "HDCP_V1",
                              "allowRevokedDevice": true
                          }
                      },
                      "SD": {
                          "WidevineM": {
                              "require HDCP": "HDCP_NONE",
                              "allowRevokedDevice": false
                          }
                      },
                      "AUDIO": {
                          "WidevineM": {
                              "require HDCP": "HDCP_NONE",
                              "allowRevokedDevice": false
                          }
                      }
                  }
              }
          }
      }
  }
  ```


  Example upstream location on Nginx. If using more than one upstream server define an upstream block instead of using
  direct IP:port as upstream definition.
  ```
  location /bs-drm-adapter {
      include uwsgi_params;
      uwsgi_pass 192.168.122.30:9010;
  }
  ```




  Start application using `systemctl start bs-drm-adapter`

  Stop application using `systemctl stop bs-drm-adapter`

  Check status of application using `systemctl status bs-drm-adapter`


  Start application using `service bs-drm-adapter start`

  Stop application using `service bs-drm-adapter stop`

  Check status of application using `service bs-drm-adapter status`



  For startup issues check system journal `journalctl -xe -f -u bs-drm-adapter`


  For runtime issues check application logs in `/var/log/bs-drm-adapter` directory.


  In production environments it is recommended to deploy more than one instance of application behind Nginx reverse proxy
  and distribute requests to it in round robin manner by properly configuring upstream servers block on Nginx.

  See configuration section for proper configuration of UWSGI server and Nginx reverse proxy.



  Building the image is as simple as running proper `docker build` command. It is possible to override adapter version at
  build time using `DRM_ADAPTER_VERSION` build argument using `--build-arg` flag.


  Following application runtime parameters are available via environment variables:

  | VARIABLE | DEFAULT VALUE   | DESCRIPTION |
  |----------|:---------------:|-------------|
  | UWSGI_SOCKET_TYPE | http | Type of socket to use. Valid options are ['http', 'uwsgi'] |
  | UWSGI_PORT | 8080 | Port to bind application to |
  | UWSGI_PROCESSES | 2 | Number of worker processes to spawn |
  | UWSGI_THREADS | 2 | Number of threads available to worker |
  | BS_DRM_ADAPTER_CONFIGURATION | /opt/bs-drm-adapter.yml | Location of application configuration file |

  Default configuration file included in the image only contains test parameters and should not be used for anything but
  development testing. Mount an external configuration file into container or otherwise present it to container (sidecar,
  configMap...). Refer to the application configuration section for details on how to configure the app.

  Example of running the application in Docker with default parameters
  ```bash
  docker run \
      -ti \
      --name bs-drm-adapter \
      -v /home/user/bs-drm-adapter.yml:/opt/bs-drm-adapter.yml \
      -p8080:8080 \
      nexus-docker.lab.beenius.tv/bs-drm-adapter:2.0-1
  ```



  Any development on the project should be done with running using Python 3.6 in mind. Do not use features from higher
  Python versions.


  Clone the project from [gitlab repository](https://git.beenius.tv/devops/tools/bs-drm-adapter).
  ```.bash
  git clone git@git.beenius.tv:devops/tools/bs-drm-adapter.git
  ```

  Set up virtual environment for development using `pipenv`. This requires Python 3.6 to be available on development
  system. Running following commands a virtual environment with all dependencies including development ones will be set
  up. It will also install git pre-commit hooks.
  ```.bash
  pipenv install --dev
  pipenv run pre-commit install
  ```


  `Dockerfile.beepypi` is included and can be used to build/publish packages to Beenius' hosted PyPi repository. Please
  use for publishing tags only! You may want to clean up after building.
  ```.bash

  docker build . -f Dockerfile.beepypi


  docker image prune
  ```


pkgId: 5e4797c93293c67117f75369827ab565be2157770e4ff3ed44b424ac158adba1
name: python-bsg-ide-help
arch: noarch
version: 3.6
epoch: 0
release: 1
summary: Development documents and examples for bsg-ide
url: https://github.com/sajeethphilip/Beamer-Slide-Generator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bsg-ide-3.6-1.src.rpm
location_href: Packages/python-bsg-ide-help-3.6-1.noarch.rpm
checksum_type: sha256
description:
  A customizable IDE for creating Beamer presentations with multimedia support.



  You can install BSG-IDE directly from PyPI:

  ```bash
  pip install bsg-ide
  ```

  Or install from source:

  ```bash
  git clone https://github.com/sajeethphilip/Beamer-Slide-Generator.git
  cd Beamer-Slide-Generator
  pip install -e .
  ```



  - Python 3.7 or higher
  - LaTeX distribution (TeXLive/MikTeX)
  - For video presentations: pympress



  After installation, you can launch BSG-IDE in two ways:

  1. From command line:
  ```bash
  bsg-ide
  ```

  2. Import and run programmatically:
  ```python
  from bsg_ide import BeamerSlideEditor
  editor = BeamerSlideEditor()
  editor.mainloop()
  ```



  - WYSIWYG Beamer slide editing
  - Multimedia support (images, videos, URLs)
  - Syntax highlighting
  - Live preview
  - Presenter notes support
  - Export to PDF/Overleaf



  This project is licensed under Creative Commons - see the LICENSE file for details.



  Ninan Sajeeth Philip (nsp@airis4d.com)


pkgId: 35c3fdb841b187e10cb97c58c985a19027a955e44256ac0ffef0e062a4f3e4ad
name: python-bskydata-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for bskydata
url: https://github.com/stoltzmaniac/bskydata
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bskydata-0.6.1-1.src.rpm
location_href: Packages/python-bskydata-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  This is built as a wrapper for the `atproto` package. While that package is fantastic, it can be a bit tricky to navigate. This package will **hopefully** give a productive user experience.


  ```
  pip install bskydata


  pip install bskydata[azure]
  pip install bskydata[aws]
  pip install bskydata[gcp]
  pip install bskydata[azure, aws, gcp]

  ```


pkgId: 6e20cce935d865c83a940ef0201498295fd0c78a74eb2aa9d079af632257fe76
name: python-bskydata-help
arch: noarch
version: 0.6.4
epoch: 0
release: 1
summary: Development documents and examples for bskydata
url: https://github.com/stoltzmaniac/bskydata
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bskydata-0.6.4-1.src.rpm
location_href: Packages/python-bskydata-help-0.6.4-1.noarch.rpm
checksum_type: sha256
description:
  This is built as a wrapper for the `atproto` package. While that package is fantastic, it can be a bit tricky to navigate. This package will **hopefully** give a productive user experience.


  ```
  pip install bskydata


  pip install bskydata[azure]
  pip install bskydata[aws]
  pip install bskydata[gcp]
  pip install bskydata[azure, aws, gcp]
  pip install bskydata[mongodb]
  ```


pkgId: 73c4674865e1a41ae85399d1e2841fee8e0968d9bc58ca30778faee01c039c22
name: python-bsmplot-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for bsmplot
url: https://github.com/tianzhuqiao/bsmplot
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bsmplot-0.2.6-1.src.rpm
location_href: Packages/python-bsmplot-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  **bsmplot** is a cross-platform tool to visualize time series based on [Matplotlib](https://matplotlib.org/) and [wxPython](https://wxpython.org/).

  <img src="./docs/bsmplot.png?raw=true" width="865"></img>


  ```
  $ pip install bsmplot
  ```

  To start from terminal
  ```
  $ bsmplot
  ```

  Add shortcut to desktop / Start Menu
  ```
  $ bsmplot --init
  ```


  - VCD (value change dump)
  - PX4 [ulog](https://docs.px4.io/main/en/dev_log/ulog_file_format.html)
  - CSV
  - Matlab (.mat)
  - [ZMQ](https://zeromq.org/) subscriber. **json** format is supported by defaut. If corresponding package is installed, the following format is also supported
      - [bson](https://github.com/py-bson/bson)
      - [cbor](shttps://github.com/agronholm/cbor2)
      - [msgpack](https://msgpack.org/)


  To plot the data, simply double click a signal. It will plot the signal on the current figure window (or create one if there is no figure window then plot).

  <img src="./docs/plot.png?raw=true" width="600"></img>

  You can also drag the signal to the figure window.

  If the data has timestamp field (e.g., ulog), it will be used as x-axis data; otherwise (e.g., csv), the x-axis will be the index by default. And you can also set some signal as x-axis data, which will be shown in **bold**.

  <img src="./docs/plot3.png?raw=true" width="600"></img>

  Many operations of the figure can be done via the context menu (right click), and the toolbar on top. For example, to create a subplot with shared x-axis,

  <img src="./docs/plot2.png?raw=true" width="600"></img>



  To process the data, right click the signal, and select the function to run. Following functions are pre-defined

  1. Quaternion to Yaw/Pitch/Roll
  2. Radian to degree
  3. Degree to Radian
  4. Moving average

  <img src="./docs/quat2angle.png?raw=true" width="600"></img>

  If you are familiar with python code, you can add your own functions. You basically need to define the **inputs**, **equation**, and **outputs**. The number of **outputs** must match the actual ones returned from the **equation**.

  <img src="./docs/addfunc.png?raw=true" width="400"></img>

  If the processing is too complicated, you can also export the data to shell: right click -> Export to shell (or Export to shell with timestamp if available)

  <img src="./docs/exportdata.png?raw=true" width="600"></img>

  Then in the shell, you can access the exported data, and run any python command.

  <img src="./docs/exportdata2.png?raw=true" width="600"></img>

rpm_license:
  MIT License  Copyright (c) 2024 Tianzhu Qiao  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: fb71a7ba9ce28f8935d0e89e0330963bcc12f67c88be816de309930eaf63cf15
name: python-bspline-mutual-information-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for bspline-mutual-information
url: https://pypi.org/project/bspline-mutual-information/
rpm_license: 2-clause BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bspline-mutual-information-1.0.0-1.src.rpm
location_href: Packages/python-bspline-mutual-information-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Utility to bin continuous variables and estimate mutual information based on B-Spline binning.

  This is an adaption of Carsten Daub's R implementation[^1] of the algorithm described in Daub et.al 2004[^2].


  - python >= 3.9
  - numpy >= 1.22.0
  - scipy >= 1.9.0



  The easiest way to install the package is directly via `pip`:
  ```sh
  pip install bspline-mutual-information
  ```

  The most up-to-date version of the package can be also be installed by specifying the git repository directly in the `pip install` command
  ```sh
  pip install git+https://github.com/pnnl-predictive-phenomics/bspline_mutual_information.git
  ```
  or alternatively, cloning the repository to a local folder and installed via `pip` from source:
  ```sh
  git clone https://github.com/pnnl-predictive-phenomics/bspline_mutual_information.git
  cd bspline_mutual_information
  pip install .
  ```


  Once installed the module consits of two functions:
  - `bspline_mutual_information.bspline_bin()`
  - `bspline_mutual_information.mutual_information()`

  `bspline_bin()` is both called internally in `mutual_information()` but can also be used to manually bin continuous data into discrete bins if so desired.

  For this example we will focus on `mutual_information()` since it is the primary use case of this package.

  An example can be found below on how to use `mutual_information()` to estimate the mutual information between two vectors containing continuous data points. It assumes a python environment.

  ```python
  >>> from bspline_mutual_information import mutual_information
  >>> x = [1,2,3,4,5]
  >>> y = [1,2,1,2,3]
  >>> mutual_information(x, y, bins=5, spline_order=3)
  0.4740122135541802
  ```

  If mutual information for pairs of columns in a whole matrix or pandas DataFrame should be calculated this can be done by leveraging pandas `DataFrame.corr()` function. However, since `corr()` does not allow for keyword arguments a helper function needs to be defined first that specifies the arguments `mutual_information()` should be executed with. Consider the example below where the helper function `mut_inf(x, y)` is defined as returning the mutual information calculated using the parameters `bins=5`, `spline_order=1` and `correct=True` (which corrects for the finit size effect if `spline_order==1`). Note that `DataFrame.corr()` will always fill the diagonal with `1` values independent of the chosen `method`.

  ```python
  >>> import pandas as pd
  >>> import bspline_mutual_information as bsp
  >>> data = pd.DataFrame({
  ...     'a': [0, 1, 2, 3, 4],
  ...     'b': [5, 6, 7, 8, 9],
  ...     'c': [0, 1, 2, 1, 0],
  ...     'd': [3, 2, 1, 3, 2]
  ...     })
  ...
  >>> def mut_inf(x, y):
  ...     mi = bsp.mutual_information(
  ...         x, y,
  ...         bins=5,
  ...         spline_order=1,
  ...         correct=True
  ...         )
  ...     return mi
  ...
  >>> data.corr(method=mut_inf)
            a         b         c         d
  a  1.000000  1.921928  1.121928  1.121928
  b  1.921928  1.000000  1.121928  1.121928
  c  1.121928  1.121928  1.000000  0.321928
  d  1.121928  1.121928  0.321928  1.000000
  ```



  [^1]: [C. Daub's R implementation](https://gitlab.com/daub-lab/mutual_information)

  [^2]: Daub CO, Steuer R, Selbig J, Kloska S. Estimating mutual information using B-spline functions--an improved similarity measure for analysing gene expression data. BMC Bioinformatics. 2004 Aug 31;5:118. doi: [10.1186/1471-2105-5-118](https://doi.org/10.1186/1471-2105-5-118). PMID: 15339346; PMCID: PMC516800.


pkgId: baaa01fc97ebace1e2b53b64f9f7b2d0c387f189099d9c26393e8056e4824985
name: python-bspy-help
arch: noarch
version: 4.3
epoch: 0
release: 1
summary: Development documents and examples for bspy
url: http://github.com/ericbrec/BSpy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bspy-4.3-1.src.rpm
location_href: Packages/python-bspy-help-4.3-1.noarch.rpm
checksum_type: sha256
description:
  Library for manipulating and rendering B-spline curves, surfaces, and multidimensional manifolds with non-uniform knots in each dimension.

  The [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) abstract base class for [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) and [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html).

  The [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html) class has a method to fit multidimensional data for scalar and vector functions of single and multiple variables. It also can fit splines to functions, to solutions for ordinary differential equations (ODEs), and to geodesics.
  Spline has methods to create points, lines, circular arcs, spheres, cones, cylinders, tori, ruled surfaces, surfaces of revolution, and four-sided patches.
  Other methods add, subtract, and multiply splines, as well as confine spline curves to a given range.
  There are methods to evaluate spline values, derivatives, normals, integrals, continuity, curvature, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, graphs, and convolutions.
  In addition, there are methods to manipulate the domain of splines, including trim, join, split, reparametrize, transpose, reverse, add and remove knots, elevate and extrapolate, and fold and unfold.
  There are methods to manipulate the range of splines, including dot product, cross product, translate, rotate, scale, and transform.
  Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
  Splines can be saved and loaded in json format.

  The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has methods to create individual hyperplanes in any dimension, along with axis-aligned hyperplanes and hypercubes.

  The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids. Solids can be saved and loaded in json format.

  The [SplineBlock](https://ericbrec.github.io/BSpy/bspy/spline_block.html) class has methods to process an array-like collection of splines that represent a system of equations. There are highly-optimized methods to compute the contours and zeros of a spline block, as well as a variety of methods to manipulate and evaluate a spline block and its derivatives.

  The [BSpyConvert](https://pypi.org/project/BSpyConvert/) package converts BSpy splines and solid models to and from [OpenCascade (OCCT)](https://dev.opencascade.org/) equivalents and a variety of geometry and CAD file formats, including STEP, IGES, and STL.

  The [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html) class is an
  [OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves and surfaces. Spline surfaces with more
  than 3 dependent variables will have their added dimensions rendered as colors (up to 6 dependent variables are supported). Only tested on Windows systems.

  The [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) class is a
  [tkinter.Tk](https://docs.python.org/3/library/tkinter.html) app that hosts a
  [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html),
  a tree view full of solids and splines, and a set of controls to adjust and view the selected solids and splines. Only tested on Windows systems.

  The [Graphics](https://ericbrec.github.io/BSpy/bspy/viewer.html#Graphics) class is a graphics engine to display splines.
  It launches a [Viewer](https://ericbrec.github.io/BSpy/bspy/viewer.html) and issues commands to the viewer for use
  in [jupyter](https://jupyter.org/) notebooks and other scripting environments. Only tested on Windows systems.

  ![Viewer rendering the Utah teapot](https://ericbrec.github.io/BSpy/viewer.png "Viewer rendering the Utah teapot")

  The full documentation for BSpy can be found [here](https://ericbrec.github.io/BSpy), its GitHub project can be found
  [here](https://github.com/ericbrec/BSpy), a test suite can be found [here](https://github.com/ericbrec/BSpy/tree/main/tests), and
  a set of examples, including a jupyter notebook, can be found [here](https://github.com/ericbrec/BSpy/tree/main/examples).


  * Removed accuracy as a member of Spline
  * Spline.common_basis is now a static method (see documentation for details)
  * Spline.least_squares changed arguments (see documentation for details)
  * Spline.load always returns a list of splines


  * Removed Spline blossom method
  * Removed DrawableSpline class
  * Changed bspyApp class name to Viewer
  * Changed Viewer listbox to use extended selection (shift and ctrl keys)
  * Changed bspyGraphics class name to Graphics
  * Moved DrawableSpine methods for adjusting spline appearance to Viewer (see documentation for details)
  * Spline.bspline_values changed arguments (see documentation for details)
  * Spline.intersect changed return values (see documentation for details)


pkgId: 73281ca6b9c6bcb07cfb9a6f1c8ac931301c40b87bb9a0e27a1b4e3947bf71d1
name: python-bugsink-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for bugsink
url: https://pypi.org/project/bugsink/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bugsink-1.0.1-1.src.rpm
location_href: Packages/python-bugsink-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [Bugsink](https://www.bugsink.com/) offers real-time [error tracking](https://www.bugsink.com/error-tracking/) for your applications with full control
  through self-hosting.

  * [Built to self-host](https://www.bugsink.com/built-to-self-host/)
  * [Sentry-compatible SDKs](https://www.bugsink.com/connect-any-application/)
  * [Scalable and reliable](https://www.bugsink.com/scalable-and-reliable/)



  This is what you'll get:

  ![Screenshot](https://www.bugsink.com/static/images/JsonSchemaDefinitionException.5e02c1544273.png)




  The **quickest way to evaluate Bugsink** is to spin up a throw-away instance using Docker:

  ```
  docker pull bugsink/bugsink:latest

  docker run \
    -e SECRET_KEY={{ random_secret }} \
    -e CREATE_SUPERUSER=admin:admin \
    -e PORT=8000 \
    -p 8000:8000 \
    bugsink/bugsink
  ```

  Visit [http://localhost:8000/](http://localhost:8000/), where you'll see a login screen. The default username and password
  are `admin`.

  Now, you can [set up your first project](https://www.bugsink.com/docs/quickstart/) and start tracking errors.

  [Detailed installation instructions](https://www.bugsink.com/docs/installation/) are on the Bugsink website.

  [More information and documentation](https://www.bugsink.com/)

rpm_license:
  With regard to the Bugsink Software:  This software and associated documentation files (the "Software") may only be used under either of the following 2 conditions:  1. In production, if you (and any entity that you represent) have agreed to, and are in compliance with, the Bugsink Subscription Terms of Service, available at https://www.bugsink.com/terms/ (the "Terms"), or other agreement governing the use of the Software, as agreed by you and Bugsink B.V., and otherwise have a valid Bugsink subscription for the correct number of users.  OR  2. In a non-production environment, for a single user, for the purpose of evaluating the Software, provided that you are not using or have not used the Software in a way that would violate the Terms.  Subject to the foregoing condition, you are free to modify this Software, provided that you do not remove the copyright notice and the license notice and do not modify the code in a way that would conflict with the Terms.  You are not granted any other rights beyond what is expressly stated herein.  Subject to the foregoing, it is forbidden to copy, merge, publish, distribute, sublicense, and/or sell the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  For all third party components incorporated into the Bugsink Software, those components are licensed under the original license provided by the owner of the applicable component:  * The icons in SVG format, directly included in various html templates are from Heroicons by Tailwind Labs, Inc. (MIT License)  * The code in the 'sentry' directory is Copyright 2019 Sentry (https://sentry.io) and individual contributors. (BSD 3-Clause License)  * Upon installing Bugsink, additional third party components will be installed automatically (e.g. through pip or as part of the Docker installation). Please refer to the license of the respective component in your package manager's repository.


pkgId: 548d785efd1caf6b930a7ef76dd24ad3c0d6e66568f08b05246f7f47f599c959
name: python-bugster-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for bugster
url: https://www.bugster.dev
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bugster-0.5.0-1.src.rpm
location_href: Packages/python-bugster-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  Bugster is a powerful, flexible testing framework built on top of Playwright and pytest. It's designed to simplify the process of writing and managing end-to-end tests for web applications, with a focus on supporting multiple client configurations.



  - Built on Playwright for robust, cross-browser testing
  - Seamless integration with pytest
  - Support for client-specific configurations and login strategies
  - Custom `@login` decorator for easy test marking
  - Flexible page object model with `BugsterPage`



  You can install Bugster using pip:

  ```bash
  pip install bugster
  ```

  This will install Bugster and its dependencies (including pytest and playwright).

  After installation, you need to install the Playwright browsers:

  ```bash
  playwright install
  ```





  1. Create a client configuration repository with the following structure:

  ```
  customer-configs/
  ├── customer1/
  │   ├── config.py
  │   └── login_strategy.py
  ├── customer2/
  │   ├── config.py
  │   └── login_strategy.py
  └── ...
  ```

  2. In your test files, use the `@login` decorator to mark tests that require login:

  ```python
  from bugster.decorators import login

  @login
  def test_requires_login(page):
      assert page.is_visible("text=Welcome")

  def test_does_not_require_login(page):
      assert page.is_visible("text=Login")

  @login
  class TestLoggedInFeatures:
      def test_feature_1(self, page):
          assert page.is_visible("text=Feature 1")
  ```



  To run your tests, use pytest with the `--customer-id` option:

  ```bash
  pytest --customer-id customer1 /path/to/your/tests
  ```



  In each client's `config.py`:

  ```python
  from bugster.config.base_config import BaseConfig
  from .login_strategy import CustomLoginStrategy

  class CustomerConfig(BaseConfig):
      LOGIN_STRATEGY = CustomLoginStrategy
      CREDENTIALS = {
          "username": "customeruser",
          "password": "customerpass"
      }
      
  ```

  In each client's `login_strategy.py`:

  ```python
  from bugster.login.base_login_strategy import BaseLoginStrategy

  class CustomLoginStrategy(BaseLoginStrategy):
      def login(self, page, credentials):
          page.goto("https://customer.example.com/login")
          page.fill("#username", credentials["username"])
          page.fill("#password", credentials["password"])
          page.click("#login-button")
          page.wait_for_selector("#welcome-message")
  ```



  Bugster provides a `BugsterPage` class that wraps Playwright's `Page` object, providing additional functionality. You can extend this class for custom page objects:

  ```python
  from bugster.core.bugster_page import BugsterPage

  class MyCustomPage(BugsterPage):
      def custom_action(self):
          
          pass
  ```



  We welcome contributions to Bugster! Please see our [CONTRIBUTING.md](CONTRIBUTING.md) file for details on how to contribute.



  Bugster is released under the MIT License. See the [LICENSE](LICENSE) file for details.



  See the [CHANGELOG.md](CHANGELOG.md) file for details on what has changed in each version of Bugster.



  If you encounter any issues or have questions, please file an issue on the [GitHub issue tracker](https://github.com/yourusername/bugster/issues).



  Bugster is built on top of the excellent [Playwright](https://playwright.dev/) and [pytest](https://docs.pytest.org/) projects. We're grateful to the maintainers and contributors of these projects for their fantastic work.


pkgId: 66d36de07563437ada09794aaf6c2b005c1557435ea8c15b1051318dbdce5501
name: python-build-a-brain-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for build-a-brain
url: https://pypi.org/project/build-a-brain/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-build-a-brain-1.0.1-1.src.rpm
location_href: Packages/python-build-a-brain-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This package generates a simple spiking network model with a leaky integrate and fire (LIF) approach. The spiking model can be customized and outputs spiking activity over time of each neuron in the form of a raster plot. Additionally, membrane potential voltages are stored for each neuron at each step of the simulation.


  The model is customizable with the aid of a user friendly interface. The model consists of 5 layers where the user defines the following:
  - number of neurons in each layer
  - connectivity matrix of each layer to itself and other layers
  - stimulation layer
  - percent of neurons in stimulation layer reciving stimulation
  - run time of stimulation in miliseconds


  Dependencies:
  To use the package, first install the following pacakges and make sure you are using python version 3.11 or later:
  ```
  pip install numpy
  pip install matplotlib
  pip install tk
  ```

  Install the package:
  ```
  pip install build_a_brain
  ```


  To use the interactive interface, the function can be ran in either the command line or in a jupyter notebook:
  ```
  build_a_brain.build_network_interface()
  ```
  To output the network object, spikes over time, and voltages over time, it is reccomended to use a jupyter notbook. Below is an example of a neural network that can be generated.
  ```
  net, spikes, voltages = run_simulation(-1, -1, num_steps = 100,
                      layer_1_size = 1000,
                      layer_2_size = 1000,
                      layer_3_size = 1000,
                      layer_4_size = 1000,
                      layer_5_size = 1000,
                      connectivity_matrix = np.array([[0,0,0.02,0.02,0.01],
                                                      [0.001,0.001,0,0.001,0.01],
                                                      [0.001,0.001,0.01,0,0.001],
                                                      [0.01,0.01,0.01,0,0.01],
                                                      [0.001,0.001,0.01,0.001,0]]),
                      driving_layer = 3,
                      driving_neuron_nums = 20)
  ```


pkgId: 022d5c4b51cce9625f7954a9d3c3f684df6b14d44f821ef8584cbc17e677ad23
name: python-build-metadata-help
arch: noarch
version: 0.2
epoch: 0
release: 1
summary: Development documents and examples for build-metadata
description: None
url: https://pypi.org/project/build-metadata/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-build-metadata-0.2-1.src.rpm
location_href: Packages/python-build-metadata-help-0.2-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Tekijänoikeus 2020– Antti Hautaniemi  Tämän käyttöoikeusasiakirjan nojalla annetaan ilmainen käyttöoikeus sen mukana toimitettavaan ohjelmistoon kenelle tahansa henkilölle, joka saa tämän ohjelmiston ja sen mukana toimitettavan dokumentaation haltuunsa. Tämä oikeus sisältää oikeuden mainitun ohjelmiston käyttämiseen, kopiointiin, muokkaamiseen, yhdistämiseen, julkaisemiseen, levittämiseen, edelleen lisensointiin sekä ohjelmiston tai sen osien jälleenmyyntiin. Samoin annetaan oikeus edellä mainittujen oikeuksien luovuttamiseen myös sellaisille kolmansille osapuolille, joiden käyttöön mainittu ohjelmisto on näiden oikeuksien haltijan toimesta luovutettu. Kaikki tässä kappaleessa mainitut oikeudet luovutetaan yksinomaan seuraavalla ehdolla:  Yllä mainittu tekijänoikeusilmoitus sekä tämä käyttöoikeusasiakirja on sisällytettävä sellaisenaan kaikkiin tämän asiakirjan mukana toimitettavasta ohjelmistosta tai kyseisen ohjelmiston merkittävästä osakokonaisuudesta tehtyihin kopioihin.  Ohjelmisto toimitetaan sellaisenaan ilman minkäänlaista, suoraan tai välillisesti, ilmaistua takuuta. Tällaisena takuuna pidetään muun muassa, seuraaviin esimerkkeihin kuitenkaan rajoittumatta, myyntikelpoisuutta, käyttökelpoisuutta mihinkään erityiseen tarkoitukseen tai kolmansien osapuolten oikeuksien loukkaamattomuutta. Missään tapauksessa ohjelmiston tekijöitä tai tekijänoikeuden haltijoita ei voida pitää korvausvelvollisina liittyen mihinkään vahingonkorvaus- tai muuhun sen enempää sopimussuhteesta kuin muustakaan ohjelmistoon itseensä, sen käyttöön tai muuhun ohjelmiston tai sen osien käsittelyyn liittyvästä vahingon tai muun korvausvelvollisuuden aiheutumisesta.  Riippumatta siitä, mitä tämän asiakirjan muissa kohdissa sanotaan, Suomen kansan pakotelistalla (https://github.com/an7oine/suomen-kansan-pakotelista/blob/master/README.md) mainituilla henkilöillä lähipiireineen ei ole oikeutta pitää hallussaan, käyttää taikka suoraan tai välillisesti hyödyntää tätä ohjelmistoa tai mitään sen osaa.


pkgId: b449f66d18bf2e1fd0f536cc7f9ef17930cb996cd8cb00f60423a955b50934e1
name: python-buildbot-help
arch: noarch
version: 4.2.0
epoch: 0
release: 1
summary: Development documents and examples for buildbot
url: http://buildbot.net/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-buildbot-4.2.0-1.src.rpm
location_href: Packages/python-buildbot-help-4.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Buildbot is an open-source continuous integration framework for automating software build, test, and release processes.
  * Buildbot is easy to set up, but very extensible and customizable.
    It supports arbitrary build processes, and is not limited to common build processes for particular languages (e.g., autotools or ant)
  * Buildbot supports building and testing on a variety of platforms.
    Developers, who do not have the facilities to test their changes everywhere before committing, will know shortly afterwards whether they have broken the build or not.
  * Buildbot allows to track various metrics (warning counts, lint checks, image size, compile time, etc) over time.
  * Buildbot has minimal requirements for workers: using virtualenv, only a Python installation is required.
  * Workers can be run behind a NAT firewall and communicate with the master.
  * Buildbot has a variety of status-reporting tools to get information about builds in front of developers in a timely manner.


pkgId: 44d380376a079bb4f508351dd44d215cd785b3a9b97d7dc443a5dec3683e3684
name: python-buildbot-netauth-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for buildbot-netauth
url: https://pypi.org/project/buildbot-netauth/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-buildbot-netauth-0.1.1-1.src.rpm
location_href: Packages/python-buildbot-netauth-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  NetAuth authentication, user info, and avatar plugin for buildbot



  1. Install the plugin, for example: `pip install buildbot-netauth`

  2. In your `buildmaster.cfg`, add:

  ```py
  from buildbot.plugins import util

  netauth = util.BuildbotNetAuth(conf=Path("/etc/netauth/config.toml"))


  c["www"]["auth"] = netauth
  c["www"]["avatar_methods"] = [netauth, ...]
  ```



  The plugin looks at the following metadata on NetAuth entities:

  - entity ID: used as an "email" in the format `entity_id@domain`. `domain` is the base domain of the NetAuth server, but is overridable.
  - entity display name or legal name: if set, will be used for the `full_name` buildbot user property in that fallback order
  - entity group membership: used for the `groups` buildbot user property and can be used for buildbot authz, for example:

  ```py
  from buildbot.plugins import util

  c["www"]["authz"] = util.Authz(
      allowRules=[
          util.AnyEndpointMatcher(role="ops", defaultDeny=False),
          util.AnyControlEndpointMatcher(role="ops"),
      ],
      roleMatchers=[
          util.RolesFromGroups(groupPrefix="build-"),
      ]
  )
  ```


pkgId: 0344986de9ed9511d9c43cd59979c00804887cc87dfb390628f312fed90efcbb
name: python-builder2ibek-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for builder2ibek
url: https://pypi.org/project/builder2ibek/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-builder2ibek-0.3.0-1.src.rpm
location_href: Packages/python-builder2ibek-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/epics-containers/builder2ibek/actions/workflows/ci.yml/badge.svg)](https://github.com/epics-containers/builder2ibek/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/epics-containers/builder2ibek/branch/main/graph/badge.svg)](https://codecov.io/gh/epics-containers/builder2ibek)
  [![PyPI](https://img.shields.io/pypi/v/builder2ibek.svg)](https://pypi.org/project/builder2ibek)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)



  A tool suite for converting DLS XML builder projects to epics-containers ibek.

  Source          | <https://github.com/epics-containers/builder2ibek>
  :---:           | :---:
  PyPI            | `pip install builder2ibek`
  Releases        | <https://github.com/epics-containers/builder2ibek/releases>

  <pre><font color="#AAAAAA">╭─ Commands ───────────────────────────────────────────────────────────────────╮</font>
  <font color="#AAAAAA">│ </font><font color="#2AA1B3"><b>xml2yaml       </b></font> Convert a builder XML IOC instance definition file into an   │
  <font color="#AAAAAA">│ </font><font color="#2AA1B3"><b>               </b></font> ibek YAML file                                               │
  <font color="#AAAAAA">│ </font><font color="#2AA1B3"><b>beamline2yaml  </b></font> Convert all IOCs in a BLXXI-SUPPORT project into a set of    │
  <font color="#AAAAAA">│ </font><font color="#2AA1B3"><b>               </b></font> ibek services folders (TODO)                                 │
  <font color="#AAAAAA">│ </font><font color="#2AA1B3"><b>autosave       </b></font> Convert DLS autosave DB template comments into autosave req  │
  <font color="#AAAAAA">│ </font><font color="#2AA1B3"><b>               </b></font> files                                                        │
  <font color="#AAAAAA">│ </font><font color="#2AA1B3"><b>db-compare     </b></font> Compare two DB files and output the differences              │
  <font color="#AAAAAA">╰──────────────────────────────────────────────────────────────────────────────╯</font>
  </pre>

  ```bash
  builder2ibek

  ```python
  from builder2ibek import __version__

  print(f"Hello builder2ibek {__version__}")
  ```

  Or if it is a commandline tool then you might put some example commands here:

  ```
  python -m builder2ibek --version
  ```

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


pkgId: 901490acb7f1259471d7f8111a5d1d6b4a5d408e1b70fe2bae71041866c0e260
name: python-buildrunner-help
arch: noarch
version: 3.15.1081
epoch: 0
release: 1
summary: Development documents and examples for buildrunner
url: https://github.com/adobe/buildrunner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-buildrunner-3.15.1081-1.src.rpm
location_href: Packages/python-buildrunner-help-3.15.1081-1.noarch.rpm
checksum_type: sha256
description:
  Buildrunner is a tool written on top of Docker and ssh remoting frameworks that
  allows engineers to do the following:
  - Build and publish Docker images
  - Run other build and packaging tools within custom Docker containers while
    collecting the artifacts these tools produce
  - Run builds/tasks on remote systems that cannot be done within a Docker
    container
  - Creating ad-hoc environments using Docker containers for running automated,
    self-contained integration and functional tests
  Buildrunner runs builds and tests by reading configuration files within a given
  source tree. This allows build and continuous integration test configurations
  to live close to source files, providing engineers the ability to update and
  version the build and test configuration right along with the code that is
  being built and tested. This also allows build tools and infrastructures to
  very easily import and setup builds for new modules and branches.


pkgId: 41d9bb47be8e5eccfd4d684d7b0aed5b47128980fa002a0e622613f7841bb264
name: python-bump-my-version-help
arch: noarch
version: 0.28.2
epoch: 0
release: 1
summary: Development documents and examples for bump-my-version
url: https://pypi.org/project/bump-my-version/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bump-my-version-0.28.2-1.src.rpm
location_href: Packages/python-bump-my-version-help-0.28.2-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/bump-my-version.svg)](https://pypi.org/project/bump-my-version/)
  [![image](https://img.shields.io/pypi/l/bump-my-version.svg)](https://github.com/callowayproject/bump-my-version/blob/master/LICENSE)
  [![image](https://img.shields.io/pypi/pyversions/bump-my-version.svg)](https://pypi.org/project/bump-my-version/)
  [![codecov](https://codecov.io/gh/callowayproject/bump-my-version/branch/master/graph/badge.svg?token=D1GSOtWEPU)](https://codecov.io/gh/callowayproject/bump-my-version)
  [![GitHub Actions](https://github.com/callowayproject/bump-my-version/workflows/CI/badge.svg)](https://github.com/callowayproject/bump-my-version/actions)

  > **NOTE**
  >
  > This is a maintained refactor of the [bump2version fork](https://github.com/c4urself/bump2version) of the excellent [bumpversion project](https://github.com/peritus/bumpversion). The main goals of this refactor were:
  >
  > - Add support for `pyproject.toml` configuration files.
  > - Convert to [click](https://click.palletsprojects.com/en/8.1.x/) for and [rich](https://rich.readthedocs.io/en/stable/index.html) for the CLI interface
  > - Add better configuration validation using [Pydantic](https://docs.pydantic.dev)
  > - Make the code and tests easier to read and maintain

  <!--start-->



  Bump My Version's purpose is to:

  - Work as a part of an automated build system
  - Manage project versioning through the project's development life cycle
      - Incrementing version numbers
      - serializing version numbers
      - parsing version numbers
      - supporting SemVer, CalVer, and other versioning schemes
  - Modify project files as part of the project's development life cycle
  - Work with the project's source control system
      - Committing changes
      - Tagging releases
      - Reading version numbers from tags



  You can download and install the latest version of this software from the Python package index (PyPI) as follows:

  ```console
  pip install --upgrade bump-my-version
  ```



  Please find the changelog here: [CHANGELOG.md](https://github.com/callowayproject/bump-my-version/blob/master/CHANGELOG.md)


  <!--tutorial start-->



  The default configuration uses a simplified version of [semantic versioning](https://semver.org/).

  ```console title="Generating a default configuration"
  $ bump-my-version sample-config --no-prompt --destination .bumpversion.toml
  $ cat .bumpversion.toml
  [tool.bumpversion]
  current_version = "0.1.0"
  parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
  serialize = ["{major}.{minor}.{patch}"]
  search = "{current_version}"
  replace = "{new_version}"
  regex = false
  ignore_missing_version = false
  tag = false
  sign_tags = false
  tag_name = "v{new_version}"
  tag_message = "Bump version: {current_version} → {new_version}"
  allow_dirty = false
  commit = false
  message = "Bump version: {current_version} → {new_version}"
  commit_args = ""
  ```



  You can see the potential versioning paths with the `show-bump` subcommand.

  ```console title="Showing the potential versioning path"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0
                 ├─ minor ─ 0.2.0
                 ╰─ patch ─ 0.1.1
  $ bump-my-version show-bump 1.2.3
  1.2.3 ── bump ─┬─ major ─ 2.0.0
                 ├─ minor ─ 1.3.0
                 ╰─ patch ─ 1.2.4
  ```

  The default configuration only allows bumping the major, minor, or patch version. What if you wanted to support pre-release versions?



  Alter the `parse` configuration to support pre-release versions. This `parse` option uses an extended (or verbose) regular expression to extract the version components from the current version.

  ```toml title="New parse configuration"
  parse = """(?x)
      (?P<major>0|[1-9]\\d*)\\.
      (?P<minor>0|[1-9]\\d*)\\.
      (?P<patch>0|[1-9]\\d*)
      (?:
          -                             # dash separator for pre-release section
          (?P<pre_l>[a-zA-Z-]+)         # pre-release label
          (?P<pre_n>0|[1-9]\\d*)        # pre-release version number
      )?                                # pre-release section is optional
  """
  ```

  Alter the `serialize` configuration to support pre-release versions.

  ```toml title="New serialize configuration"
  serialize = [
      "{major}.{minor}.{patch}-{pre_l}{pre_n}",
      "{major}.{minor}.{patch}",
  ]
  ```

  Add a new configuration section for the `pre_l` part.

  ```toml title="New pre_l configuration"

  [tool.bumpversion.parts.pre_l]
  values = ["dev", "rc", "final"]
  optional_value = "final"
  ```



  Now when you run `bump-my-version show-bump`, you can see the new pre-release versioning path.

  ```console title="Showing the new versioning path"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0-dev0
                 ├─ minor ─ 0.2.0-dev0
                 ├─ patch ─ 0.1.1-dev0
                 ├─ pre_l ─ invalid: The part has already the maximum value among ['dev', 'rc', 'final'] and cannot be bumped.
                 ╰─ pre_n ─ 0.1.0-final1
  ```

  The `pre_l` is not bump-able because it is already at the maximum value. The `pre_n` is bump-able because it is not at the maximum value.

  If we run `bump-my-version show-bump 1.0.0-dev0`, we can see the new versioning path for a `dev` starting version.

  ```console title="Showing the new versioning path for a dev version"
  $ bump-my-version show-bump 1.0.0-dev0
  1.0.0-dev0 ── bump ─┬─ major ─ 2.0.0-dev0
                      ├─ minor ─ 1.1.0-dev0
                      ├─ patch ─ 1.0.1-dev0
                      ├─ pre_l ─ 1.0.0-rc0
                      ╰─ pre_n ─ 1.0.0-dev1
  ```

  Finally, we can see the new versioning path for a `rc` starting version.

  ```console title="Showing the new versioning path for an rc version"
  $ bump-my-version show-bump 1.0.0-rc0
  1.0.0-rc0 ── bump ─┬─ major ─ 2.0.0-dev0
                     ├─ minor ─ 1.1.0-dev0
                     ├─ patch ─ 1.0.1-dev0
                     ├─ pre_l ─ 1.0.0
                     ╰─ pre_n ─ 1.0.0-rc1
  ```

  The full development and release path is:

  - `1.0.0`
  - `bump patch` → `1.0.1-dev0`
  - `bump pre_n` → `1.0.1-dev1`
  - `bump pre_l` → `1.0.1-rc0`
  - `bump pre_n` → `1.0.1-rc1`
  - `bump pre_l` → `1.0.1`

  1. You must decide on the next version before you start developing.
  2. Development versions increase using `bump-my-version bump pre_n`.
  3. Switch from development to release candidate using `bump-my-version bump pre_l`.
  4. Release candidates increase using `bump-my-version bump pre_n`.
  5. Switch from the release candidate to the final release using `bump-my-version bump pre_l`.



  The `pre_n` or pre-release number is a number that increases with each pre-release. You can automate this by changing the serialization configuration.

  ```toml title="Serialize configuration with pre_n automation"
  serialize = [
      "{major}.{minor}.{patch}-{pre_l}{distance_to_latest_tag}",
      "{major}.{minor}.{patch}",
  ]
  ```

  The `distance_to_latest_tag` is a special value that is replaced with the number of commits since the last tag. This is a good value to use for the `pre_n` because it will always increase with each commit.



  Now when you run `bump-my-version show-bump`, you can see the new pre-release versioning path.

  ```console title="Showing the new versioning path with pre_n automation"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0-dev0
                 ├─ minor ─ 0.2.0-dev0
                 ├─ patch ─ 0.1.1-dev0
                 ╰─ pre_l ─ invalid: The part has already the maximum value among ['dev', 'rc', 'final'] and cannot be bumped.
  $ bump-my-version show-bump 1.0.0-dev0
  1.0.0-dev0 ── bump ─┬─ major ─ 2.0.0-dev0
                      ├─ minor ─ 1.1.0-dev0
                      ├─ patch ─ 1.0.1-dev0
                      ╰─ pre_l ─ 1.0.0-rc0
  $ bump-my-version show-bump 1.0.0-rc0
  1.0.0-rc0 ── bump ─┬─ major ─ 2.0.0-dev0
                     ├─ minor ─ 1.1.0-dev0
                     ├─ patch ─ 1.0.1-dev0
                     ╰─ pre_l ─ 1.0.0
  ```

  The `pre_n` path is now missing because it is automated.

  The full development and release path now is:

  - `1.0.0`
  - `bump patch` → `1.0.1-dev0`
    - each commit will increase → `1.0.1-dev1`
  - `bump pre_l` → `1.0.1-rc0`
    - each commit will increase → `1.0.1-rc1`
  - `bump pre_l` → `1.0.1`

  1. You must decide on the next version before you start developing.
  2. Development versions increase automatically with each commit.
  3. Switch from development to release candidate using `bump-my-version bump pre_l`.
  4. Release candidate versions increase automatically with each commit.
  5. Switch from the release candidate to the final release using `bump-my-version bump pre_l`.

  <!--tutorial end-->



  You can use `bump-my-version` as part of a GHA workflow. Here is an example of a workflow that bumps the version, commits the change, and tags the commit.

  ```yaml title="GitHub Actions Workflow"
  name: Bump version

  on:
    workflow_dispatch:
      inputs:
        bump-type:
          description: 'Bump type'
          required: true
          default: 'patch'
          type: choice
          options:
          - major
          - minor
          - patch

  jobs:
    build:
      runs-on: ubuntu-latest
      steps:
        - name: Checkout the code
          uses: actions/checkout@v4

        - name: Bump version
          id: bump
          uses: callowayproject/bump-my-version@master
          env:
            BUMPVERSION_TAG: "true"
          with:
            args: ${{ inputs.bump-type }}
            github-token: ${{ secrets.GH_TOKEN }}

        - name: Check
          if: steps.bump.outputs.bumped == 'true'
          run: |
            echo "Version was bumped from ${{ steps.bump.outputs.previous-version }} to ${{ steps.bump.outputs.current-version }}!"
  ```

  Inputs for the bump-my-version action are:
  1. `args` - The arguments to pass to the `bump-my-version bump [args]` command. See the CLI documentation for more information.
  2. `github-token` - The GitHub token to use for committing and tagging. This is optional.

  Output:
  1. `bumped` - Boolean flag for whether the version was bumped.
  2. `previous-version` - Version before bump was performed.
  3. `current-version` - Version after performing bump.

  If you want to ensure that workflows set up with on-push trigger will also start based on those newly pushed commits or tags, you need to provide a custom PAT (`github-token`). See [here](https://github.com/orgs/community/discussions/25702).



  Thank you, contributors! You can find a full list here: https://github.com/callowayproject/bump-my-version/graphs/contributors

  See also our [CONTRIBUTING.md](https://github.com/callowayproject/bump-my-version/blob/master/CONTRIBUTING.md)

  Development of this happens on GitHub, patches including tests, and documentation are very welcome, as well as bug reports! Please open an issue if this tool does not support every aspect of bumping versions in your development
  workflow, as it is intended to be very versatile.



  Bump My Version is licensed under the MIT License - see the [LICENSE](https://github.com/callowayproject/bump-my-version/blob/master/LICENSE) file for details

  <!--end-->

rpm_license:
  MIT License  Copyright (c) 2013-2014 Filip Noetzel  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: fbf91bee12a334b0881981dd45f911fa16f45e1b8d425b8cc5cb108f308a059b
name: python-bump-my-version-help
arch: noarch
version: 0.29.0
epoch: 0
release: 1
summary: Development documents and examples for bump-my-version
url: https://pypi.org/project/bump-my-version/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bump-my-version-0.29.0-1.src.rpm
location_href: Packages/python-bump-my-version-help-0.29.0-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/bump-my-version.svg)](https://pypi.org/project/bump-my-version/)
  [![image](https://img.shields.io/pypi/l/bump-my-version.svg)](https://github.com/callowayproject/bump-my-version/blob/master/LICENSE)
  [![image](https://img.shields.io/pypi/pyversions/bump-my-version.svg)](https://pypi.org/project/bump-my-version/)
  [![codecov](https://codecov.io/gh/callowayproject/bump-my-version/branch/master/graph/badge.svg?token=D1GSOtWEPU)](https://codecov.io/gh/callowayproject/bump-my-version)
  [![GitHub Actions](https://github.com/callowayproject/bump-my-version/workflows/CI/badge.svg)](https://github.com/callowayproject/bump-my-version/actions)

  > **NOTE**
  >
  > This is a maintained refactor of the [bump2version fork](https://github.com/c4urself/bump2version) of the excellent [bumpversion project](https://github.com/peritus/bumpversion). The main goals of this refactor were:
  >
  > - Add support for `pyproject.toml` configuration files.
  > - Convert to [click](https://click.palletsprojects.com/en/8.1.x/) for and [rich](https://rich.readthedocs.io/en/stable/index.html) for the CLI interface
  > - Add better configuration validation using [Pydantic](https://docs.pydantic.dev)
  > - Make the code and tests easier to read and maintain

  <!--start-->



  Bump My Version's purpose is to:

  - Work as a part of an automated build system
  - Manage project versioning through the project's development life cycle
      - Incrementing version numbers
      - serializing version numbers
      - parsing version numbers
      - supporting SemVer, CalVer, and other versioning schemes
  - Modify project files as part of the project's development life cycle
  - Work with the project's source control system
      - Committing changes
      - Tagging releases
      - Reading version numbers from tags



  You can download and install the latest version of this software from the Python package index (PyPI) as follows:

  ```console
  pip install --upgrade bump-my-version
  ```



  Please find the changelog here: [CHANGELOG.md](https://github.com/callowayproject/bump-my-version/blob/master/CHANGELOG.md)


  <!--tutorial start-->



  The default configuration uses a simplified version of [semantic versioning](https://semver.org/).

  ```console title="Generating a default configuration"
  $ bump-my-version sample-config --no-prompt --destination .bumpversion.toml
  $ cat .bumpversion.toml
  [tool.bumpversion]
  current_version = "0.1.0"
  parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
  serialize = ["{major}.{minor}.{patch}"]
  search = "{current_version}"
  replace = "{new_version}"
  regex = false
  ignore_missing_version = false
  tag = false
  sign_tags = false
  tag_name = "v{new_version}"
  tag_message = "Bump version: {current_version} → {new_version}"
  allow_dirty = false
  commit = false
  message = "Bump version: {current_version} → {new_version}"
  commit_args = ""
  ```



  You can see the potential versioning paths with the `show-bump` subcommand.

  ```console title="Showing the potential versioning path"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0
                 ├─ minor ─ 0.2.0
                 ╰─ patch ─ 0.1.1
  $ bump-my-version show-bump 1.2.3
  1.2.3 ── bump ─┬─ major ─ 2.0.0
                 ├─ minor ─ 1.3.0
                 ╰─ patch ─ 1.2.4
  ```

  The default configuration only allows bumping the major, minor, or patch version. What if you wanted to support pre-release versions?



  Alter the `parse` configuration to support pre-release versions. This `parse` option uses an extended (or verbose) regular expression to extract the version components from the current version.

  ```toml title="New parse configuration"
  parse = """(?x)
      (?P<major>0|[1-9]\\d*)\\.
      (?P<minor>0|[1-9]\\d*)\\.
      (?P<patch>0|[1-9]\\d*)
      (?:
          -                             # dash separator for pre-release section
          (?P<pre_l>[a-zA-Z-]+)         # pre-release label
          (?P<pre_n>0|[1-9]\\d*)        # pre-release version number
      )?                                # pre-release section is optional
  """
  ```

  Alter the `serialize` configuration to support pre-release versions.

  ```toml title="New serialize configuration"
  serialize = [
      "{major}.{minor}.{patch}-{pre_l}{pre_n}",
      "{major}.{minor}.{patch}",
  ]
  ```

  Add a new configuration section for the `pre_l` part.

  ```toml title="New pre_l configuration"

  [tool.bumpversion.parts.pre_l]
  values = ["dev", "rc", "final"]
  optional_value = "final"
  ```



  Now when you run `bump-my-version show-bump`, you can see the new pre-release versioning path.

  ```console title="Showing the new versioning path"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0-dev0
                 ├─ minor ─ 0.2.0-dev0
                 ├─ patch ─ 0.1.1-dev0
                 ├─ pre_l ─ invalid: The part has already the maximum value among ['dev', 'rc', 'final'] and cannot be bumped.
                 ╰─ pre_n ─ 0.1.0-final1
  ```

  The `pre_l` is not bump-able because it is already at the maximum value. The `pre_n` is bump-able because it is not at the maximum value.

  If we run `bump-my-version show-bump 1.0.0-dev0`, we can see the new versioning path for a `dev` starting version.

  ```console title="Showing the new versioning path for a dev version"
  $ bump-my-version show-bump 1.0.0-dev0
  1.0.0-dev0 ── bump ─┬─ major ─ 2.0.0-dev0
                      ├─ minor ─ 1.1.0-dev0
                      ├─ patch ─ 1.0.1-dev0
                      ├─ pre_l ─ 1.0.0-rc0
                      ╰─ pre_n ─ 1.0.0-dev1
  ```

  Finally, we can see the new versioning path for a `rc` starting version.

  ```console title="Showing the new versioning path for an rc version"
  $ bump-my-version show-bump 1.0.0-rc0
  1.0.0-rc0 ── bump ─┬─ major ─ 2.0.0-dev0
                     ├─ minor ─ 1.1.0-dev0
                     ├─ patch ─ 1.0.1-dev0
                     ├─ pre_l ─ 1.0.0
                     ╰─ pre_n ─ 1.0.0-rc1
  ```

  The full development and release path is:

  - `1.0.0`
  - `bump patch` → `1.0.1-dev0`
  - `bump pre_n` → `1.0.1-dev1`
  - `bump pre_l` → `1.0.1-rc0`
  - `bump pre_n` → `1.0.1-rc1`
  - `bump pre_l` → `1.0.1`

  1. You must decide on the next version before you start developing.
  2. Development versions increase using `bump-my-version bump pre_n`.
  3. Switch from development to release candidate using `bump-my-version bump pre_l`.
  4. Release candidates increase using `bump-my-version bump pre_n`.
  5. Switch from the release candidate to the final release using `bump-my-version bump pre_l`.



  The `pre_n` or pre-release number is a number that increases with each pre-release. You can automate this by changing the serialization configuration.

  ```toml title="Serialize configuration with pre_n automation"
  parse = """(?x)
      (?P<major>0|[1-9]\\d*)\\.
      (?P<minor>0|[1-9]\\d*)\\.
      (?P<patch>0|[1-9]\\d*)
      (?:
          -                             # dash separator for pre-release section
          (?P<pre_l>[a-zA-Z-]+)         # pre-release label
          (?:0|[1-9]\\d*)               # pre-release version number
      )?                                # pre-release section is optional
  """

  serialize = [
      "{major}.{minor}.{patch}-{pre_l}{distance_to_latest_tag}",
      "{major}.{minor}.{patch}",
  ]
  ```

  Now the `pre_n` is no longer captured in the `parse` expression and `serialize` replaces `pre_n` with `distance_to_latest_tag`. The `distance_to_latest_tag` is a special value replaced with the number of commits since the last tag. This is a good value to use for the `pre_n` because it will always increase with each commit.



  Now when you run `bump-my-version show-bump`, you can see the new pre-release versioning path.

  ```console title="Showing the new versioning path with pre_n automation"
  $ bump-my-version show-bump
  0.1.0 ── bump ─┬─ major ─ 1.0.0-dev0
                 ├─ minor ─ 0.2.0-dev0
                 ├─ patch ─ 0.1.1-dev0
                 ╰─ pre_l ─ invalid: The part has already the maximum value among ['dev', 'rc', 'final'] and cannot be bumped.
  $ bump-my-version show-bump 1.0.0-dev0
  1.0.0-dev0 ── bump ─┬─ major ─ 2.0.0-dev0
                      ├─ minor ─ 1.1.0-dev0
                      ├─ patch ─ 1.0.1-dev0
                      ╰─ pre_l ─ 1.0.0-rc0
  $ bump-my-version show-bump 1.0.0-rc0
  1.0.0-rc0 ── bump ─┬─ major ─ 2.0.0-dev0
                     ├─ minor ─ 1.1.0-dev0
                     ├─ patch ─ 1.0.1-dev0
                     ╰─ pre_l ─ 1.0.0
  ```

  The `pre_n` path is now missing because it is automated.

  The full development and release path now is:

  - `1.0.0`
  - `bump patch` → `1.0.1-dev0`
    - each commit will increase → `1.0.1-dev1`
  - `bump pre_l` → `1.0.1-rc0`
    - each commit will increase → `1.0.1-rc1`
  - `bump pre_l` → `1.0.1`

  1. You must decide on the next version before you start developing.
  2. Development versions increase automatically with each commit.
  3. Switch from development to release candidate using `bump-my-version bump pre_l`.
  4. Release candidate versions increase automatically with each commit.
  5. Switch from the release candidate to the final release using `bump-my-version bump pre_l`.

  <!--tutorial end-->



  You can use `bump-my-version` as part of a GHA workflow. Here is an example of a workflow that bumps the version, commits the change, and tags the commit.

  ```yaml title="GitHub Actions Workflow"
  name: Bump version

  on:
    workflow_dispatch:
      inputs:
        bump-type:
          description: 'Bump type'
          required: true
          default: 'patch'
          type: choice
          options:
          - major
          - minor
          - patch

  jobs:
    build:
      runs-on: ubuntu-latest
      steps:
        - name: Checkout the code
          uses: actions/checkout@v4

        - name: Bump version
          id: bump
          uses: callowayproject/bump-my-version@master
          env:
            BUMPVERSION_TAG: "true"
          with:
            args: ${{ inputs.bump-type }}
            github-token: ${{ secrets.GH_TOKEN }}

        - name: Check
          if: steps.bump.outputs.bumped == 'true'
          run: |
            echo "Version was bumped from ${{ steps.bump.outputs.previous-version }} to ${{ steps.bump.outputs.current-version }}!"
  ```

  Inputs for the bump-my-version action are:
  1. `args` - The arguments to pass to the `bump-my-version bump [args]` command. See the CLI documentation for more information.
  2. `github-token` - The GitHub token to use for committing and tagging. This is optional.

  Output:
  1. `bumped` - Boolean flag for whether the version was bumped.
  2. `previous-version` - Version before bump was performed.
  3. `current-version` - Version after performing bump.

  If you want to ensure that workflows set up with on-push trigger will also start based on those newly pushed commits or tags, you need to provide a custom PAT (`github-token`). See [here](https://github.com/orgs/community/discussions/25702).



  Thank you, contributors! You can find a full list here: https://github.com/callowayproject/bump-my-version/graphs/contributors

  See also our [CONTRIBUTING.md](https://github.com/callowayproject/bump-my-version/blob/master/CONTRIBUTING.md)

  Development of this happens on GitHub, patches including tests, and documentation are very welcome, as well as bug reports! Please open an issue if this tool does not support every aspect of bumping versions in your development
  workflow, as it is intended to be very versatile.



  Bump My Version is licensed under the MIT License - see the [LICENSE](https://github.com/callowayproject/bump-my-version/blob/master/LICENSE) file for details

  <!--end-->

rpm_license:
  MIT License  Copyright (c) 2013-2014 Filip Noetzel  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 1bd569beb3d1249cc5042ab75b61555b83813f8373fe258055f16e8c018855ff
name: python-bumpcalver-help
arch: noarch
version: 2024.12.14.1
epoch: 0
release: 1
summary: Development documents and examples for bumpcalver
url: https://github.com/devsetgo/bumpcalver
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-bumpcalver-2024.12.14.1-1.src.rpm
location_href: Packages/python-bumpcalver-help-2024.12.14.1-1.noarch.rpm
checksum_type: sha256
description:
  - Documentation Site: [BumpCalver CLI](https://devsetgo.github.io/bumpcalver/)
  - [Installation](#installation)
  - [Getting Started](#getting-started)
  - [Configuration](#configuration)
    - [Example Configuration](#example-configuration)
  - [Command-Line Usage](#command-line-usage)
    - [Options](#options)
  - [Examples](#examples)
  - [Error Handling](#error-handling)

rpm_license:
  MIT License  Copyright (c) 2024 Mike  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: ec841ec230fbc247ffbe1e85505267badf260149f59599acb63e88d2c29ba284
name: python-busnearby-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for busnearby
url: https://github.com/t0mer/py-busnearby
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-busnearby-0.1.3-1.src.rpm
location_href: Packages/python-busnearby-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A Python library to get bus times from the Bus Nearby API https://www.busnearby.co.il/




  You can install the library from PyPI:

  ```bash
  pip install busnearby
  ```

  Alternatively, you can install it directly from the source:

  ```bash
  git clone https://github.com/t0mer/py-busnearby.git
  cd bus_times
  pip install .
  ```


  Here are some examples of how to use the library:



  To get bus times for a specific station and bus lines, you can use the get_bus_times function.

  ```python
  from busnearby import BusNearBy
  import asyncio

  bus = BusNearBy()

  async def main():
      station = "34501"
      bus_lines = "609,636,10,15"
      try:
          result = await bus.get_bus_times(station, bus_lines)
          print(result)
      except ValueError as e:
          print(f"Error: {e}")
      except RuntimeError as e:
          print(f"Error: {e}")

  asyncio.run(main())
  ```



  ```json
  {
      "stationName": "שדרות וייצמן/עקיבא",
      "time": "2024-07-22 13:10:43.974935",
      "buses": [
          {
              "lineNumber": "10",
              "arrivalSeconds": 644
          },
          {
              "lineNumber": "15",
              "arrivalSeconds": 1501
          },
          {
              "lineNumber": "609",
              "arrivalSeconds": 2210
          },
          {
              "lineNumber": "636",
              "arrivalSeconds": 3532
          },
          {
              "lineNumber": "636",
              "arrivalSeconds": 6728
          }
      ]
  }
  ```


  Contributions are welcome! Please open an issue or submit a pull request on GitHub.


pkgId: 09206fb1f8226b9ad84b8eeda6d678fa1319ff3ebe1b33c37561ae4680609e43
name: python-c2cciutils-help
arch: noarch
version: 1.7.1
epoch: 0
release: 1
summary: Development documents and examples for c2cciutils
url: https://github.com/camptocamp/c2cciutils
rpm_license: FreeBSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-c2cciutils-1.7.1-1.src.rpm
location_href: Packages/python-c2cciutils-help-1.7.1-1.noarch.rpm
checksum_type: sha256
description:
  The main goals of C2C CI utils is to offer the commands to publish the project,
  see the [documentation](https://github.com/camptocamp/c2cciutils/wiki/Publishing).



  When we create a tag by default with the `changelog` workflow a release is created on GitHub, a changelog is
  generated and added to the release.



  C2C CI utils will no more provide a tool to do a check of the project, this is replaced by `pre-commit`,
  a base configuration is provided in the example project.



  A workflow is provided to run the checks on the pull requests, it will run the `c2cciutils-pr-checks` command.

  - Check that the commit message and the pull request title start with a capital letter.
  - Check that there aren't any spelling issue in the commit message and in the pull request title.
  - Add a message to the pull request with a link to the JIRA issue if the pull request branch name starts with
    `[a-zA-Z]+-[0-9]+-` or end with `-[a-zA-Z]+-[0-9]+`.



  In the example project there is a basic Renovate configuration, it will update the dependencies of the project.
  There is also a workflow to add a review on the Renovate pull requests to make the auto merge working on
  repository that required a review.



  A workflow is provided to backport the pull requests on the stabilization branches, it will be triggered by
  adding a label named `backport <destination_branch>` on the pull request.



  GitHub will retain all the old workflows, so we need to delete them, the `delete-old-workflows-run`
  workflow will delete the workflows older than 500 days.



  C2cciutils make easier to have those workflows in a project:

  - `auto-review.yaml`: Auto review the Renovate pull requests
  - `backport.yaml`: Trigger the backports (work with labels)
  - `clean.yaml`: Clean the Docker images related on a deleted feature branch
  - `main.yaml`: Main workflow especially with the c2cciutils-checks command

  All the provided commands used in the workflow:

  - `c2cciutils`: some generic tools.
  - `c2cciutils-version`: Create a new version of the project.
  - `c2cciutils-env`: Print some environment information.
  - `c2cciutils-publish`: Publish the project.
  - `c2cciutils-clean`: Delete Docker images on Docker Hub after corresponding branch have been deleted.



  The following utilities are provided:

  - `c2cciutils`: some generic tools.
  - `c2cciutils-download-applications`: Download the applications with version managed by Renovate, see below.
  - `c2cciutils-docker-logs`: Display the logs of the application in Docker (compose).
  - `c2cciutils-k8s-install`: Install a k3d / k3s cluster, see below.
  - `c2cciutils-k8s-logs`: Display the logs of the application in the k8s cluster, see below.
  - `c2cciutils-k8s-db`: Create a database in the k8s cluster, see below.
  - `c2cciutils-k8s-wait`: Wait that the application started correctly in the cluster, see below.
  - `c2cciutils-docker-versions-gen`: Generate the Docker package versions file (`ci/dpkg-versions.yaml`), see below.
  - `c2cciutils-pin-pipenv`: Display all the dependencies that's in the `Pipenv.lock` but not in the `Pipenv` to be able to pin them.
  - `c2cciutils-trigger-image-update`: Trigger the ArgoCD repository about image update on the CI (automatically done in the publishing).
  - `c2cciutils-google-calendar`: Tool to test the Google credentials for calendar API and refresh them if needed. See `c2cciutils-google-calendar -h` for more information.



  The content of `example-project` can be a good base for a new project.



  Requirements: the right version (>= 1.6) of `c2cciutils` should be installed with the `version` extra.

  To create a new minor version you just should run `c2cciutils-version --version=<version>`.

  You are welcome to run `c2cciutils-version --help` to see what's it's done.

  Note that it didn't create a tag, you should do it manually.

  To create a patch version you should just create tag.



  In the CI we need to have the following secrets::

  - `HAS_SECRETS` to be set to 'HAS_SECRETS', to avoid error errors from external
    pull requests, already set globally on Camptocamp organization.
  - `GOPASS_CI_GITHUB_TOKEN` and `CI_GPG_PRIVATE_KEY` required to initialize the gopass password store,
    the secrets exists in the Camptocamp organization but not shared on all project, then you should add
    your project to the shared list.



  Install it: `python3 -m pip install --user --requirement ci/requirements.txt`
  Dry run publish: `GITHUB_REF=... c2cciutils-publish --dry-run ...`



  You can get the current configuration with `c2cciutils --get-config`, the default configuration depends on your project.
  Note that it didn't contain the default defined the schema and visible in the [generated documentation](./config.md).

  You can override the configuration with the file `ci/config.yaml`.

  At the base of the configuration you have:

  - `version`: Contains some regular expressions to find the versions branches and tags, and to convert them into application versions.
  - `publish`: The publishing configuration, see `c2cciutils/publish.py` for more information.

  Many actions can be disabled by setting the corresponding configuration part to `False`.



  The `SECURITY.md` file should contain the security policy of the repository, especially the end of
  support dates.

  For compatibility with `c2cciutils` it should contain an array with at least the columns
  `Version` and `Supported Until`. The `Version` column will contain the concerned version.
  The `Supported Until` will contain the date of end of support `dd/mm/yyyy`.
  It can also contain the following sentences:

  - `Unsupported`: no longer supported => no audit, no rebuild.
  - `Best effort`: the support is ended, it is still rebuilt and audited, but this can be stopped without any notice.
  - `To be defined`: not yet released or the date will be set related of another project release date (like for GeoMapFish).

  See also [GitHub Documentation](https://docs.github.com/en/github/managing-security-vulnerabilities/adding-a-security-policy-to-your-repository)



  The IDE should be configured as:

  - using `black` and `isort` without any arguments,
  - using the `editorconfig` configuration.



  - Recommend extensions to work well with c2cciutils:
    - [Prettier](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode) And use EditorConfig
    - [shell-format](https://marketplace.visualstudio.com/items?itemName=foxundermoon.shell-format) With the configuration
      `"shellformat.flag": "-bn"`.
    - [Better TOML](https://marketplace.visualstudio.com/items?itemName=bodil.prettier-toml)
  - Other recommend extensions:
    - [hadolint](https://marketplace.visualstudio.com/items?itemName=exiasr.hadolint)
    - [Code Spell Checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker)

  Select a formatter:

  - `CTRL+MAJ+P`
  - Format document With...
  - Configure Default Formatter...
  - Select the formatter





  The config is like this:

  ```yaml
  versions:
    
    
    
  ```

  It we have a `setup.py` file, we will be in legacy mode:
  When publishing, the version computed from arguments or `GITHUB_REF` is put in environment variable `VERSION`, thus you should use it in `setup.py`, example:

  ```python
  VERSION = os.environ.get("VERSION", "1.0.0")
  ```

  Also we consider that we use `poetry` with [poetry-dynamic-versioning](https://pypi.org/project/poetry-dynamic-versioning/) to manage the version, and [poetry-plugin-tweak-dependencies-version](https://pypi.org/project/poetry-plugin-tweak-dependencies-version/) to manage the dependencies versions.

  Example of configuration:

  ```toml
  [tool.poetry-dynamic-versioning]
  enable = true
  vcs = "git"
  pattern = "^(?P<base>\\d+(\\.\\d+)*)"
  format-jinja = """
  { if env.get("VERSION_TYPE") == "version_branch" -%}
  {{serialize_pep440(bump_version(base, 1 if env.get("IS_MASTER") == "TRUE" else 2), dev=distance)}}
  { elif distance == 0 -%}
  {{serialize_pep440(base)}}
  { else -%}
  {{serialize_pep440(bump_version(base), dev=distance)}}
  { endif -%}
  """

  ```

  Note that we can access to the environment variables `VERSION`,`VERSION_TYPE` and `IS_MASTER`.

  Then by default:

  - Tag with `1.2.3` => release `1.2.3`
  - Commit on feature branch just do a validation
  - Commit on `master` branch after the tag 1.3.0 => release `1.4.0.dev1`
  - Commit on `1.3` branch after the tag 1.3.0 => release `1.3.1.dev1`



  If the file `~/.pypirc` exists we consider that we ar already logged in also
  we will do the login with the `pypi` server with OpenID Connect (OIDC).

  The OIDC login is recommended because it didn't needs any additional secrets,
  but it need some configuration on pypi in the package,
  see the [GitHub Documentation](https://docs.github.com/en/actions/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-pypi#adding-the-identity-provider-to-pypi).



  To make it working in the `Dockerfile` you should have in the `poetry` stage:

  ```Dockerfile
  ENV POETRY_DYNAMIC_VERSIONING_BYPASS=dev
  RUN poetry export --extras=checks --extras=publish --output=requirements.txt \
      && poetry export --with=dev --output=requirements-dev.txt
  ```

  And in the `run` stage

  ```Dockerfile
  ARG VERSION=dev
  RUN --mount=type=cache,target=/root/.cache \
      POETRY_DYNAMIC_VERSIONING_BYPASS=${VERSION} python3 -m pip install --disable-pip-version-check --no-deps --editable=.
  ```

  And in the `Makefile`:

  ```Makefile
  VERSION = $(strip $(shell poetry version --short))

  .PHONY: build
  build: ## Build the Docker images
      docker build --build-arg=VERSION=$(VERSION) --tag=$(GITHUB_REPOSITORY) .
  ```



  The config is like this:

  ```yaml
  latest: True
  images:
    - # The base name of the image we want to publish
      name:
  repository:
    <internal_name>:
      
      server:
      
      
      version:
      
      
      
      
      tags:
      
      
      group:
  ```

  By default, the last line of the `SECURITY.md` file will be published (`docker`) with the tag
  `latest`. Set `latest` to `False` to disable it.

  With the `c2cciutils-clean` the images on Docker hub for `feature_branch` will be removed on branch removing.



  In case some executables or applications from GitHub releases or any other URLs are required on the CI host
  and are not handled by any dependency manager, we provide a set of tools to install them and manage upgrades
  through Renovate.

  Create an application file (e.-g. `applications.yaml`) with:

  ```yaml



  <organization>/<project>:
    get-file-name: <file name present in the release>
    to-file-name: <The file name you want to create in ~/.local/bin>
    finish-command: # The command you want to run after the file is downloaded
      - - chmod # To be executable (usually required)
        - +x
        - <to-file-name>
      - - <to-file-name> # Print the version of the application
        - --version

  <organization>/<project>:
    get-file-name: <file name present in the release>
    type: tar
    tar-file-name: <The file name available in the tar file>
    to-file-name: <The file name you want to create in ~/.local/bin>
    finish-command: [...] # The command you want to run after the file is downloaded

  <application reference name>:
    url-pattern: <The URL used to download the application>
    to-file-name: <The file name you want to create in ~/.local/bin>
    finish-command: [...] # The command you want to run after the file is downloaded
  ```

  In the attributes `url-pattern`, `get-file-name` you can use the following variables:

  - `{version}`: The version of the application present in the version file.
  - `{version_quote}`: The URL encoded version.
  - `{short_version}`: The version without the `v` prefix.

  The `applications-versions.yaml` file is a map of applications and their versions.

  Add in your Renovate configuration:

  ```json5
    regexManagers: [
      {
        fileMatch: ['^applications-versions.yaml$'],
        matchStrings: [
          '(?<depName>[^\\s]+): (?<currentValue>[^\\s]+) # (?<datasource>[^\\s]+)',
        ],
      },
    ],
  ```

  Now you need to call `c2cciutils-download-applications --applications-file=applications.yaml --versions-file=applications-version.yaml`
  to install required applications on CI host before using them (an already installed application is installed only if needed).



  Run the command `c2cciutils-docker-versions-gen camptocamp/image[:tag]` to generate a file that is a kind of package lock of the Debian packages in the file `ci/dpkg-versions.yaml`.

  Add in your renovate configuration:

  ```javascript
    regexManagers: [
      {
        fileMatch: ['^ci/dpkg-versions.yaml$'],
        matchStrings: [" *(?<depName>[^'\\s]+): '?(?<currentValue>[^'\\s/]*[0-9][^'\\s/]*)'?"],
        datasourceTemplate: 'repology',
        versioningTemplate: 'loose',
      },
    ],
  ```

  When a new version of a Debian package will be available:

  - Renovate will automatically open a pull request to update the file `ci/dpkg-versions.yaml`.
  - And the continuous integration will build a new fresh Docker image with latest versions of all Debian packages.



  C2cciutils provide some commands for Kubernetes.

  You can define a workflow like that:

  ```yaml
  - name: Install k3s/k3d (Kubernetes cluster)
    run: c2cciutils-k8s-install

  - name: Create a database to do the tests
    run: c2cciutils-k8s-db --script=<my_script>.sql

  - name: Install the application in the Kubernetes cluster
    run: kubectl apply -f <my_application>.yaml

  - name: Wait that the application is ready
    run: c2cciutils-k8s-wait
  - name: Print the application status and logs
    run: c2cciutils-k8s-logs
    if: always()

  - name: Uninstall the application
    run: kubectl delete -f <my_application>.yaml || true

  - name: Cleanup the database
    run: c2cciutils-k8s-db --cleanup
  ```

  `c2cciutils-k8s-install` can be configured in the `ci/config.yaml` file, in section `k8s/k3d/install-commands`, default is:

  ```yaml
  - - k3d
      cluster
      create
      test-cluster
      --no-lb
      --no-rollback
  ```

  See also: [K3d cluster create documentation](https://k3d.io/v4.4.8/usage/commands/k3d_cluster_create/).

  `c2cciutils-k8s-db` can be configured in the `ci/config.yaml` file, in section `k8s/db/chart-options`, default is:

  ```yaml
  persistence.enabled: 'false'
  tls.enabled: 'true'
  tls.autoGenerated: 'true'
  postgresqlPassword: mySuperTestingPassword
  volumePermissions.enabled: 'true'
  ```

  See also: [Parameters documentations](https://github.com/bitnami/charts/tree/master/bitnami/postgresql#parameters).



  Install the pre-commit hooks:

  ```bash
  pip install pre-commit
  pre-commit install --allow-missing-config
  ```


pkgId: ed694a913254784fa88ddcaf33d6240d666d06aa037cf6551952babd2be3b470
name: python-c2cwsgiutils-help
arch: noarch
version: 6.1.5
epoch: 0
release: 1
summary: Development documents and examples for c2cwsgiutils
url: https://github.com/camptocamp/c2cwsgiutils
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-c2cwsgiutils-6.1.5-1.src.rpm
location_href: Packages/python-c2cwsgiutils-help-6.1.5-1.noarch.rpm
checksum_type: sha256
description:
  This is a Python 3 library providing common tools for Camptocamp WSGI
  applications:

  - Provide prometheus metrics
  - Allow to use a master/slave PostgresQL configuration
  - Logging handler for CEE/UDP logs
    - An optional view to change runtime the log levels
  - SQL profiler to debug DB performance problems, disabled by default. Warning, it will slow down everything.
  - A view to get the version information about the application and the installed packages
  - A framework for implementing a health_check service
  - Error handlers to send JSON messages to the client in case of error
  - A cornice service drop in replacement for setting up CORS

  Also provide tools for writing acceptance tests:

  - A class that can be used from a py.test fixture to control a composition
  - A class that can be used from a py.text fixture to test a REST API

  As an example on how to use it in an application provided by a Docker image, you can look at the
  test application in [acceptance_tests/app](acceptance_tests/app).
  To see how to test such an application, look at [acceptance_tests/tests](acceptance_tests/tests).





  Here we didn't do a minimal install of c2cwsgiutils, but be put in place everything needed to
  monitor the application in integration and production environment.

  The library is available in PYPI:
  [https://pypi.python.org/pypi/c2cwsgiutils](https://pypi.python.org/pypi/c2cwsgiutils)

  Copy and adapt these template configuration file into your project:

  - [production.ini](acceptance_tests/app/production.ini);
  - [gunicorn.conf.py](acceptance_tests/app/gunicorn.conf.py).
    Then replace `c2cwsgiutils_app` by your package name.

  You should install `c2cwsgiutils` with the tool you use to manage your pip dependencies.

  In the `Dockerfile` you should add the following lines:

  ```dockerfile

  RUN c2cwsgiutils-genversion $(git rev-parse HEAD)

  CMD ["gunicorn", "--paste=/app/production.ini"]


  ENV \
    DEVELOPMENT=0 \
    SQLALCHEMY_POOL_RECYCLE=30 \
    SQLALCHEMY_POOL_SIZE=5 \
    SQLALCHEMY_MAX_OVERFLOW=25 \
    SQLALCHEMY_SLAVE_POOL_RECYCLE=30 \
    SQLALCHEMY_SLAVE_POOL_SIZE=5 \
    SQLALCHEMY_SLAVE_MAX_OVERFLOW=25\
    LOG_TYPE=console \
    OTHER_LOG_LEVEL=WARNING \
    GUNICORN_LOG_LEVEL=WARNING \
    SQL_LOG_LEVEL=WARNING \
    C2CWSGIUTILS_LOG_LEVEL=WARNING \
    LOG_LEVEL=INFO
  ```

  Add in your `main` function.

  ```python
  config.include("c2cwsgiutils.pyramid")
  dbsession = c2cwsgiutils.db.init(config, "sqlalchemy", "sqlalchemy_slave")

  config.scan(...)


  health_check = c2cwsgiutils.health_check.HealthCheck(config)
  health_check.add_db_session_check(dbsession)
  health_check.add_alembic_check(dbsession, "/app/alembic.ini", 1)
  ```

  The related environment variables:

  - `DEVELOPMENT`: set to `1` to enable the development mode, default is `0`.
  - `SQLALCHEMY_URL`: SQL alchemy URL, like `postgresql://user:password@host:port/dbname`.
  - `SQLALCHEMY_POOL_RECYCLE`: The SQL alchemy pool recycle, default is `30`.
  - `SQLALCHEMY_POOL_SIZE`: The SQL alchemy pool size, default is `5`.
  - `SQLALCHEMY_MAX_OVERFLOW`: SQL alchemy max overflow, default is `25`.
  - `SQLALCHEMY_SLAVE_URL`: The SQL alchemy slave (read only) URL, like `postgresql://user:password@host:port/dbname`.
  - `SQLALCHEMY_SLAVE_POOL_RECYCLE`: The SQL alchemy slave pool recycle, default is `30`.
  - `SQLALCHEMY_SLAVE_POOL_SIZE`: The SQL alchemy slave pool size, default is `5`.
  - `SQLALCHEMY_SLAVE_MAX_OVERFLOW`: The SQL alchemy slave max overflow, default is `25`.
  - `GUNICORN_WORKERS`: The number of workers, default is `2`.
  - `GUNICORN_THREADS`: The number of threads per worker, default is `10`.
  - `LOG_TYPE`: The types of logs, default is `console`, should be `json` on kubernetes to work well with
    [elk](https://www.elastic.co/fr/what-is/elk-stack).
  - `LOG_LEVEL`: The application log level, default is `INFO`.
  - `SQL_LOG_LEVEL`: The SQL query log level, `WARNING`: no logs, `INFO`: logs the queries,
    `DEBUG` also logs the results, default is `WARNING`.
  - `GUNICORN_ERROR_LOG_LEVEL`: The Gunicorn error log level, default is `WARNING`.
  - `C2CWSGIUTILS_CONFIG`: The fallback ini file to use by gunicorn, default is `production.ini`.
  - `C2CWSGIUTILS_LOG_LEVEL`: The c2c WSGI utils log level, default is `WARNING`.
  - `OTHER_LOG_LEVEL`: The log level for all the other logger, default is `WARNING`.

  Those environment variables can be useful for investigation on production environments.



  Or (deprecated) as a base Docker image:
  [camptocamp/c2cwsgiutils:release_5](https://hub.docker.com/r/camptocamp/c2cwsgiutils/) or
  [ghcr.io/camptocamp/c2cwsgiutils:release_5](https://github.com/orgs/camptocamp/packages/container/package/c2cwsgiutils)

  If you need an image with a smaller foot print, use the tags prefixed with `-light`. Those are without
  GDAL and without the build tools.

  We deprecate the Docker image because:

  - The project wants to choose the base image.
  - The project pin different versions of the dependencies.



  In general, configuration can be done both with environment variables (taken first) or with entries in the
  `production.ini` file.

  You can configure the base URL for accessing the views provided by c2cwsgiutils with an environment variable
  named `C2C_BASE_PATH` or in the `production.ini` file with a property named `c2c.base_path`.

  A few REST APIs are added and can be seen with this URL:
  `{C2C_BASE_PATH}`.

  Some APIs are protected by a secret. This secret is specified in the `C2C_SECRET` variable or `c2c.secret`
  property. It is either passed as the `secret` query parameter or the `X-API-Key` header. Once
  accessed with a good secret, a cookie is stored and the secret can be omitted.

  An alternative of using `C2C_SECRET` is to use an authentication on GitHub,
  [create the GitHub application](https://github.com/settings/applications/new).

  Configure the json renderers with the `C2C_JSON_PRETTY_PRINT` and `C2C_JSON_SORT_KEYS` environment
  variables or `c2c.json.pretty_print`and `c2c.json.sort_keys` properties. Default is `false`.

  Then it will redirect the user to the github authentication form if not already authenticated
  (using `C2C_AUTH_GITHUB_CLIENT_ID`, `C2C_AUTH_GITHUB_CLIENT_SECRET` and `C2C_AUTH_GITHUB_SCOPE`).

  Then we will check if the user is allowed to access to the application, for that we check
  if the user has enough right on a GitHub repository (using `C2C_AUTH_GITHUB_REPOSITORY`
  and `C2C_AUTH_GITHUB_REPOSITORY_ACCESS_TYPE`).

  Finally we store the session information in an encrypted cookie (using `C2C_AUTH_SECRET`
  and `C2C_AUTH_COOKIE`).

  Configuration details:

  Using the environment variable `C2C_AUTH_GITHUB_REPOSITORY` or the config key `c2c.auth.github.repository`
  to define the related GitHub repository (required).

  Using the environment variable `C2C_AUTH_GITHUB_ACCESS_TYPE` or the config key
  `c2c.auth.github.access_type` to define the type of required access can be `pull`, `push` or
  `admin` (default is `push`)

  Using the environment variable `C2C_AUTH_GITHUB_CLIENT_ID` or the config key `c2c.auth.github.client_id` to
  define the GitHub application ID (required)

  Using the environment variable `C2C_AUTH_GITHUB_CLIENT_SECRET` or the config key
  `c2c.auth.github.client_secret` to define the GitHub application secret (required)

  Using the environment variable `C2C_AUTH_GITHUB_SCOPE` or the config key `c2c.auth.github.scope` to define
  the GitHub scope (default is `repo`), see [GitHub documentation](https://developer.github.com/apps/building-oauth-apps/understanding-scopes-for-oauth-apps/)

  Using the environment variable `C2C_AUTH_GITHUB_SECRET` or the config key `c2c.auth.github.auth.secret` to
  define the used secret for JWD encryption (required, with a length at least of 16)

  Using the environment variable `C2C_AUTH_GITHUB_COOKIE` or the config key `c2c.auth.github.auth.cookie` to
  define the used cookie name (default is `c2c-auth-jwt`)

  Using the environment variable `C2C_AUTH_GITHUB_AUTH_URL` or the config key `c2c.auth.github.auth_url` to
  define the GitHub auth URL (default is `https://github.com/login/oauth/authorize`)

  Using the environment variable `C2C_AUTH_GITHUB_TOKEN_URL` or the config key `c2c.auth.github.token_url` to
  define the GitHub auth URL (default is `https://github.com/login/oauth/access_token`)

  Using the environment variable `C2C_AUTH_GITHUB_USER_URL` or the config key `c2c.auth.github.user_url` to
  define the GitHub auth URL (default is `https://api.github.com/user`)

  Using the environment variable `C2C_AUTH_GITHUB_REPO_URL` or the config key `c2c.auth.github.repo_url` to
  define the GitHub auth URL (default is `https://api.github.com/repo`)

  Using the environment variable `C2C_AUTH_GITHUB_PROXY_URL` or the config key `c2c.auth.github.auth.proxy_url` to
  define a redirect proxy between GitHub and our application to be able to share an OAuth2 application on GitHub (default is no proxy).
  Made to work with [this proxy](https://github.com/camptocamp/redirect/).

  Using the environment variable `C2C_USE_SESSION` or the config key `c2c.use_session` to
  define if we use a session. Currently, we can use the session to store a state, used to prevent CSRF, during OAuth2 login (default is `false`)



  All the environment variables are usable in the configuration file using stuff like `s`.

  To enable most of the features of c2cwsgiutils, you need to add this line to your WSGI main:

  ```python
  import c2cwsgiutils.pyramid
  config.include(c2cwsgiutils.pyramid.includeme)
  ```

  Error catching views will be put in place to return errors as JSON.

  A custom loader is provided to run pyramid scripts against configuration files containing environment variables:

  ```shell
  proutes c2c://production.ini      # relative path
  proutes c2c:///app/production.ini # absolute path
  ```

  A filter is automatically installed to handle the HTTP headers set by common proxies and have correct values
  in the request object (`request.client_addr`, for example). This filter is equivalent to what the
  `PasteDeploy#prefix` (minus the prefix part) does, but supports newer headers as well (`Forwarded`).
  If you need to prefix your routes, you can use the `route_prefix` parameter of the `Configurator` constructor.



  Two new logging backends are provided:

  - `c2cwsgiutils.pyramid_logging.PyramidCeeSysLogHandler`: to send @cee formatted logs to syslog through UDP.
  - `c2cwsgiutils.pyramid_logging.JsonLogHandler`: to output (on stdout or stderr) JSON formatted logs.

  Look at the logging configuration part of
  [acceptance_tests/app/production.ini](acceptance_tests/app/production.ini) for paste and commands line.

  The logging configuration is imported automatically by gunicorn, it is possible to visualize the dict config by setting the environment variable `DEBUG_LOGCONFIG=1`.

  You can enable a view to configure the logging level on a live system using the `C2C_LOG_VIEW_ENABLED` environment
  variable. Then, the current status of a logger can be queried with a GET on
  `{C2C_BASE_PATH}/logging/level?secret={C2C_SECRET}&name={logger_name}` and can be changed with
  `{C2C_BASE_PATH}/logging/level?secret={C2C_SECRET}&name={logger_name}&level={level}`. Overrides are stored in
  Redis, if `C2C_REDIS_URL` (`c2c.redis_url`) or `C2C_REDIS_SENTINELS` is configured.



  You can enable a view to force usage of the slave engine using the `C2C_DB_MAINTENANCE_VIEW_ENABLED` environment
  variable. Then, the database can be made "readonly" with
  `{C2C_BASE_PATH}/db/maintenance?secret={C2C_SECRET}&readonly=true`.
  The current state is stored in Redis, if `C2C_REDIS_URL` (`c2c.redis_url`) or `C2C_REDIS_SENTINELS` is configured.



  In order to follow the logs generated by a request across all the services (think separate processes),
  c2cwsgiutils tries to flag averything with a request ID. This field can come from the input as request headers
  (`X-Request-ID`, `X-Correlation-ID`, `Request-ID` or `X-Varnish`) or will default to a UUID. You can add an
  additional request header as source for that by defining the `C2C_REQUEST_ID_HEADER` environment variable
  (`c2c.request_id_header`).

  In JSON logging formats, a `request_id` field is automatically added.

  You can enable (disabled by default since it can have a cost) the flagging of the SQL requests as well by
  setting the C2C_SQL_REQUEST_ID environment variable (or c2c.sql_request_id in the .ini file). This will use
  the application name to pass along the request id. If you do that, you must include the application name in
  the PostgreSQL logs by setting `log_line_prefix` to something like `"%a "` (don't forget the space).

  Then, in your application, it is recommended to transmit the request ID to the external REST APIs. Use
  the `X-Request-ID` HTTP header, for example. The value of the request ID is accessible through an added
  `c2c_request_id` attribute on the Pyramid Request objects. The `requests` module is patched to automatically
  add this header.

  The requests module is also patched to monitor requests done without timeout. In that case, you can
  configure a default timeout with the `C2C_REQUESTS_DEFAULT_TIMEOUT` environment variable
  (`c2c.requests_default_timeout`). If no timeout and no default is specified, a warning is issued.



  The SQL profiler must be configured with the `C2C_SQL_PROFILER_ENABLED` environment variable. That enables a view
  to query the status of the profiler (`{C2C_BASE_PATH}/sql_profiler?secret={C2C_SECRET}`) or to
  enable/disable it (`{C2C_BASE_PATH}/sql_profiler?secret={C2C_SECRET}&enable={1|0}`).

  If enabled, for each `SELECT` query sent by SQLAlchemy, another query it done with `EXPLAIN ANALYZE`
  prepended to it. The results are sent to the `c2cwsgiutils.sql_profiler` logger.

  Don't enable that on a busy production system. It will kill your performances.



  C2cwsgiutils provide an easy way to profile an application:

  With a decorator:

  ```python
  from c2cwsgiutils.profile import Profiler

  @Profile('/my_file.prof')
  my_function():
      ...
  ```

  Or with the `with` statement:

  ```python
  from c2cwsgiutils.profile import Profiler

  with Profile('/my_file.prof'):
      ...
  ```

  Then open your file with SnakeViz:

  ```bash
  docker cp container_name:/my_file.prof .
  pip install --user snakeviz
  snakeviz my_file.prof
  ```



  The `c2cwsgiutils.db.init` allows you to setup a DB session that has two engines for accessing a
  master/slave PostgresQL setup. The slave engine (read only) will be used automatically for `GET` and `OPTIONS`
  requests and the master engine (read write) will be used for the other queries.

  To use that, your `production.ini` must look like that:

  ```ini
  sqlalchemy.url = s
  sqlalchemy.pool_recycle = s
  sqlalchemy.pool_size = s
  sqlalchemy.max_overflow = s

  sqlalchemy_slave.url = s
  sqlalchemy_slave.pool_recycle = s
  sqlalchemy_slave.pool_size = s
  sqlalchemy_slave.max_overflow = s
  ```

  And your code that initializes the DB connection must look like that:

  ```python
  import c2cwsgiutils.db

  def main(config):
      c2cwsgiutils.db.init(config, 'sqlalchemy', 'sqlalchemy_slave', force_slave=[
          "POST /api/hello"
      ])[0]
  ```

  You can use the `force_slave` and `force_master` parameters to override the defaults and force a route to use
  the master or the slave engine.



  To enable health checks, you must add some setup in your WSGI main (usually after the DB connections are
  setup). For example:

  ```python
  from c2cwsgiutils.health_check import HealthCheck

  def custom_check(request):
      global not_happy
      if not_happy:
          raise Exception("I'm not happy")
      return "happy"

  health_check = HealthCheck(config)
  health_check.add_db_session_check(models.DBSession, at_least_one_model=models.Hello)
  health_check.add_url_check('http://localhost:8080/api/hello')
  health_check.add_custom_check('custom', custom_check, 2)
  health_check.add_alembic_check(models.DBSession, '/app/alembic.ini', 3)
  ```

  Then, the URL `{C2C_BASE_PATH}/health_check?max_level=3` can be used to run the health checks and get a report
  looking like that (in case of error):

  ```json
  {
    "status": 500,
    "successes": {
      "db_engine_sqlalchemy": { "timing": 0.002 },
      "db_engine_sqlalchemy_slave": { "timing": 0.003 },
      "http://localhost/api/hello": { "timing": 0.01 },
      "alembic_app_alembic.ini_alembic": { "timing": 0.005, "result": "4a8c1bb4e775" }
    },
    "failures": {
      "custom": {
        "message": "I'm not happy",
        "timing": 0.001
      }
    }
  }
  ```

  The levels are:

  - 0: Don't add checks at this level. This max_level is used for doing a simple ping.
  - 1: Checks for anything vital for the usefulness of the service (DB, redis, ...). This is the max_level set
    by default and used by load balancers to determine if the service is alive.
  - \>=2: Use those at your convenience. Pingdom and CO are usually setup at max_level=100. So stay below.

  The URL `{C2C_BASE_PATH}/health_check?checks=<check_name>` can be used to run the health checks on some
  checks, coma separated list.

  When you instantiate the `HealthCheck` class, two checks may be automatically enabled:

  - If redis is configured, check that redis is reachable.
  - If redis is configured and the version information is available, check that the version matches
    across all instances.

  Look at the documentation of the `c2cwsgiutils.health_check.HealthCheck` class for more information.



  A command is provided that can generate Doxygen graphs of an SQLAlchemy ORM model.
  See [acceptance_tests/app/models_graph.py](acceptance_tests/app/models_graph.py) how it's used.



  If the `/app/versions.json` exists, a view is added (`{C2C_BASE_PATH}/versions.json`) to query the current
  version of a app. This file is generated by calling the `c2cwsgiutils-genversion [$GIT_TAG] $GIT_HASH`
  command line. Usually done in the [Dockerfile](acceptance_tests/app/Dockerfile) of the WSGI application.



  [Prometheus client](https://github.com/prometheus/client_python) is integrated in c2cwsgiutils.

  It will work in multi process mode with the limitation listed in the
  [`prometheus_client` documentation](https://github.com/prometheus/client_python#multiprocess-mode-eg-gunicorn).

  To enable it you should provide the `C2C_PROMETHEUS_PORT` environment variable.
  For security reason, this port should not be exposed.

  We can customize it with the following environment variables:

  - `C2C_PROMETHEUS_PREFIX`: to customize the prefix, default is `c2cwsggiutils-`.
  - `C2C_PROMETHEUS_PACKAGES` the packages that will be present in the version information, default is `c2cwsgiutils,pyramid,gunicorn,sqlalchemy`.
  - `C2C_PROMETHEUS_APPLICATION_PACKAGE` the packages that will be present in the version information as application.

  And you should add in your `gunicorn.conf.py`:

  ```python
  from prometheus_client import multiprocess


  def on_starting(server):
      from c2cwsgiutils import prometheus

      del server

      prometheus.start()


  def post_fork(server, worker):
      from c2cwsgiutils import prometheus

      del server, worker

      prometheus.cleanup()


  def child_exit(server, worker):
      del server

      multiprocess.mark_process_dead(worker.pid)
  ```

  In your `Dockerfile` you should add:

  ```dockerfile
  RUN mkdir -p /prometheus-metrics \
      && chmod a+rwx /prometheus-metrics
  ENV PROMETHEUS_MULTIPROC_DIR=/prometheus-metrics
  ```



  See [official documentation](https://github.com/prometheus/client_python#custom-collectors).

  Related to the Unix process.

  ```python
  from c2cwsgiutils import broadcast, prometheus

  prometheus.MULTI_PROCESS_COLLECTOR_BROADCAST_CHANNELS.append("prometheus_collector_custom")
  broadcast.subscribe("c2cwsgiutils_prometheus_collect_gc", _broadcast_collector_custom)
  my_custom_collector_instance = MyCustomCollector()


  def _broadcast_collector_custom() -> List[prometheus.SerializedGauge]:
      """Get the collected GC gauges."""

      return prometheus.serialize_collected_data(my_custom_collector_instance)
  ```

  Related to the host, use that in the `gunicorn.conf.py`:

  ```python
  def on_starting(server):
      from c2cwsgiutils import prometheus

      del server

      registry = CollectorRegistry()
      registry.register(MyCollector())
      prometheus.start(registry)
  ```



  Look at the `c2cwsgiutils-stats-db` utility if you want to generate statistics (gauges) about the
  row counts.



  With c2cwsgiutils each instance (Pod) has its own metrics, so we need to aggregate them to have the metrics for the service you probably need to use `sum by (<fields>) (<metric>)` to get the metric (especially for counters).



  To have the application initialized in a script you should use the
  `c2cwsgiutils.setup_process.bootstrap_application_from_options` function.

  Example of `main` function:

  ```python
  def main() -> None:
      parser = argparse.ArgumentParser(description="My scrypt.")
      
      c2cwsgiutils.setup_process.fill_arguments(parser)
      args = parser.parse_args()
      env = c2cwsgiutils.setup_process.bootstrap_application_from_options(args)
      settings = env["registry"].settings

      
  ```

  If you need an access to the database you should add:

  ```python
      engine = c2cwsgiutils.db.get_engine(settings)
      session_factory = c2cwsgiutils.db.get_session_factory(engine)
      with transaction.manager:
          
  ```

  If you need the database connection without the application context, you can replace:

  ```python
      env = c2cwsgiutils.setup_process.bootstrap_application_from_options(args)
      settings = env["registry"].settings
  ```

  by:

  ```python
      loader = pyramid.scripts.common.get_config_loader(args.config_uri)
      loader.setup_logging(parse_vars(args.config_vars) if args.config_vars else None)
      settings = loader.get_settings()
  ```



  To enable the debugging interface, you must set the `C2C_DEBUG_VIEW_ENABLED` environment variable. Then you can
  have dumps of a few things:

  - every threads' stacktrace: `{C2C_BASE_PATH}/debug/stacks?secret={C2C_SECRET}`
  - memory usage: `{C2C_BASE_PATH}/debug/memory?secret={C2C_SECRET}&limit=30&analyze_type=builtins.dict&python_internals_map=false`
  - object ref: `{C2C_BASE_PATH}/debug/show_refs.dot?secret={C2C_SECRET}&analyze_type=gunicorn.app.wsgiapp.WSGIApplication&analyze_id=12345&max_depth=3&too_many=10&filter=1024&no_extra_info&backrefs`
    `analyze_type` and `analyze_id` should not ve used toogether, you can use it like:
    ```bash
    curl "<URL>" > /tmp/show_refs.dot
    dot -Lg -Tpng /tmp/show_refs.dot > /tmp/show_refs.png
    ```
  - memory increase when calling another API: `{C2C_BASE_PATH}/debug/memory_diff?path={path_info}&secret={C2C_SECRET}&limit=30&no_warmup`
  - sleep the given number of seconds (to test load balancer timeouts): `{C2C_BASE_PATH}/debug/sleep?secret={C2C_SECRET}&time=60.2`
  - see the HTTP headers received by WSGI: `{C2C_BASE_PATH}/debug/headers?secret={C2C_SECRET}&status=500`
  - return an HTTP error: `{C2C_BASE_PATH}/debug/error?secret={C2C_SECRET}&status=500`

  To ease local development, the views are automatically reloaded when files change. In addition, the filesystem is mounted by the `docker-compose.override.yaml` file. Make sure not to use such file / mechanism in production.



  Some c2cwsgiutils APIs effect or query the state of the WSGI server. Since only one process out of the 5
  (by default) time the number of servers gets a query, only this one will be affected. To avoid that, you
  can configure c2cwsgiutils to use Redis pub/sub to broadcast those requests and collect the answers.

  The impacted APIs are:

  - `{C2C_BASE_PATH}/debug/stacks`
  - `{C2C_BASE_PATH}/debug/memory`
  - `{C2C_BASE_PATH}/logging/level`
  - `{C2C_BASE_PATH}/sql_profiler`

  The configuration parameters are:

  - `C2C_REDIS_URL` (`c2c.redis_url`): The URL to the Redis single instance to use
  - `C2C_REDIS_OPTIONS`: The Redis options, comma separated list of <key>=<value>, the value is parsed as YAML
  - `C2C_REDIS_SENTINELS`: The coma separated list of Redis host:port sentinel instances to use
  - `C2C_REDIS_SERVICENAME`: The redis service name in case of using sentinels
  - `C2C_REDIS_DB`: The redis database number in case of using sentinels
  - `C2C_BROADCAST_PREFIX` (`c2c.broadcast_prefix`): The prefix to add to the channels being used (must be
    different for 2 different services)

  If not configured, only the process receiving the request is impacted.



  To have CORS compliant views, define your views like that:

  ```python
  from c2cwsgiutils import services
  hello_service = services.create("hello", "/hello", cors_credentials=True)

  @hello_service.get()
  def hello_get(request):
      return {'hello': True}
  ```



  c2cwsgiutils can install exception handling views that will catch any exception raised by the
  application views and will transform it into a JSON response with a HTTP status corresponding to the error.

  You can enable this by setting `C2C_ENABLE_EXCEPTION_HANDLING` (`c2c.enable_exception_handling`) to "1".

  In development mode (`DEVELOPMENT=1`), all the details (SQL statement, stacktrace, ...) are sent to the
  client. In production mode, you can still get them by sending the secret defined in `C2C_SECRET` in the query.

  If you want to use pyramid_debugtoolbar, you need to disable exception handling and configure it like that:

  ```ini
  pyramid.includes =
      pyramid_debugtoolbar
  debugtoolbar.enabled = true
  debugtoolbar.hosts = 0.0.0.0/0
  debugtoolbar.intercept_exc = debug
  debugtoolbar.show_on_exc_only = true
  c2c.enable_exception_handling = 0
  ```



  Some JSON renderers are available:

  - `json`: the normal JSON renderer (default).
  - `fast_json`: a faster JSON renderer using ujson.
  - `cornice_json`: the normal JSON renderer wrapped around cornice CorniceRenderer.
  - `cornice_fast_json`: a faster JSON renderer wrapped around cornice CorniceRenderer.

  Both pretty prints the rendered JSON. While this adds significant amount of whitespace, the difference in
  bytes transmitted on the network is negligible thanks to gzip compression.

  The `fast_json` renderer is using ujson which is faster, but doesn't offer the ability to change the rendering
  of some types (the `default` parameter of json.dumps). This will interact badly with `papyrus` and such.

  The cornice versions should be used to avoid the "'JSON' object has no attribute 'render_errors'" error.



  The stacktraces can be sent to a sentry.io service for collection. To enable it, you must set the `SENTRY_URL`
  (`c2c.sentry_url`) to point the the project's public DSN.

  A few other environment variables can be used to tune the info sent with each report:

  - `SENTRY_EXCLUDES` (`c2c.sentry.excludes`): list of loggers (colon separated, without spaces) to exclude for sentry
  - `GIT_HASH` (`c2c.git_hash`): will be used for the release
  - `SENTRY_CLIENT_RELEASE`: If not equal to "latest", will be taken for the release instead of the GIT_HASH
  - `SENTRY_CLIENT_ENVIRONMENT`: the environment (dev, int, prod, ...)
  - `SENTRY_CLIENT_IGNORE_EXCEPTIONS`: list (coma separated) of exceptions to ignore (defaults to SystemExit)
  - `SENTRY_TAG_...`: to add other custom tags
  - `SENTRY_LEVEL`: starting from what logging level to send events to Sentry (defaults to ERROR)
  - `SENTRY_TRACES_SAMPLE_RATE`: The percentage of events to send to sentry in order to compute the performance. Value between 0 and 1 (default is 0)
  - `SENTRY_INTEGRATION_LOGGING`: If set to 0, the Sentry integration will not log anything (default is 1)
  - `SENTRY_INTEGRATION_PYRAMID`: If set to 0, the Sentry integration with Pyramid will not be enabled (default is 1)
  - `SENTRY_INTEGRATION_SQLALCHEMY`: If set to 0, the Sentry integration with SQLAlchemy will not be enabled (default is 1)
  - `SENTRY_INTEGRATION_REDIS`: If set to 0, the Sentry integration with Redis will not be enabled (default is 1)
  - `SENTRY_INTEGRATION_ASYNCIO`: If set to 0, the Sentry integration with asyncio will not be enabled (default is 1)



  You will need `docker` (>=1.12.0), `docker compose` and
  `make` installed on the machine to play with this project.
  Check available versions of `docker-engine` with
  `apt-get policy docker-engine` and eventually force install the
  up-to-date version using a command similar to
  `apt-get install docker-engine=1.12.3-0~xenial`.

  To lint and test everything, run the following command:

  ```shell
  make
  ```

  Make sure you are strict with the version numbers:

  - bug fix version change: Nothing added, removed or changed in the API and only bug fix
    version number changes in the dependencies
  - minor version change: The API must remain backward compatible and only minor version
    number changes in the dependencies
  - major version change: The API and the dependencies are not backward compatible

  To make a release:

  - Change the the version in [setup.py](setup.py).
  - Commit and push to master.
  - Tag the GIT commit.
  - Add the new branch name in the `.github/workflows/rebuild.yaml` and
    `.github/workflows/audit.yaml` files.



  Pserve will not set the headers in the environment then if you are behind a reverse proxy, you will have
  wrong values in client information, you can force them by using the environment variables:
  `C2CWSGIUTILS_FORCE_PROTO`, `C2CWSGIUTILS_FORCE_HOST` `C2CWSGIUTILS_FORCE_SERVER_NAME` and
  `C2CWSGIUTILS_FORCE_REMOTE_ADDR`.





  To test the screenshots, you need to install `node` with `npm`, to do that add the following lines in your `Dockerfile`:

  ```dockerfile
  RUN --mount=type=cache,target=/var/lib/apt/lists \
      --mount=type=cache,target=/var/cache,sharing=locked \
      apt-get install --yes --no-install-recommends gnupg \
      && . /etc/os-release \
      && echo "deb https://deb.nodesource.com/node_18.x ${VERSION_CODENAME} main" > /etc/apt/sources.list.d/nodesource.list \
      && curl --silent https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add - \
      && apt-get update \
      && apt-get install --assume-yes --no-install-recommends 'nodejs=18.*' \
          libx11-6 libx11-xcb1 libxcomposite1 libxcursor1 \
          libxdamage1 libxext6 libxi6 libxtst6 libnss3 libcups2 libxss1 libxrandr2 libasound2 libatk1.0-0 \
          libatk-bridge2.0-0 libpangocairo-1.0-0 libgtk-3.0 libxcb-dri3-0 libgbm1 libxshmfence1
  ```

  To do the image test call `check_screenshot` e.g.:

  ```python
  from c2cwsgiutils.acceptance import image

  def test_screenshot(app_connection):
      image.check_screenshot(
          app_connection.base_url + "my-path",
          width=800,
          height=600,
          result_folder="results",
          expected_filename=os.path.join(os.path.dirname(__file__), "my-check.expected.png"),
      )
  ```



  Install the pre-commit hooks:

  ```bash
  pip install pre-commit
  pre-commit install --allow-missing-config
  ```


pkgId: beaf7066c1232375e4b8c00f77899195e498b491d3707a770e975782cc1543ba
name: python-cached-path-help
arch: noarch
version: 1.6.6
epoch: 0
release: 1
summary: Development documents and examples for cached-path
url: https://github.com/allenai/cached_path
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cached-path-1.6.6-1.src.rpm
location_href: Packages/python-cached-path-help-1.6.6-1.noarch.rpm
checksum_type: sha256
description:
  <!-- start tagline -->

  A file utility library that provides a unified, simple interface for accessing both local and remote files.
  This can be used behind other APIs that need to access files agnostic to where they are located.

  <!-- end tagline -->

  <p align="center">
      <a href="https://github.com/allenai/cached_path/actions">
          <img alt="CI" src="https://github.com/allenai/cached_path/workflows/CI/badge.svg?event=push&branch=main">
      </a>
      <a href="https://pypi.org/project/cached_path/">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/cached_path">
      </a>
      <a href="https://cached-path.readthedocs.io/en/latest/?badge=latest">
          <img src="https://readthedocs.org/projects/cached-path/badge/?version=latest" alt="Documentation Status" />
      </a>
      <a href="https://github.com/allenai/cached_path/blob/main/LICENSE">
          <img alt="License" src="https://img.shields.io/github/license/allenai/cached_path.svg?color=blue&cachedrop">
      </a>
      <br/>
  </p>



  - [Documentation](https://cached-path.readthedocs.io/)
  - [PyPI Package](https://pypi.org/project/cached-path/)
  - [Contributing](https://github.com/allenai/cached_path/blob/main/CONTRIBUTING.md)
  - [License](https://github.com/allenai/cached_path/blob/main/LICENSE)



  <!-- start py version -->

  **cached-path** requires Python 3.7 or later.

  <!-- end py version -->



  <!-- start install pip -->

  **cached-path** is available [on PyPI](https://pypi.org/project/cached-path/). Just run

  ```bash
  pip install cached-path
  ```

  <!-- end install pip -->



  <!-- start install source -->

  To install **cached-path** from source, first clone [the repository](https://github.com/allenai/cached_path):

  ```bash
  git clone https://github.com/allenai/cached_path.git
  cd cached_path
  ```

  Then run

  ```bash
  pip install -e .
  ```

  <!-- end install source -->



  ```python
  from cached_path import cached_path
  ```

  Given something that might be a URL or local path, `cached_path()` determines which.
  If it's a remote resource, it downloads the file and caches it to the [cache directory](#cache-directory), and
  then returns the path to the cached file. If it's already a local path,
  it makes sure the file exists and returns the path.

  For URLs, `http://`, `https://`, `s3://` (AWS S3), `gs://` (Google Cloud Storage), and `hf://` (HuggingFace Hub) are all supported out-of-the-box.
  Optionally `beaker://` URLs in the form of `beaker://{user_name}/{dataset_name}/{file_path}` are supported, which requires [beaker-py](https://github.com/allenai/beaker-py) to be installed.

  For example, to download the PyTorch weights for the model `epwalsh/bert-xsmall-dummy`
  on HuggingFace, you could do:

  ```python
  cached_path("hf://epwalsh/bert-xsmall-dummy/pytorch_model.bin")
  ```

  For paths or URLs that point to a tarfile or zipfile, you can also add a path
  to a specific file to the `url_or_filename` preceeded by a "!", and the archive will
  be automatically extracted (provided you set `extract_archive` to `True`),
  returning the local path to the specific file. For example:

  ```python
  cached_path("model.tar.gz!weights.th", extract_archive=True)
  ```



  By default the cache directory is `~/.cache/cached_path/`, however there are several ways to override this setting:
  - set the environment variable `CACHED_PATH_CACHE_ROOT`,
  - call `set_cache_dir()`, or
  - set the `cache_dir` argument each time you call `cached_path()`.



  <!-- start team -->

  **cached-path** is developed and maintained by the AllenNLP team, backed by [the Allen Institute for Artificial Intelligence (AI2)](https://allenai.org/).
  AI2 is a non-profit institute with the mission to contribute to humanity through high-impact AI research and engineering.
  To learn more about who specifically contributed to this codebase, see [our contributors](https://github.com/allenai/cached_path/graphs/contributors) page.

  <!-- end team -->



  <!-- start license -->

  **cached-path** is licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0).
  A full copy of the license can be found [on GitHub](https://github.com/allenai/cached_path/blob/main/LICENSE).

  <!-- end license -->

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


pkgId: 910ead8a09dc5c04357f59b0685fc7e38e5f46044f617394ba250757142d3583
name: python-cadenzaanalytics-help
arch: noarch
version: 0.1.25
epoch: 0
release: 1
summary: Development documents and examples for cadenzaanalytics
url: https://pypi.org/project/cadenzaanalytics/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cadenzaanalytics-0.1.25-1.src.rpm
location_href: Packages/python-cadenzaanalytics-help-0.1.25-1.noarch.rpm
checksum_type: sha256
description:
  **cadenzaanalytics** is the official package for fast and easy creation of [disy Cadenza](https://www.disy.net/en/products/disy-cadenza/) analytics extensions with Python. It enables the extension of disy Cadenza for advanced analytics purposes with the usage of python code.

  Currently, this package is in **beta status**: it can be used for testing, but there
  may be breaking changes before a full release.

  Find the docs at https://disyinformationssysteme.github.io/cadenza-analytics-python

  [![CI](https://github.com/DisyInformationssysteme/cadenza-analytics-python/actions/workflows/ci.yml/badge.svg)](https://github.com/DisyInformationssysteme/cadenza-analytics-python/actions/workflows/ci.yml)
  [![Pylint](https://github.com/DisyInformationssysteme/cadenza-analytics-python/actions/workflows/pylint.yml/badge.svg)](https://github.com/DisyInformationssysteme/cadenza-analytics-python/actions/workflows/pylint.yml)


  * Python 3
  * Flask
  * Pandas
  * requests-toolbelt



  Example extension can be found in [examples](examples).

  To test a example extension, clone this repository, install the dependencies, navigate to the folder, e.g. `examples/calculation/extension`. Run the example file in your python environment e.g.:
  ```
  python example_extensions.py
  ```
  A development server will be started on localhost `http://127.0.0.1:5005`. The analytics extension can now be registered and used in disy Cadenza.

  It is not recommended to use the development server in a production environment.




  Development is possible via most common IDEs such as Visual Studio Code or PyCharm. Make sure to mark the `src` directory as "Sources Root" to make sure cross imports from the `examples` directory work as expected and that imports within `cadenzaanalytics` can get resolved by the IDE.


  We aim to support older python versions and dependencies, but best experience and most features will be available for newer versions, currently this is Python `9.12`.

  Versioning of `cadenzaanalytics` will happen via [poetry-bumpversion](https://github.com/monim67/poetry-bumpversion). On release, this will bump the version depending on the chosen release type.
  The project uses semantic versioning with a major, minor and patch version.


  On release, all "Unreleased" changes in the [Changelog](CHANGELOG.md) will be automatically tagged with the released version.
  So make sure to add relevant changelog notes for every change you make and follow the style described in the changelog file.


  [Pylint](https://github.com/pylint-dev/pylint) is used for making sure that `cadenzaanalytics` follows some common styles. If necessary some rules can be disabled globally in the [.pylintrc](.pylintrc) file or in the corresponding python file. There is a GitHub workflow to validate this. For some IDEs like PyCharm there are also plugins for Pylint so that linting can happen within the IDE and errors in the pipeline can be avoided.

  Make sure to check the following
  - Does the [Changelog](CHANGELOG.md) contain all relevant information?
  - Are all relevant workflows green?
  - Do you want to make a test release to https://test.pypi.org? This is helpful to test `cadenzaanalytics` with existing extensions. To get the latest version immediately it might be good to disable caches, e.g. via `pip install --upgrade cadenzaanalytics --extra-index-url https://test.pypi.org/simple --no-cache-dir`. For a first installation in a new (virtual) environment, you can use `pip install cadenzaanalytics --extra-index-url https://test.pypi.org/simple`
  - To make a non-test release, choose the pypi.org deployment environment in the release dialog.


  To run the example (and your production application) in a docker container you will need to define the wsgi server that will run the flask app.
  The provided Dockerfile in the examples uses gunicorn with some example options, for more details consult the [documentation](https://docs.gunicorn.org/en/latest/settings.html). Important is that gunicorn has access to a function creating or providing the flask app object, which for `cadenzanalytics` is the `CadenzaAnalyticsExtensionService`.
  The requirements file can use test releases when adding `--extra-index-url https://test.pypi.org/simple` in the first line. It can (re)define versions of its own or transient dependencies, but most importantly needs the `cadenzaanalytics` dependency.
  ```commandline
  cd /examples/calculation
  docker build . -t cadenza-analytics-example
  docker image list
  docker run -p 8080:8080 YOUR_CREATED_IMAGE_ID
  ```

  The release process uses PyPi's [trusted publishing](https://docs.pypi.org/trusted-publishers/), so is based on
  OIDC id token and uses no API token from PyPi. The relevant permission `id-token: write` must be given to the release-job.

  The test environment test.pypi.org makes no guarantee on availability of the package or even on the account. So it might be necessary to recreate an account at some point in time.

  To test and play around with poetry-bumpversion locally, you can use it as follows, see documentation of [poetry](https://python-poetry.org/docs/#installing-with-pipx) and [poetry-bumpversion](https://pypi.org/project/poetry-bumpversion/)
  ```commandline
  pipx install poetry
  pipx run poetry self add poetry-bumpversion
  pipx run poetry version minor -s
  ```


  [License](LICENSE.md)


pkgId: 275f2386a4df4e11b856bfccb7407e12ff7d6f783a0137f3d34ece27fafbacc7
name: python-cadica-data-set-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for cadica-data-set
url: https://pypi.org/project/cadica-data-set/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cadica-data-set-1.0.3-1.src.rpm
location_href: Packages/python-cadica-data-set-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  This is the cadica-data-set repository!
  More details soon to come on how to install thy package via pip install,
  and use the code/libraries in the package.


pkgId: 486365e1236574bf9d414ae0c58b5f2fc32100330f989219494c7280be4a206d
name: python-cadmium-django-sdk-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for cadmium-django-sdk
url: https://github.com/bannawandoor27/cadmium-django-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cadmium-django-sdk-1.2.0-1.src.rpm
location_href: Packages/python-cadmium-django-sdk-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This SDK captures and sends errors from your Django application to the Cadmium server.



  ```bash
  pip install cadmium-django-sdk
  ```



  Add the following to your `settings.py`:

  ```python
  INSTALLED_APPS += ['cadmium_django']

  APPLICATION_ID = "your-application-id"
  CD_SECRET = "your-secret"
  CD_ID = "your-cd-id"

  import cadmium_django
  cadmium_django.initialize()
  ```



  Once configured, any unhandled exception will automatically be sent to the Cadmium server.


pkgId: 0244ee5678f72ad2a36712cadfca677743611a71b6dde718a557d1e1814d2531
name: python-cadquery-cli-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for cadquery-cli
url: https://github.com/CadQuery/cq-cli
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cadquery-cli-2.3.0-1.src.rpm
location_href: Packages/python-cadquery-cli-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/CadQuery/cq-cli/actions/workflows/tests.yml/badge.svg)](https://github.com/CadQuery/cq-cli/actions)



  * [Introduction](https://github.com/CadQuery/cq-cli#introduction)
  * [Getting Help](https://github.com/CadQuery/cq-cli#getting_help)
  * [Installation](https://github.com/CadQuery/cq-cli#installation)
  * [Usage](https://github.com/CadQuery/cq-cli#usage)
  * [Examples](https://github.com/CadQuery/cq-cli#examples)
  * [Drawbacks](https://github.com/CadQuery/cq-cli#drawbacks)
  * [Contributing](https://github.com/CadQuery/cq-cli#contributing)



  ***Please Note*** cq-cli is in beta.

  cq-cli is a Command Line Interface for executing CadQuery scripts and converting their output to another format. It uses a plugin system where "codecs" can be placed in the cqcodecs directory and will be automatically loaded and used if a user selects that codec from the command line.

  It is possible to specify input and output files using arguments, but cq-cli also allows the use to the stdin, stdout and stderr streams so that it can be used in a pipeline.

  Linux, MacOS and Windows are supported, but some features may be used differently or may not work the same in Windows.



  In addition to opening an issue on this repo, there is a [CadQuery Discord channel](https://discord.gg/qz3uAdF) and a [Google Group](https://groups.google.com/g/cadquery) that you can join to ask for help getting started with cq-cli.



  ***Note:*** It probably goes without saying, but it is best to use a Python virtual environment when installing a Python package like cq-cli.

  These instructions cover installing cq-cli using pip. If you want a stand-alone installation that does not require any of the Python infrastructure, read the Stand-Alone section below.

  cq-cli is not available on PyPI, so it must be installed using pip and git. git must be installed for this process to work.

  ```
  pip install git+https://github.com/CadQuery/cq-cli.git
  ```
  Once the installation is complete, there will be two different ways to run the cq-cli command line interface.

  ```
  cq-cli --help
  ```
  or
  ```
  python -m cq_cli.main --help
  ```



  **Please note:** This method is not recommended now that cq-cli can be installed via pip, but it is still an option if it is not possible to use a Python virtual environment.

  Download a binary distribution that is appropriate for your operating system from the [latest PyInstaller workflow run with a green checkmark](https://github.com/CadQuery/cq-cli/actions/workflows/pyinstaller.yml), extract the zip file, and make sure to put the cq-cli binary in the PATH. Then the CLI can be invoked as `cq-cli` (`cq-cli.exe` on Windows).

  If installing on Windows, the [latest redistributable for Visual Studio](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads) will need to be installed.




  * The file (and directory) size for cq-cli is very large. cq-cli uses pyinstaller to package the binaries for each platform, and must embed all needed dependencies. The OCP and OCCT library dependencies add a minimum of ~270 MB of data on top of the included Python distribution. It is possible that the pyinstaller spec file could be optimized. If you are interested in helping with this, please let us know by opening an issue.
  * Startup times for the single binary are relatively slow. If startup and execution time is important to you, consider using the pyinstaller_dir.spec spec file with pyinstaller: `pyinstaller pyinstaller_dir.spec`.



  usage: cq-cli.py [-h] [--codec CODEC] [--infile INFILE] [--outfile OUTFILE] [--errfile ERRFILE] [--params PARAMS] [--outputopts OPTS] [--validate VALIDATE]

  Command line utility for converting CadQuery script output to various other output formats.

  optional arguments:
  * `-h`, `--help` Show this help message and exit
  * `--codec` CODEC The codec to use when converting the CadQuery output. Must match the name of a codec file in the cqcodecs directory.
  * `--getparams` GETPARAMS
  * `--infile` INFILE The input CadQuery script to convert.
  * `--outfile` OUTFILE File to write the converted CadQuery output to. Prints to stdout if not specified.
  * `--errfile` ERRFILE File to write any errors to. Prints to stderr if not specified.
  * `--params` PARAMS A colon and semicolon delimited string (no spaces) of key/value pairs representing variables and their values in the CadQuery script. i.e. var1:10.0;var2:4.0;
  * `--outputopts` OPTS A colon and semicolon delimited string (no spaces) of key/value pairs representing options to pass to the selected codec.  i.e. width:100;height:200;
  * `--validate` VALIDATE Setting to true forces the CLI to only parse and validate the script and not produce converted output.



  1. Find out what codecs are available.
  ```
  cq-cli --codec help
  ```
  2. Validate a CadQuery script.
  ```
  cq-cli --validate true --infile /input/path/script.py
  ```
  3. Convert a CadQuery script to STEP format and output to stdout.
  ```
  cq-cli --codec step --infile /input/path/script.py
  ```
  4. Convert a CadQuery script to STEP format and write to a file.
  ```
  cq-cli --codec step --infile /input/path/script.py --outfile /output/path/newfile.step
  ```
  5. Convert a CadQuery script and write any errors to a separate file.
  ```
  cq-cli --codec step --infile /input/path/script.py -errfile /error/path/error.txt
  ```
  6. Convert a CadQuery script using the stdin and stdout streams. This example counts the lines in the resulting STEP output as a trivial example.
  ```
  cat /input/path/script.py | cq-cli.py --codec step | wc -l
  ```
  7. Convert a CadQuery script to SVG, passing in output options to influence the resulting image.
  ```
  cq-cli --codec svg --infile /input/path/script.py --outfile /output/path/newfile.svg --outputopts "width:100;height:100;marginLeft:12;marginTop:12;showAxes:False;projectionDir:(0.5,0.5,0.5);strokeWidth:0.25;strokeColor:(255,0,0);hiddenColor:(0,0,255);showHidden:True;"
  ```
  8. Convert a CadQuery script to STL, passing in output options to change the quality of the resulting STL. Explanation of linear vs angular deflection can be found [here](https://dev.opencascade.org/doc/occt-7.1.0/overview/html/occt_user_guides__modeling_algos.html#occt_modalg_11_2).
  ```
  cq-cli --codec stl --infile /input/path/script.py --outfile /output/path/script.stl --outputopts "linearDeflection:0.3;angularDeflection:0.3"
  ```
  9. Extract parameter information from the input script. The outfile argument can also be left off to output the parameter JSON to stdout.
  ```
  cq-cli --getparams /output/path/params.json --infile /input/path/script.py
  ```
  10. Pass JSON parameter information from a file to be used in the script.
  ```
  cq-cli --codec stl --infile /input/path/script.py --outfile /output/path/output.stl --params /parameter/path/parameters.json
  ```
  11. Pass JSON parameter data as a string on the command line.
  ```
  cq-cli --codec stl --infile /input/path/script.py --params "{\"width\":10}"
  ```
  12. String parameters can be defined using single quotes (`'`) or escaped double quotes (`\"`).
  ```
  cq-cli --codec stl --outfile test.stl --infile /input/path/script.py --outputopts "width:2;tag_name:'test';centered:True"
  ```
  ```
  cq-cli --codec stl --outfile test.stl --infile /input/path/script.py --outputopts "width:2;tag_name:\"test\";centered:True"
  ```



  If you want to help improve and expand cq-cli, the following steps should get you up and running with a development setup. There is a  [CadQuery Discord channel](https://discord.gg/qz3uAdF) and a [Google Group](https://groups.google.com/g/cadquery) that you can join to ask for help getting started.

  1. Create a Python virtual environment and activate it. Attept to avoid the bleeding-edge version of Python as there may be problems.
  2. Clone this repository: `git clone https://github.com/CadQuery/cq-cli.git`
  3. cd into the repository directory: `cd cq-cli`
  4. Do a local editable installation via pip: `pip install -e .`



  The codec plugin system is based on naming conventions so that cq-cli knows what codec options to accept from the user. When adding a codec, make sure to place it in the `cqcodecs` directory and follow the naming convention `cq_codec_[your codec name].py`. The `your codec name` part of the filename will automatically be used as the codec name that the user specifies.

  A good example to start with when creating your own codec would be `cqcodecs/cq_codec_step.py` as it shows a simple implementation of the codec that relies on CadQuery to do all the heavy lifting. At the very least, your codec needs to have a `convert` function that takes in a [CQGI BuildResult object](https://cadquery.readthedocs.io/en/latest/cqgi.html#cadquery.cqgi.BuildResult) and returns a string representing the converted model(s). As an alternative, cq-cli will pass the output file name, which makes it possible to write the output to the outfile path directly from the codec. If `None` is returned from the `convert` function, cq-cli will assume that the output was written directly to the output file by the codec.

  For pyinstaller to know about the new dynamically loaded codec, it must be added to the `hiddenimports` array in both cq-cli_onfile_pyinstaller.spec and cq-cli_dir_pyinstaller.spec files. Leave the `.py` off of the name when adding to the array, for instance `codec.cq_codec_step` is the string used for the STEP codec. When only running a codec locally and not contributing it, this step is not required.



  A test is required when adding a codec to cq-cli, but is easy to add. Add a file named `test_[your codec name]_codec.py` in the tests directory, and add the test to it. `test_step_codec.py` would be a good template to base any new tests off of.



  Applications can return a non-zero exit code to let the user know what went wrong. Below is a listing of the exit codes for cq-cli and what they mean.

  * **0:** Operation was successful with no errors detected.
  * **1:** A CadQuery script could not be read from the given `infile`.
  * **2:** There was a usage error with the parameters that were passed to cq-cli (too few parameters, not the correct ones, etc).
  * **3:** A codec for converting the results of the CadQuery script was not provided.
  * **100:** There was an unknown error while running the CadQuery script and obtaining a result (build error, possibly from OCCT).
  * **200:** There was an unknown error while running a codec to convert the results of the CadQuery script.



  If building cq-cli to run as a stand-alone app is required, there are two modes to build it in: `onefile` and `dir` (directory). onefile mode creates a single file for the app, which is easy to distribute but takes longer to start up run on each execution. dir mode creates a directory with numerous dependency files in it, including the cq-cli binary file, and starts up faster than the single file. However, the directory distribution can take up more than twice the disk space and can be messier to distribute. A PyInstaller spec file has been provided for both modes, and selecting between them only requires the addition of a command line argument. The commands to build in each type of mode are outlined below.

  There are a few packages, including PyInstaller, must be installed via conda or pip before executing either of the `pyinstaller` commands below.
  ```
  pip install pyinstaller
  pip install path
  ```
  The output for both of the commands will be in the `dist` directory. If the mode argument is left off, `onefile` is assumed.


  ```
  pyinstaller cq-cli_pyinstaller.spec onefile
  ```


  ```
  pyinstaller cq-cli_pyinstaller.spec dir
  ```

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


pkgId: 2b6a4adba77f9ae9164d4c801fa207f8d4248b7b4ca69995d773c01d0002f9b3
name: python-cadquery-freecad-import-plugin-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for cadquery-freecad-import-plugin
url: https://pypi.org/project/cadquery-freecad-import-plugin/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cadquery-freecad-import-plugin-1.0.0-1.src.rpm
location_href: Packages/python-cadquery-freecad-import-plugin-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This plugin allows users to import FreeCAD models into CadQuery, and will apply parameters to the model if they are provided and the model is a parametric one (contains a FreeCAD spreadsheet document). At this time this plugin does not handle FreeCAD assemblies.



  Something like an Anaconda environment with FreeCAD installed as a conda package may be required on some Linux distros like Ubuntu because of the requirement to use the FreeCAD Snap to get the latest version of FreeCAD. The Snap does not seem to allow FreeCAD to be imported properly in Python. If you do use Anaconda, name the environment `freecad` to help this plugin find it. See the [documentation here](https://cadquery.readthedocs.io/en/latest/installation.html#install-the-conda-package-manager) for instructions on how to set up Anaconda without messing up your local Python installation. A example conda installation to get this plugin working is shown below.
  ```bash
  mamba create -n freecad python=3.10
  mamba install -c cadquery cadquery=master
  mamba install freecad:freecad
  ```

  Assuming that you have pip and git installed, the following line can be used to install this plugin.

  ```
  pip install -e "git+https://github.com/CadQuery/cadquery-plugins.git#egg=freecad_import&subdirectory=plugins/freecad_import"
  ```



  FreeCAD must be installed and importable via Python in order for this plugin to work. CadQuery is also required. To install CadQuery, follow the [instructions here](https://cadquery.readthedocs.io/en/latest/installation.html), or use the conda instructions above.



  To use this plugin after it has been installed, import it to automatically patch its functions into the `cadquery.importers` package.

  Here is an example of importing a parametric FreeCAD part.

  ```python
  import cadquery as cq

  from freecad_importer import import_freecad_part



  result = import_freecad_part(
          "path_to_freecad_part_file.FCStd", parameters={"mount_dia": {"value": 4.8, "units": "mm"}}
      )
  ```

  Here is an example of retrieving the parameters from a parametric FreeCAD part.

  ```python
  import cadquery as cq

  from freecad_importer import get_freecad_part_parameters


  params = get_freecad_part_parameters(
      "path_to_freecad_part_file.FCStd", name_column_letter="A", value_column_letter="B"
  )
  ```

  The tests associated with this plugin have additional code that also might be useful to review as examples.

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


pkgId: a2244a69975df54bcc638f20813f2918f56a2ad37259912b0f2060ff35e7a966
name: python-cadquery-png-plugin-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for cadquery-png-plugin
url: https://pypi.org/project/cadquery-png-plugin/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cadquery-png-plugin-1.0.0-1.src.rpm
location_href: Packages/python-cadquery-png-plugin-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  *cadquery-png-plugin* is a PNG export plugin for [CadQuery](https://cadquery.readthedocs.io/en/latest/), which is a Python API for creating CAD models and assemblies. The core CadQuery library can export SVG images, but not bitmap images, such as PNG.



  This plugin has not been released on PyPI, but it can be installed via `git` and `pip`.

  ```bash
  pip install git+https://github.com/jmwright/cadquery-png-plugin.git
  ```

  This installation will also install other required packages such as CadQuery if the environment does not already include them.



  Below is a minimal example of this plugin being used to export a CadQuery assembly.

  ```python
  import cadquery as cq
  import cadquery_png_plugin.plugin  # This registers the plugin with CadQuery


  render_options = {"width": 600,  # width of the output image
                    "height": 600,  # height of the output image
                    "color_theme": "default",  # can also be black_and_white
                    "view": "front-top-right",  # front, top, front-bottom-left, etc
                    "zoom": 1.0  # zooms in and out on the center of the model
                    }


  box = cq.Workplane().box(10, 10, 10)
  cyl = cq.Workplane().circle(2.5).extrude(5)
  assy = cq.Assembly(box, color=cq.Color(1.0, 0.0, 0.0))
  assy.add(cyl, loc=cq.Location(0, 0, 5.0), color=cq.Color(0.0, 0.0, 1.0))


  assy.exportPNG(options=render_options, file_path="ouptput_file.png")
  ```

  That code results in the following image.

  ![Sample PNG based on the script above](sample_image.png)



  An example of this plugin being used by a project in the wild can be found in the [Nimble repository](https://github.com/Wakoma/nimble/blob/c33497258f969392d91b2c30aa8d06ef7a2bd7ec/nimble_build_system/cad/renderer.py).



  1. Clone the repository.
  ```
  https://github.com/jmwright/cadquery-png-plugin.git && cd cadquery-png-plugin
  ```

  2. Install the plugin and its development dependencies.
  ```
  pip install -e .
  pip install -e .[dev]
  ```

  3. Run the tests
  ```
  pytest
  ```

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


pkgId: 9afd89859cac9bff5e756e0a2b9b17729e2c492eab6586f766dd81eabdfba80e
name: python-caerp-celery-help
arch: noarch
version: 2024.2.5
epoch: 0
release: 1
summary: Development documents and examples for caerp-celery
url: https://framagit.org/caerp/caerp_celery
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-caerp-celery-2024.2.5-1.src.rpm
location_href: Packages/python-caerp-celery-help-2024.2.5-1.noarch.rpm
checksum_type: sha256
description:
  Since version 6, caerp-celery only supports python 3.
  Asynchronous tasks are executed through celery.
  pyramid_celery is used to integrate celery with the Pyramid related stuff.
  pyramid_beaker is used to cache responses.
  tasks:
      Asynchronous tasks called from CAErp
  scheduler:
      Beat tasks, repeated along the time (like cron tasks)


pkgId: 6876aa68258a9426f199c5b9055fea5ce7f677dbd3e8f02913f80218402c37bb
name: python-caerp-oidc-client-help
arch: noarch
version: 2024.2.0
epoch: 0
release: 1
summary: Development documents and examples for caerp-oidc-client
url: https://framagit.org/caerp/caerp_oidc_client
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-caerp-oidc-client-2024.2.0-1.src.rpm
location_href: Packages/python-caerp-oidc-client-help-2024.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ```python
  python setup.py install
  ```




  To configure your open id connect client in a SSO server like Keycloak.

  Host : https://caerp.mycae.coop

  > **Important** Create a custom realm (don't use the master realm, you'll face serious security problems : all users would have admin rights on Keycloak)



  - ClientID : caerp_client_id
  - Name : Free choice
  - Root URL : https://caerp.mycae.coop
  - Home URL : https://caerp.mycae.coop
  - Valid Redirect URIs : https://caerp.mycae.coop/*
  - Valid post logout redirect URIs : https://caerp.mycae.coop/login
  - Web Origins : https://caerp.mycae.coop
  - Admin URL : Nothing
  - Client Authentication : True
  - Authentication Flow : Check the following
     - Standard Flow
     - Implicit flow
     - Direct access grants
  - Disable Consent required
  - Backchannel logout url : https://caerp.mycae.coop/oidc_backend_logout
  - Backchannel logout session required: True




  In the "Credentials" section of the keycloak client view, retrieve the client's secret (you need it to configure caerp)




  In your caerp application's ini file

  ```
  pyramid.includes = ...
                     caerp_oidc_client.models
  ```

  Later in the same ini file
  ```
  caerp.authentification_module=caerp_oidc_client

  oidc.client_secret=<Secret token from the OIDC server>
  oidc.client_id=caerp_client_id
  oidc.scope=openid roles
  oidc.auth_endpoint_url=<Keycloak auth endpoint url>
  oidc.token_endpoint_url=<Keycloak id token endpoint url>
  oidc.logout_endpoint_url=<Keycloak logout endpoint url>
  ```

  Keycloak's url are in the form

  https://keycloak/realms/**my custom realm name**/protocol/openid-connect/auth

  https://keycloak/realms/**my custom realm name**/protocol/openid-connect/token

  https://keycloak/realms/**my custom realm name**/protocol/openid-connect/logout


pkgId: 179866b2d69dd9cdd4d99dd89ea9d532fd3528bd9caee6004ffecf1f976c119b
name: python-caketool-help
arch: noarch
version: 1.5.0
epoch: 0
release: 1
summary: Development documents and examples for caketool
url: https://github.com/cake-digital-bank
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-caketool-1.5.0-1.src.rpm
location_href: Packages/python-caketool-help-1.5.0-1.noarch.rpm
checksum_type: sha256
description:
  - Enviroment

  ```bash
  conda create -n caketool
  conda activate caketool
  pip-compile pyproject.toml
  pip-sync
  pip install pip-tools bumpver build twine ipykernel
  ```

  - Publish libs

  ```bash
  bumpver update --major # Increment the MAJOR version when you make incompatible API changes.
  bumpver update --minor # Increment the MINOR version when you add functionality in a backwards compatible manner.
  bumpver update --patch # Increment the PATCH version when you make backwards compatible bug fixes.
  python -m pip install -e . # Install on local machine
  rm ./dist/*
  python -m build
  twine upload -r testpypi dist/*
  twine upload dist/*
  pip install caketool
  ```

rpm_license:
  MIT License  Copyright (c) 2018 Real Python  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 8a14b449b37e47df1bf12e6c44fb64032e7fc51f1e84296efdcd521d0b789c0d
name: python-calc-files-control-sum-help
arch: noarch
version: 1.1.4
epoch: 0
release: 1
summary: Development documents and examples for calc-files-control-sum
url: https://github.com/octaprog7/CalcFilesControlSum
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-calc-files-control-sum-1.1.4-1.src.rpm
location_href: Packages/python-calc-files-control-sum-help-1.1.4-1.noarch.rpm
checksum_type: sha256
description:
  File checksum information is written to stdout.
  To later check the files for changes, you need to save this information
  to a file by redirecting the output to a file (> filename.ext)


    - -h, --help            show this help message and exit
    - -c CHECK_FILE, --check_file CHECK_FILE
                          Name of the source file of checksums for checking
                          files. Type: cfcs [opt] > filename.ext to produce
                          check file filename.ext in current working dir!
    - -s SRC, --src SRC     Folder in which checksums of files are calculated.
    - -a ALG, --alg ALG     Algorithm for calculating the checksum. For example
                          MD5, SHA1, SHA224, SHA256, SHA384, SHA512. Default
                          value: md5
    - -e EXT, --ext EXT     Pattern string for filename matching check! Filters
                          out files subject to checksum calculation. For
                          example: "*.zip,*.rar,*.txt"


  - ```cfcs --src=/home/username --alg=sha1 --ext="*.rar,*.avi,*.bmp" (writing checksum information to stdout).```
  - ```cfcs --src=/home/username --alg=sha1 --ext="*.zip,*.7z,*.mp4" > control_sum_filename.ext (writing checksum information to file).```
  - ```cfcs --check_file==/home/previously_created_file.ext  (check files in folder).```


      cfcs --src="/home/roman/Изображения" --ext="*.png" > my_images.cs

      cfcs --check_file="my_images.cs"

  my_test.cs file content:
  ```
  {SETTINGS}
  check_file	None
  src	/mnt/anydata/tmp
  alg	md5
  ext	['*.img']
  start_time	2022-12-17 14:05:42.637208

  {FILES_AND_CONTROL_SUM}
  A981130CF2B7E09F4686DC273CF7187E	test1.img
  CD573CFAACE07E7949BC0C46028904FF	test5.img
  CD573CFAACE07E7949BC0C46028904FF	test3.img
  CD573CFAACE07E7949BC0C46028904FF	test0.img
  C698C87FB53058D493492B61F4C74189	test2.img
  CD573CFAACE07E7949BC0C46028904FF	test4.img
  {INFO AND STATISTICS}
  Ended: 2022-12-17 14:05:58.980157	Files: 6;	Bytes processed: 9663676416
  Processing speed [MiB/sec]: 563.913
  hash_val	DD44D3D71819D7EE6A5622544AE1905E
  ```


      cfcs --check_file="my_test.cs"


  ```
  Checking files by their checksums has begun!
  The file has been verified. No changes found.: /mnt/anydata/big_archive.tar.gz
  Total files checked: 1
  Number of modified files: 0
  Number of I/O errors: 0
  File scan speed [MiB/s]: 82.969
  ```

  https://pypi.org/project/calc-files-control-sum/


  Most of the program messages are translated into five languages: English, Russian, German, Spanish, French.
  See: https://github.com/octaprog7/PyInternalization.


pkgId: d417131123c024c2af4ec7c44b8551e88f1d15b0aad93cf202e263c60a992e71
name: python-calcpy-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for calcpy
url: http://github.com/zhiqingxiao/calcpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-calcpy-1.0.0-1.src.rpm
location_href: Packages/python-calcpy-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Implementations of basic calculations in Python.




  ```shell
  pip install --upgrade calcpy
  ```




  Set-alike APIs operate objects with original order reserved and optional customized comparison function.

  ```Python
  >>> from calcpy import unique
  >>> unique([4, 3, 7, 3, 4])
  [4, 3, 7]
  ```

  **List of APIs:**

  - `calcpy.unique(values, matcher=None)`  Remove duplicated entries.
  - `calcpy.concat(*args, matcher=None)`   Concatenate.
  - `calcpy.union(*args, matcher=None)`   Union.
  - `calcpy.intersect(*args, matcher=None)`   Intersection.
  - `calcpy.exclude(arg, *args, matcher=None)`   Remove follow-up arguments from the first.
  - `calcpy.xor(*args, matcher=None)`    Exclusive-or of follow-up parameters from the first parameter.
  - `calcpy.eq(*args, matcher=None)`    Check whether parameters are all equal.
  - `calcpy.ne(*args, matcher=None)`    Check whether parameters are all distinct.


  **Supported object types**

  - `list`
  - `tuple`
  - `set`
  - `np.ndarray`
  - `pd.Series`
  - `pd.DataFrame`
  - others

  **On keyword parameter `matcher`**:
  The keyword parameter `matcher` is for customized comparison function.
  By default, it is `None`, which uses the default way to compare two objects, i.e. compare them as a whole.
  We can write customized binary functions to compare two objects. For example, we can compare the equality of two `np.ndarray`s using `np.array_equal`, or use the following customized function `lower_matcher` to compare two `str`s according to their lowercases:

  ```python
  >>> def lower_matcher(loper, roper):
  ...     return loper.lower() == roper.lower()
  ...
  >>> from calcpy import eq
  >>> eq("Hello", "hello", "HELLO", matcher=lower_matcher)
  True
  ```

  `calcpy` also provide a class `calcpy.matcher.PandasFrameMatcher` for comparing `pd.Series`s and `pd.DataFrame`s.

  - `calcpy.matcher.PandasFrameMatcher()`   Compare whether pandas objects as a whole. The same as `loper.equals(roper)`.

  - `calcpy.matcher.PandasFrameMatcher("index")`   Compare index values of pandas objects.

  - `calcpy.matcher.PandasFrameMatcher("values")`    Compare values of pandas objects, ignoring the index values.

  - `calcpy.matcher.PandasFrameMatcher("series")`     Compare `pd.DataFrame` in a `pd.Series` way. By default, it is `left_series.equals(right_series)`.

  For `pd.DataFrame`, it also provides a keyword parameter `axis`. It compares each row when it is set to 0 (the default value) or `'index'`, and compares each column if `axis` is set to 1 or `'column'`.



  **Repetend Analysis**

  - `calcpy.sequence.min_repetend_len()`: Get the mimimum length of repetends.

  Usage Example:
  ```python
  >>> from calcpy.sequence import min_repetend_len
  >>> min_repetend_len([1, 2, 3, 1, 2, 3, 1, 2])
  3
  ```

  **Sequence Generator**

  - `calcpy.sequence.A276128()`: Generator for the sequence [OEIS A276128](https://oeis.org/A276128).

  Usage Example:
  ```python
  >>> from calcpy.sequence import A276128
  >>> print(list(A276128(14)))
  [0, 0, 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 21, 24]
  ```


pkgId: 35dc9f94b82d65e5708a0eef1e38e1345dd402acd11f9fdca44c09834972abe5
name: python-calibsunapi-help
arch: noarch
version: 0.0.18
epoch: 0
release: 1
summary: Development documents and examples for calibsunapi
url: https://github.com/SOLAIS-FORECAST/api-python-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-calibsunapi-0.0.18-1.src.rpm
location_href: Packages/python-calibsunapi-help-0.0.18-1.noarch.rpm
checksum_type: sha256
description:
  Calibsunapi is a Python client for interacting with the CalibSun API. This package allows developers to easily integrate and communicate with the CalibSun services, providing functionalities such as data retrieval, data submission, and various API interactions.

  It is designed to be simple, efficient, and easy to use, and provides different abstractions making it an ideal choice for developers looking to leverage CalibSun's capabilities in their Python applications.




  Having troubles installing or using Calibsunapi ? Feel free to ask questions at any of the contact methods or file an issue on [Calibsunapi's GitHub page](https://github.com/SOLAIS-FORECAST/api-python-client).


  Documentation : https://solais-forecast.github.io/api-python-client/


pkgId: 3c278dfc3f40d0a4eee28ef114218a962429796540ae5fd9cb36db0e4500e72d
name: python-calkit-python-help
arch: noarch
version: 0.9.4
epoch: 0
release: 1
summary: Development documents and examples for calkit-python
url: https://github.com/calkit/calkit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-calkit-python-0.9.4-1.src.rpm
location_href: Packages/python-calkit-python-help-0.9.4-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://calkit.org" target="_blank">
      <img width="40%" src="docs/img/calkit-no-bg.png" alt="Calkit">
    </a>
  </p>

  Calkit is a lightweight framework for reproducible research projects.
  It acts as a top-level layer to integrate and simplify the use of enabling
  technologies such as
  [Git](https://git-scm.com/),
  [DVC](https://dvc.org/),
  [Conda](https://docs.conda.io/en/latest/),
  and [Docker](https://docker.com).
  Calkit also adds a domain-specific data model
  such that all aspects of the research process can be fully described in a
  single repository and therefore easily consumed by others.

  Our goal is to make reproducibility easier so it becomes more common.
  To do this, we try to make it easy for users to follow two simple rules:

  1. **Keep everything in version control.** This includes large files like
     datasets, enabled by DVC.
     The [Calkit cloud](https://github.com/calkit/calkit-cloud)
     serves as a simple default DVC remote storage location for those who do not
     want to manage their own infrastructure.
  2. **Generate all important artifacts with a single pipeline.** There should be
     no special instructions required to reproduce a project's artifacts.
     It should be as simple as calling `calkit run`.
     The DVC pipeline (in a project's `dvc.yaml` file) is therefore the main
     thing to "build" throughout a research project.
     Calkit provides helper functionality to build pipeline stages that
     keep computational environments up-to-date and label their outputs for
     convenient reuse.



  To install Calkit, [Git](https://git-scm.com) and Python must be installed.
  If you want to use [Docker](https://docker.com) containers,
  which is typically a good idea,
  that should also be installed.
  For Python, we recommend
  [Miniforge](https://conda-forge.org/miniforge/).
  If you're a Windows user and decide to install Miniforge or any other
  Conda-based distribution,
  e.g., Anaconda, you'll probably want to ensure that environment is
  [activated by default in Git Bash](https://discuss.codecademy.com/t/setting-up-conda-in-git-bash/534473).

  After Python is installed, run

  ```sh
  pip install calkit-python
  ```



  The Calkit Cloud ([calkit.io](https://calkit.io)) serves as a project
  management interface and a DVC remote for easily storing all versions of your
  data/code/figures/publications, interacting with your collaborators,
  reusing others' research artifacts, etc.

  After signing up, visit the [settings](https://calkit.io/settings) page
  and create a token.
  Then run

  ```sh
  calkit config set token ${YOUR_TOKEN_HERE}
  ```

  Then, inside a project repo you'd like to connect to the cloud, run

  ```sh
  calkit config setup-remote
  ```

  This will setup the Calkit DVC remote, such that commands like `dvc push` will
  allow you to push versions of your data or pipeline outputs to the cloud
  for safe storage and sharing with your collaborators.



  - [LaTeX collaboration with GitHub Codespaces](https://petebachant.me/latex-collab/)
  - [Jupyter notebook as a DVC pipeline](docs/tutorials/notebook-pipeline.md)
  - [Keeping track of conda environments](docs/tutorials/conda-envs.md)
  - [Defining and executing manual procedures](docs/tutorials/procedures.md)
  - [Adding a new LaTeX-based publication with its own Docker build environment](docs/tutorials/adding-latex-pub-docker.md)
  - [A reproducible workflow using Microsoft Office (Word and Excel)](https://petebachant.me/office-repro/)
  - [Reproducible OpenFOAM simulations](https://petebachant.me/reproducible-openfoam/)



  If your work is reproducible, that means that someone else can "run" it and
  calculate the same results or outputs.
  This is a major step towards addressing
  [the replication crisis](https://en.wikipedia.org/wiki/Replication_crisis)
  and has some major benefits for both you as an individual and the research
  community:

  1. You will avoid mistakes caused by, e.g., running an old version of a script
     and including a figure that wasn't created after fixing a bug in the data
     processing pipeline.
  2. Since your project is "runnable," it's more likely that someone else will be
     able to reuse part of your work to run it in a different context, thereby
     producing a bigger impact and accelerating the pace of discovery.
     If someone can take what you've done and use it to calculate a
     prediction, you have just produced truly useful knowledge.



  Git, GitHub, DVC, Docker et al. are amazing tools/platforms, but their
  use involves multiple fairly difficult learning curves,
  and tying them together might mean developing something new for each project.
  Our goal is to provide a single tool and platform to unify all of these so
  that there is a single, gentle learning curve.
  However, it is not our goal to hide or replace these underlying components.
  Advanced users can use them directly, but new users aren't forced to, which
  helps them get up and running with less effort and training.
  Calkit should help users understand what is going on under the hood without
  forcing them to work at that lower level of abstraction.



  Calkit creates a simple human-readable "database" inside the `calkit.yaml`
  file, which serves as a way to store important information about the project,
  e.g., what question(s) it seeks to answer,
  what files should be considered datasets, figures, publications, etc.
  The Calkit cloud reads this database and registers the various entities
  as part of the entire ecosystem such that if a project is made public,
  other researchers can find and reuse your work to accelerate their own.



  1. Be opinionated. Users should not be forced to make unimportant decisions.
     However, if they disagree, they should have the ability to change the
     default behavior. The most common use case should be default.
     Commands that are commonly executed as groups should be combined, but
     still available to be run individually if desired.
  1. Commits should ideally be made automatically as part of actions that make
     changes to the project repo. For
     example, if a new object is added via the CLI, a commit should be made
     right then unless otherwise specified. This saves the trouble of running
     multiple commands and encourages atomic commits.
  1. Pushes should require explicit input from the user.
     It is still TBD whether or not a pull should automatically be
     made, though in general we want to encourage trunk-based development, i.e.,
     only working on a single branch. One exception might be for local
     experimentation that has a high likelihood of failure, in which case a
     branch can be a nice way to throw those changes away.
     Multiple branches should probably not live in the cloud, however, except
     for small, quickly merged pull requests.
  1. Idempotency is always a good thing. Unnecessary state is bad. For example,
     we should not encourage caching pipeline outputs for operations that are
     cheap. Caching should happen either for state that is valuable on its
     own, like a figure, or for an intermediate result that is expensive to
     generate.
  1. There should be the smallest number of
     frequently used commands as possible, and they should require as little
     memorization as possible to know how to execute, e.g., a user should be
     able to keep running `calkit run` and that's all they really need to do
     to make sure the project is up-to-date.


pkgId: 53d02e8c8798179a3d4b1b3b7aaab7d4bc21d99074f46ba02bc2b5512b336e86
name: python-calrissian-help
arch: noarch
version: 0.18.1
epoch: 0
release: 1
summary: Development documents and examples for calrissian
url: https://pypi.org/project/calrissian/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-calrissian-0.18.1-1.src.rpm
location_href: Packages/python-calrissian-help-0.18.1-1.noarch.rpm
checksum_type: sha256
description:
  CWL on Kubernetes

  ![Build Workflow](https://github.com/Duke-GCB/calrissian/actions/workflows/build.yaml/badge.svg)

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



  Calrissian is a [CWL](https://www.commonwl.org) implementation designed to run inside a Kubernetes cluster. Its goal is to be highly efficient and scalable, taking advantage of high capacity clusters to run many steps in parallel.



  Calrissian requires a [Kubernetes](https://kubernetes.io) or [Openshift](https://www.openshift.com)/[OKD](https://www.okd.io) cluster, configured to provision [PersistentVolumes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/) with the `ReadWriteMany` access mode. Kubernetes installers and cloud providers don't usually include this type of storage, so it may require additional configuration.

  Calrissian has been tested with NFS using the [nfs-client-provisioner](https://github.com/kubernetes-incubator/external-storage/tree/master/nfs-client) and with GlusterFS using [OKD Containerized GlusterFS](https://docs.okd.io/3.11/install_config/persistent_storage/persistent_storage_glusterfs.html). Many cloud providers have an NFS offering, which integrates easily using the nfs-client-provisioner.



  Calrissian is designed to issue tasks in parallel if they are independent, and thanks to Kubernetes, should be able to run very large parallel workloads.

  When running `calrissian`, you must provide a limit the the number of CPU cores (`--max-cores`) and RAM megabytes (`--max-ram`) to use concurrently. Calrissian will use CWL [ResourceRequirements](https://www.commonwl.org/v1.0/CommandLineTool.html#ResourceRequirement) to track usage and stay within the limits provided. We highly recommend using accurate ResourceRequirements in your workloads, so that they can be scheduled efficiently and are less likely to be terminated or refused by the cluster.

  `calrissian` parameters can be provided via a JSON configuration file either stored under `~/.calrissian/default.json` or provided via the `--conf` option.

  Below an example of such a file:

  ```json
  {
      "max_ram": "16G",
      "max_cores": "10",
      "outdir": "/calrissian",
      "tmpdir_prefix": "/calrissian/tmp"
  }
  ```



  Calrissian leverages [cwltool](https://github.com/common-workflow-language/cwltool) heavily and most conformance tests for CWL v1.0. Please see [conformance](conformance) for further details and processes.

  To view open issues related to conformance, see the [conformance](https://github.com/Duke-GCB/calrissian/issues?q=is%3Aopen+is%3Aissue+label%3Aconformance) label on the issue tracker.



  Please see [examples](examples) for installation and setup instructions.



  Calrissian's behaviors can be customized by setting the following environment variables in the container specification.



  By default, pods for a job step will be deleted after termination

  - `CALRISSIAN_DELETE_PODS`: Default `true`. If `false`, job step pods will not be deleted.



  When encountering a Kubernetes API exception, Calrissian uses a library to retry API calls with an exponential backoff. See the [tenacity documentation](https://tenacity.readthedocs.io/en/latest/index.html#waiting-before-retrying) for details.

  - `RETRY_MULTIPLIER`: Default `5`. Unit for multiplying the exponent interval.
  - `RETRY_MIN`: Default `5`. Minimum interval between retries.
  - `RETRY_MAX`: Default `1200`. Maximum interval between retries.
  - `RETRY_ATTEMPTS`: Default `10`. Max number of retries before giving up.





  Note that for development you can just use [Hatch] directly as described below.



  The main tool that is used for development is [Hatch]. It manages dependencies (in a virtualenv that is created on the fly) and is also the command runner.

  So first, [install it][install Hatch]. Ideally in an isolated way with **`pipx install hatch`** (after [installing `pipx`]), or just `pip install hatch` as a more well-known way.



  ```
  hatch run test:test
  ```

  Verbose:

  ```
  hatch run test:testv
  ```



  ```
  hatch run test:cov
  ```



  ```
  hatch run calrissian
  ```



  ```
  hatch run docs:serve
  ```


pkgId: aefd881595f2461d05fdb578e353add9bf96896ecd5f3afd63dc294cddb9ed48
name: python-calzone-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for calzone
url: https://pypi.org/project/calzone/
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-calzone-1.1.1-1.src.rpm
location_href: Packages/python-calzone-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Calzone (**CAL**orimeter **ZONE**) is a Python package built on top of
  [Geant4][Geant4]. It was developed in the context of geosciences with the
  objective of studying the emission of radioactivity from volcanoes [(Terray et
  al., 2020)][TGV+20], and in particular to simulate the response of gamma
  spectrometers deployed in the field. To this end, Calzone was developed in
  conjunction with [Goupil][GOUPIL] [(Niess et al., 2024)][NVT24], a backward
  gamma transport engine, and is interoperable with the latter. Yet, both packages
  can be used entirely independently, if necessary.

  Please refer to the online [documentation][RTD] for further information.




  Binary distributions of Calzone are available from [PyPI][PyPI], for Linux
  `x86_64`, e.g. as

  ```bash
  pip3 install calzone
  ```

  Alternatively, in order to build Calzone from the source, a working
  [Geant4][Geant4] installation is required. Please refer to the corresponding
  [documentation][RTD_INSTALLATION] entry for further instructions.



  The Calzone source is distributed under the **GNU LGPLv3** license. See the
  provided [LICENSE][LICENSE] and [COPYING.LESSER][COPYING.LESSER] files.
  Additionaly, Calzone uses software developed by Members of the [Geant4][Geant4]
  Collaboration, which is under a [specific license][G4_LICENSE].


  [COPYING.LESSER]: https://github.com/niess/calzone/blob/master/COPYING.LESSER
  [JSON]: https://www.json.org/json-en.html
  [Geant4]: http://cern.ch/geant4
  [Goupil]: https://github.com/niess/goupil
  [G4_LICENSE]: https://geant4.web.cern.ch/download/license#license
  [LICENSE]: https://github.com/niess/calzone/blob/master/LICENSE
  [NVT24]: https://doi.org/10.48550/arXiv.2412.02414
  [PyPI]: https://pypi.org/project/calzone/
  [RTD]: https://calzone.readthedocs.io/en/latest/?badge=latest
  [RTD_BADGE]: https://readthedocs.org/projects/calzone/badge/?version=latest
  [RTD_INSTALLATION]: https://calzone.readthedocs.io/en/latest/installation.html
  [TGV+20]: https://doi.org/10.1029/2019JB019149
  [TOML]: https://toml.io/en/
  [YAML]: https://yaml.org/


pkgId: c2371c14bca916979e0a74f1d0972ecbe5344f9bf8457231bab4d5e7bc7f4744
name: python-camel-ai-help
arch: noarch
version: 0.2.12
epoch: 0
release: 1
summary: Development documents and examples for camel-ai
url: https://www.camel-ai.org/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-camel-ai-0.2.12-1.src.rpm
location_href: Packages/python-camel-ai-help-0.2.12-1.noarch.rpm
checksum_type: sha256
description:
  Core components and utilities to build, operate, and enhance CAMEL-AI agents and societies.
  | Module | Description |
  |:---|:---|
  | **[Models](https://docs.camel-ai.org/key_modules/models.html)** | Model architectures and customization options for agent intelligence. |
  | **[Messages](https://docs.camel-ai.org/key_modules/messages.html)** | Messaging protocols for agent communication. |
  | **[Memory](https://docs.camel-ai.org/key_modules/memory.html)** | Memory storage and retrieval mechanisms. |
  | **[Tools](https://docs.camel-ai.org/key_modules/tools.html)** | Tools integration for specialized agent tasks. |
  | **[Prompts](https://docs.camel-ai.org/key_modules/prompts.html)** | Prompt engineering and customization. |
  | **[Tasks](https://docs.camel-ai.org/key_modules/tasks.html)** | Task creation and management for agent workflows. |
  | **[Loaders](https://docs.camel-ai.org/key_modules/loaders.html)** | Data loading tools for agent operation. |
  | **[Storages](https://docs.camel-ai.org/key_modules/storages.html)** | Storage solutions for agent. |
  | **[Society](https://docs.camel-ai.org/key_modules/society.html)** | Components for building agent societies and inter-agent collaboration. |
  | **[Embeddings](https://docs.camel-ai.org/key_modules/embeddings.html)** | Embedding models for RAG. |


pkgId: bc7887c4d64c37773bacc012143f924f376905f1035f91c727c0c4d8c8cb089a
name: python-camera-stage-mapping-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for camera-stage-mapping
url: https://gitlab.com/openflexure/microscope-extensions/camera-stage-mapping/
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-camera-stage-mapping-0.1.7-1.src.rpm
location_href: Packages/python-camera-stage-mapping-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  This Python module allows you to calibrate a microscope's stage against the camera.  By moving the sample a known number of steps, and tracking how far the image translates, it is possible to recover the number of steps per pixel.  This code goes a step further, and recovers a 2x2 affine transformation matrix, so it will cope with rotation, flipping, and non-uniform scaling of the X and Y axes.  The calibration routines are designed to be relatively robust and minimally parameterised, so they start by determining a sensible step size automatically.

  As part of the calibration, you can use either FFT-based or directly calculated cross correlation to track motion of the sample.  This code is probably useful on its own, and is found in the ``fft_image_tracking`` and ``correlation_image_tracking`` submodules.  The underlying mechanism of tracking stage and camera coordinates simultaneously is handled by the ``CameraStageTracker`` class, in ``camera_stage_tracker``.  The main calibration function is ``camera_stage_calibration_1d.calibrate_backlash_1d``.  For 2D calibration, I recommend running this once for X and once for Y, then using ``camera_stage_calibration_1d.image_to_stage_displacement_from_1d`` to combine the two calibrations.  This is more robust than the 2D grid calibration method.


  Rather than tie these functions to a specific class interface, as found in many lab control frameworks, the calibration routines simply require functions to be passed in as arguments.  This is done for maximum flexibility, and to impose the fewest necessary constraints on the hardware we are controlling.  In the future, we may define a class interface to use, and would welcome input on how to do this without forcing a particular taxonomy of laboratory instruments upon everyone using the library.


  ```
  pip install camera-stage-mapping
  ```
  This package is published on PyPI and can be installed using ``pip``.  It's managed using ``poetry`` and can be installed by cloning the repository and running ``poetry install``.  For details of how to set up a development environment, please see [CONTRIBUTING].


  The functions all have fairly extensive docstrings and the module is documented on [readthedocs].

  [readthedocs]: https://camera-stage-mapping.readthedocs.io/en/latest/index.html
  [CONTRIBUTING]: ./CONTRIBUTING.md


pkgId: 8ab5a17889e3444d97a8f950846593e0eae608691db8cc13ba902878cbeba452
name: python-camsai-standards-help
arch: noarch
version: 2024.12.13.post1
epoch: 0
release: 1
summary: Development documents and examples for camsai-standards
url: https://pypi.org/project/camsai-standards/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-camsai-standards-2024.12.13.post1-1.src.rpm
location_href: Packages/python-camsai-standards-help-2024.12.13.post1-1.noarch.rpm
checksum_type: sha256
description:
  This repository provides:
  - **Data Models**: Pydantic-based schemas for defining and validating data structures.
  - **Validation Utilities**: Tools to ensure data compliance with established standards.


pkgId: c49a704273999abd09901cd6176ddca902b075778d974eb2da9607f5b635a769
name: python-camtools-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for camtools
url: https://github.com/yxlao/camtools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-camtools-0.1.6-1.src.rpm
location_href: Packages/python-camtools-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/yxlao/camtools/main/camtools/assets/camtools_logo_dark.png">
      <img alt="CamTools Logo" src="https://raw.githubusercontent.com/yxlao/camtools/main/camtools/assets/camtools_logo_light.png" width="360">
    </picture>
  </p>
  <h1 align="center">CamTools: Camera Tools for Computer Vision</h1>

  [![Formatter](https://github.com/yxlao/camtools/actions/workflows/formatter.yml/badge.svg)](https://github.com/yxlao/camtools/actions/workflows/formatter.yml)
  [![Unit Test](https://github.com/yxlao/camtools/actions/workflows/unit_test.yml/badge.svg)](https://github.com/yxlao/camtools/actions/workflows/unit_test.yml)
  [![PyPI](https://github.com/yxlao/camtools/actions/workflows/pypi.yml/badge.svg)](https://github.com/yxlao/camtools/actions/workflows/pypi.yml)
  [![GitHub](https://img.shields.io/badge/GitHub-323940.svg?style=flat&logo=github&logoColor=959DA5)](https://github.com/yxlao/camtools)
  [![Gitee](https://img.shields.io/badge/Gitee-323940.svg?style=flat&logo=gitee&logoColor=959DA5)](https://gitee.com/yxlao/camtools)
  [![PyPI](https://img.shields.io/pypi/v/camtools?style=flat&label=PyPI&logo=PyPI&logoColor=959DA5&labelColor=323940&color=808080)](https://pypi.org/project/camtools)

  CamTools is a collection of tools for handling cameras in computer vision. It
  can be used for plotting, converting, projecting, ray casting, and doing more
  with camera parameters. It follows the standard camera coordinate system with
  clear and easy-to-use APIs.

  <p align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/yxlao/camtools/main/camtools/assets/camera_coordinates_dark.png">
      <img alt="CamTools Logo" src="https://raw.githubusercontent.com/yxlao/camtools/main/camtools/assets/camera_coordinates_light.png" width="520">
    </picture>
  </p>



  1. Plot cameras. Useful for debugging 3D reconstruction and NeRFs!

     ```python
     import camtools as ct
     import open3d as o3d
     cameras = ct.camera.create_camera_frustums(Ks, Ts)
     o3d.visualization.draw_geometries([cameras])
     ```

     <p align="center">
        <img src="https://raw.githubusercontent.com/yxlao/camtools/main/camtools/assets/camera_frames.png" width="360" />
     </p>

  2. Convert camera parameters.

     ```python
     pose = ct.convert.T_to_pose(T)     # Convert T to pose
     T    = ct.convert.pose_to_T(pose)  # Convert pose to T
     R, t = ct.convert.T_to_R_t(T)      # Convert T to R and t
     C    = ct.convert.pose_to_C(pose)  # Convert pose to camera center
     K, T = ct.convert.P_to_K_T(P)      # Decompose projection matrix P to K and T
                                        
     ```

  3. Projection and ray casting.

     ```python
     
     pixels = ct.project.points_to_pixel(points, K, T)

     
     points = ct.project.im_depth_to_points(im_depth, K, T)

     
     im_depth = ct.raycast.mesh_to_im_depth(mesh, K, T, height, width)

     
     ```

  4. Image and depth I/O with no surprises.

     Strict type checks and range checks are enforced. The image and depth I/O
     APIs are specifically designed to solve the following pain points:

     - Is my image of type `float32` or `uint8`?
     - Does it have range `[0, 1]` or `[0, 255]`?
     - Is it RGB or BGR?
     - Does my image have an alpha channel?
     - When saving depth image as integer-based `.png`, is it correctly scaled?

     ```python
     ct.io.imread()
     ct.io.imwrite()
     ct.io.imread_detph()
     ct.io.imwrite_depth()
     ```

  5. Command-line tools `ct` (runs in terminal).

     ```bash
     
     ct crop-boarders *.png --pad_pixel 10 --skip_cropped --same_crop

     
     ct draw-bboxes path/to/a.png path/to/b.png

     
     ct --help
     ```

     <p align="center">
        <img src="https://user-images.githubusercontent.com/1501945/241416210-e11ff3bf-22e6-46c0-8ba0-d177a0015323.png" width="400" />
     </p>

  6. And more.
     - Solve line intersections.
     - COLMAP tools.
     - Points normalization.
     - ...



  To install CamTools, simply do:

  ```bash
  pip install camtools
  ```

  Alternatively, you can install CamTools from source with one of the following
  methods:

  ```bash
  git clone https://github.com/yxlao/camtools.git
  cd camtools


  pip install .


  pip install -e .


  pip install -e .[dev]



  pip install -e .[dev] --config-settings editable_mode=strict


  pip install camtools[torch]


  pip install -e .[torch]
  ```



  A homogeneous point `[X, Y, Z, 1]` in the world coordinate can be projected to a
  homogeneous point `[x, y, 1]` in the image (pixel) coordinate using the
  following equation:

  $$
  \lambda
  \left[\begin{array}{l}
  x \\
  y \\
  1
  \end{array}\right]=\left[\begin{array}{ccc}
  f_{x} & 0 & c_{x} \\
  0 & f_{y} & c_{y} \\
  0 & 0 & 1
  \end{array}\right]\left[\begin{array}{llll}
  R_{00} & R_{01} & R_{02} & t_{0} \\
  R_{10} & R_{11} & R_{12} & t_{1} \\
  R_{20} & R_{21} & R_{22} & t_{2}
  \end{array}\right]\left[\begin{array}{c}
  X \\
  Y \\
  Z \\
  1
  \end{array}\right].
  $$

  We follow the standard OpenCV-style camera coordinate system as illustrated at
  the beginning of the README.

  - **Camera coordinate:** right-handed, with $Z$ pointing away from the camera
    towards the view direction and $Y$ axis pointing down. Note that the OpenCV
    convention (camtools' default) is different from the OpenGL/Blender
    convention, where $Z$ points towards the opposite view direction, $Y$ points
    up and $X$ points right. To convert between the OpenCV camera coordinates and
    the OpenGL-style coordinates, use the conversion functions:
    - `ct.convert.T_opencv_to_opengl()`
    - `ct.convert.T_opengl_to_opencv()`
    - `ct.convert.pose_opencv_to_opengl()`
    - `ct.convert.pose_opengl_to_opencv()`
  - **Image coordinate:** starts from the top-left corner of the image, with $x$
    pointing right (corresponding to the image width) and $y$ pointing down
    (corresponding to the image height). This is consistent with OpenCV. Pay
    attention that the 0th dimension in the image array is the height (i.e., $y$)
    and the 1st dimension is the width (i.e., $x$). That is:
    - $x$ <=> $u$ <=> width <=> column <=> the 1st dimension
    - $y$ <=> $v$ <=> height <=> row <=> the 0th dimension
  - `K`: `(3, 3)` camera intrinsic matrix.
    ```python
    K = [[fx,  s, cx],
         [ 0, fy, cy],
         [ 0,  0,  1]]
    ```
  - `T` or `W2C`: `(4, 4)` camera extrinsic matrix.
    ```python
    T = [[R  | t   = [[R00, R01, R02, t0],
          0  | 1]]    [R10, R11, R12, t1],
                      [R20, R21, R22, t2],
                      [  0,   0,   0,  1]]
    ```
    - `T` is also known as the world-to-camera `W2C` matrix, which transforms a
      point in the world coordinate to the camera coordinate.
    - `T`'s shape is `(4, 4)`, not `(3, 4)`.
    - `T` is the inverse of `pose`, i.e., `np.linalg.inv(T) == pose`.
    - The camera center `C` in world coordinate is projected to `[0, 0, 0, 1]` in
      camera coordinate.
  - `R`: `(3, 3)` rotation matrix.
    ```python
    R = T[:3, :3]
    ```
    - `R` is a rotation matrix. It is an orthogonal matrix with determinant 1, as
      rotations preserve volume and orientation.
      - `R.T == np.linalg.inv(R)`
      - `np.linalg.norm(R @ x) == np.linalg.norm(x)`, where `x` is a `(3,)`
        vector.
  - `t`: `(3,)` translation vector.
    ```python
    t = T[:3, 3]
    ```
    - `t`'s shape is `(3,)`, not `(3, 1)`.
  - `pose` or `C2W`: `(4, 4)` camera pose matrix. It is the inverse of `T`.
    - `pose` is also known as the camera-to-world `C2W` matrix, which transforms a
      point in the camera coordinate to the world coordinate.
    - `pose` is the inverse of `T`, i.e., `pose == np.linalg.inv(T)`.
  - `C`: camera center.
    ```python
    C = pose[:3, 3]
    ```
    - `C`'s shape is `(3,)`, not `(3, 1)`.
    - `C` is the camera center in world coordinate. It is also the translation
      vector of `pose`.
  - `P`: `(3, 4)` the camera projection matrix.
    - `P` is the world-to-pixel projection matrix, which projects a point in the
      homogeneous world coordinate to the homogeneous pixel coordinate.
    - `P` is the product of the intrinsic and extrinsic parameters.
      ```python
      
      P = K @ np.hstack([R, t[:, None]])
      ```
    - `P`'s shape is `(3, 4)`, not `(4, 4)`.
    - It is possible to decompose `P` into intrinsic and extrinsic matrices by QR
      decomposition.
    - Don't confuse `P` with `pose`. Don't confuse `P` with `T`.
  - For more details, please refer to the following blog posts:
    [part 1](https://ksimek.github.io/2012/08/14/decompose/),
    [part 2](https://ksimek.github.io/2012/08/22/extrinsic/),
    and [part 3](https://ksimek.github.io/2013/08/13/intrinsic/).



  - Follow [Angular's commit message convention](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#-commit-message-format) for PRs.
    - This applies to PR's title and ultimately the commit messages in `main`.
    - The prefix shall be one of `build`, `ci`, `docs`, `feat`, `fix`, `perf`, `refactor`, `test`.
    - Use lowercase.
  - Format your code with [black](https://github.com/psf/black). This will be enforced by the CI.



  If you use CamTools in your project, consider adding one of the following
  badges to your project.

  <p>
  <a href="https://github.com/yxlao/camtools"><img alt="Built with CamTools" src="https://raw.githubusercontent.com/yxlao/camtools/main/camtools/assets/built_with_camtools_dark.svg" width=240></a>
  <a href="https://github.com/yxlao/camtools"><img alt="Built with CamTools" src="https://raw.githubusercontent.com/yxlao/camtools/main/camtools/assets/built_with_camtools_light.svg" width=240></a>
  </p>


pkgId: 5a4e07c00ed0d9426bccf19f14f6b413dee1088dfedb369fe956d8fccf5d6bbe
name: python-cancli-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for cancli
url: https://pypi.org/project/cancli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cancli-1.3.0-1.src.rpm
location_href: Packages/python-cancli-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  A command line interface to send and receive CAN bus messages.

  This program is based on:

  - [prompt_toolkit](https://python-prompt-toolkit.readthedocs.io/en/stable/) for the user interface
  - [confattr](https://erzo.gitlab.io/confattr/latest/) for parsing user input, providing auto completion and config files
  - [cantools](https://github.com/cantools/cantools) for decoding and encoding CAN bus messages
  - [python-can](https://python-can.readthedocs.io/en/stable/index.html) for receiving and transmitting CAN bus messages




  Connect to a CAN bus with `bus can0 500k`.
  Incoming messages are printed.
  If there are too many messages you can hide some or all of them with `hide`.
  You can undo `hide` with `show` or display a hidden message once with `next` or `prev`.

  When you load a database file with `db path/to/db.dbc` messages are decoded
  and the signals are displayed in human readable form.
  If the data base file does not repeat the messages for every possible node
  you can specify that part of the arbitration id is a node id with `node-id FF << 8`.

  You can send messages with `send msg_name sig1=option1 sig2=3.14`.

  You can give different incoming messages different colors with `set color.message=%color.message%,importantmessage:ansired`.
  The syntax to add values to a dict setting is explained [here](https://erzo.gitlab.io/confattr/latest/intro.html#using-the-values-of-settings-or-environment-variables).
  The available colors are displayed in the auto completion.

  Available commands:

  - `bitrate`:    Set the default bitrate and change the bitrate of all active buses.
  - `bus`:        Activate a bus.
  - `read`:       Read CAN bus messages from a log file.
  - `db`:         Load a database file (dbc/sym/...).
  - `node-id`:    Specify that part of an arbitration id is a node id.
  - `mask`:       Specify a mask to modify an arbitration ID in case it is not found in the dbc file.
  - `send`/`s`:   Send a message on the last activated CAN bus.
  - `hide`/`-`:   Do not print received messages of the specified type.
  - `show`/`+`:   Undo the effect of a previous hide command.
  - `next`/`/`:   Print the next received message of the specified type regardless of
                  whether it has been disabled with the hide command.
  - `prev`/`?`:   Print the last received message of the specified type.
  - `grep`:       Search for signal.
  - `set`:        Change the value of a setting.
  - `include`:    Load another config file.
  - `save`:       Save the settings.
  - `echo`:       Display a message.
  - `help`:       Display help.
  - `quit`/`q`:   Quit the program.




  ```
  pipx install cancli
  ```




  In order to set bit rates and create virtual CAN buses root privileges are required.
  You can configure sudo to not ask for a password in these circumstances.

  Create a group called `can`:

  ```bash

  ```

  Add the desired user to the group (this requires a reboot to take effect):

  ```bash

  ```

  ```

  ```

  ```
  %can    ALL=(root) NOPASSWD: /bin/ip link set can? up type can bitrate *
  %can    ALL=(root) NOPASSWD: /bin/ip link set can? down
  %can    ALL=(root) NOPASSWD: /bin/ip link set can? up

  %can    ALL=(root) NOPASSWD: /usr/bin/modprobe vcan
  %can    ALL=(root) NOPASSWD: /bin/ip link add dev vcan? type vcan
  %can    ALL=(root) NOPASSWD: /bin/ip link set up vcan?
  ```

  Note that the last matching rule wins, not the most specific one.
  So in order to make sure that these rules are not overridden by other rules add them at the end of the file.




  - [Documentation](https://gitlab.com/erzo/cancli/-/blob/master/README.md)
  - [Source code](https://gitlab.com/erzo/cancli)
  - [Bug tracker](https://gitlab.com/erzo/cancli/-/issues)
  - [Change log](https://gitlab.com/erzo/cancli/-/tags)




  I am using [mypy](https://www.mypy-lang.org/) for static type checking.
  [tox](https://tox.wiki/en/latest/) creates a virtual environment and installs all dependencies for you.
  You can install tox with [pipx](https://pypa.github.io/pipx/) (`pipx install tox`).

  ```bash
  $ tox
  ```

  In order to make tox work without an internet connection install [devpi](https://devpi.net/docs/devpi/devpi/stable/%2Bd/index.html):

  ```bash
  $ pipx install devpi-server
  $ devpi-init
  $ devpi-gen-config
  $ su



  ```

  and add the following line to your bashrc:

  ```bash
  export PIP_INDEX_URL=http://localhost:3141/root/pypi/+simple/
  ```




  This work is free. You can use, copy, modify, and/or distribute it
  under the terms of the [BSD Zero Clause License](https://gitlab.com/erzo/cancli/-/blob/master/LICENSE).


pkgId: b259c63215fd88aa46244a29736470c02c42e9e4bbcbe7d678db50dde485fb49
name: python-candfans-client-help
arch: noarch
version: 3.8.0
epoch: 0
release: 1
summary: Development documents and examples for candfans-client
url: https://github.com/komanushi/candfans-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-candfans-client-3.8.0-1.src.rpm
location_href: Packages/python-candfans-client-help-3.8.0-1.noarch.rpm
checksum_type: sha256
description:
  非公式のCandfansのAPI Clientです。なんの保証もありません。


  https://pypi.org/project/candfans-client/


  ```bash
  pip install candfans-client
  ```



  ```bash
  poetry add candfans-client
  ```




  初期化時にログインを行います。

  ```python
  from candfans_client.client import CandFansClient

  client = CandFansClient(
      email='YOUR_EMAIL',
      password='YOUR_PASSWORD',
  )
  ```


  指定月の売上のサマリーを取得します。

  ```python
  sales = client.get_sales('2023-11')
  print(sales[0].subscribe_sum)
  ```


  指定月の売上の履歴を取得します。

  ```python
  histories = client.get_sales_history('2023-11')
  print(len(histories))
  print(histories[0])
  ```


  指定月の単体販売の詳細を取得します。

  ```python
  purchase = client.get_sales_purchase_post('2023-11')
  print(purchase.total_price, len(purchase.sales))
  ```


  指定月のサブスクの詳細を取得します。

  ```python
  subscribe = client.get_sales_subscribe('2023-11')
  print(subscribe.total_price, len(subscribe.sales))
  ```


  指定月のチップの詳細を取得します。

  ```python
  chip = client.get_sales_chip('2023-11')
  print(chip.total_price, len(chip.sales))
  ```


  指定月のバックナンバーの売上の詳細を取得します。

  ```python
  backnumber = client.get_sales_backnumber('2023-11')
  print(backnumber.total_price, len(backnumber.sales))
  ```





  ```
  poetry run python -m unittest discover -s tests/
  ```


pkgId: cdfaeacca7d2554bc93a625fb4b0272545bfbed280d50dced1aa922d6afd5826
name: python-candidhealth-help
arch: noarch
version: 0.36.1
epoch: 0
release: 1
summary: Development documents and examples for candidhealth
url: https://pypi.org/project/candidhealth/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-candidhealth-0.36.1-1.src.rpm
location_href: Packages/python-candidhealth-help-0.36.1-1.noarch.rpm
checksum_type: sha256
description:
  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2Fcandidhealth%2Fcandid-python)
  [![pypi](https://img.shields.io/pypi/v/candidhealth)](https://pypi.python.org/pypi/candidhealth)

  The Candid Python library provides convenient access to the Candid API from Python.



  ```sh
  pip install candidhealth
  ```



  Instantiate and use the client with the following:

  ```python
  from candid.client import CandidApiClient

  client = CandidApiClient(
      client_id="YOUR_CLIENT_ID",
      client_secret="YOUR_CLIENT_SECRET",
  )
  client.auth.v_2.get_token(
      client_id="YOUR_CLIENT_ID",
      client_secret="YOUR_CLIENT_SECRET",
  )
  ```



  The SDK also exports an `async` client so that you can make non-blocking calls to our API.

  ```python
  import asyncio

  from candid.client import AsyncCandidApiClient

  client = AsyncCandidApiClient(
      client_id="YOUR_CLIENT_ID",
      client_secret="YOUR_CLIENT_SECRET",
  )


  async def main() -> None:
      await client.auth.v_2.get_token(
          client_id="YOUR_CLIENT_ID",
          client_secret="YOUR_CLIENT_SECRET",
      )


  asyncio.run(main())
  ```



  When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
  will be thrown.

  ```python
  from .api_error import ApiError

  try:
      client.auth.v_2.get_token(...)
  except ApiError as e:
      print(e.status_code)
      print(e.body)
  ```





  The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long
  as the request is deemed retriable and the number of retry attempts has not grown larger than the configured
  retry limit (default: 2).

  A request is deemed retriable when any of the following HTTP status codes is returned:

  - [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
  - [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
  - [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) (Internal Server Errors)

  Use the `max_retries` request option to configure this behavior.

  ```python
  client.auth.v_2.get_token(...,{
      max_retries=1
  })
  ```



  The SDK defaults to a 60 second timeout. You can configure this with a timeout option at the client or request level.

  ```python

  from candid.client import CandidApiClient

  client = CandidApiClient(..., { timeout=20.0 }, )



  client.auth.v_2.get_token(...,{
      timeout_in_seconds=1
  })
  ```



  You can override the `httpx` client to customize it for your use-case. Some common use-cases include support for proxies
  and transports.
  ```python
  import httpx
  from candid.client import CandidApiClient

  client = CandidApiClient(
      ...,
      http_client=httpx.Client(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```



  While we value open-source contributions to this SDK, this library is generated programmatically.
  Additions made directly to this library would have to be moved over to our generation code,
  otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
  a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
  an issue first to discuss with us!

  On the other hand, contributions to the README are always very welcome!


pkgId: 621f1e8fc622dc141166bd09732c3f33c07e98d623ebbb45cfe54b53107e09b1
name: python-canonada-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for canonada
url: https://github.com/RLado/Canonada
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-canonada-0.1.2-1.src.rpm
location_href: Packages/python-canonada-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  > ⚠️ Canonada is currently under development.

  Canonada is a data science framework that helps you build production-ready streaming pipelines for data processing in Python.

  [![GitHub branch check runs](https://img.shields.io/github/check-runs/rlado/canonada/master)](https://github.com/RLado/Canonada)
  [![PyPI - Version](https://img.shields.io/pypi/v/canonada)](https://pypi.org/project/canonada/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/canonada)](https://pypi.org/project/canonada/)


  - **Standardized**: Canonada provides a standardized way to build your data projects
  - **Modular**: Canonada is modular and allows you to build and visualize data pipelines with ease
  - **Memory Efficient**: Canonada is memory efficient and can handle large datasets by streaming data through the pipeline instead of loading it all at once


  - **Centralized control of data sources**: Manage all your data sources in one place, enabling you to keep your team in sync
  - **Centralized control of the project configuration**: Manage all your project configurations in one place
  - **Easy dataloading**: Load data from various sources like CSV, JSON, Parquet, etc.
  - **Use functions as nodes**: Functions are the building blocks of Canonada. You can use any function as a node in your pipeline
  - **Create streaming data pipelines**: Create parallel and sequential data pipelines with ease
  - **Visualize your data pipeline**: Visualize your data pipelines, nodes and connections


  ```
  canonada.toml
  config/
      catalog.toml
      parameters.toml
      credentials.toml
  data/
      ...
  datahandlers/
      __init__.py
      custom_datahandler_1.py
      custom_datahandler_2.py
      ...
  notebooks/
      ...
  pipelines/
      __init__.py
      pipeline_1.py
      pipeline_2.py
      nodes_1/
          __init__.py
          node_1.py
          node_2.py
          ...
      nodes_2/
          __init__.py
          node_3.py
          node_4.py
          ...
      ...
  systems/
      __init__.py
      system_1.py
      system_2.py
      ...
  tests/
      test_node_group_1.py
      test_node_group_2.py
      ...
  ```


  Available commands:
  ```
  Usage: canonada <command> <args>
  Commands:
      new <project_name> - Create a new project
      catalog [list/params] - List all available datasets or get the project parameters
      registry [pipelines/systems] - List all available pipelines or systems
      run [pipelines/systems] <name(s)> - Run a pipeline or system
      view [pipelines/systems] <name(s)> - View a pipeline or system
      version - Print the version of Canonada
  ```


  Canonada is available on [PyPI](https://pypi.org/project/canonada/) and can be installed using pip:
  ```bash
  pip install canonada
  ```

  > Check out the [Getting Started](https://github.com/RLado/Canonada/wiki/GettingStarted) guide to learn how to create a new project with Canonada.


  Check out the project's documentation [here](https://github.com/RLado/Canonada/wiki)


  Contributions are welcome! If you have any suggestions, examples, datahandlers, bug reports, or feature requests, please open an issue or a discussion thread.


pkgId: 5581c452ab3a7ba39a8c5ce01011aa708683c4deecf17ec2b6983c4907f54c19
name: python-canonicalwebteam.image-template-help
arch: noarch
version: 1.4.1
epoch: 0
release: 1
summary: Development documents and examples for canonicalwebteam.image-template
url: https://github.com/canonical-web-and-design/canonicalwebteam.image-template
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-canonicalwebteam.image-template-1.4.1-1.src.rpm
location_href: Packages/python-canonicalwebteam.image-template-help-1.4.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/canonicalwebteam.image-template)](https://pypi.org/project/canonicalwebteam.image-template/)
  [![Tests](https://github.com/canonical-web-and-design/canonicalwebteam.image-template/workflows/Tests/badge.svg)](https://github.com/canonical-web-and-design/canonicalwebteam.image-template/actions?query=workflow%3ATests)
  [![Code coverage](https://codecov.io/gh/canonical-web-and-design/canonicalwebteam.image-template/branch/main/graph/badge.svg)](https://codecov.io/gh/canonical-web-and-design/canonicalwebteam.image-template)

  A module to generate performant HTML image markup for images. The markup
  will:

  - Use [native lazyloading](https://addyosmani.com/blog/lazy-loading/)
  - Explicitly define `width` and `height` attributes to avoid the page jumping effect
  - Prefix all image URLs with cloudinary CDN proxy URLs, to transform the image to the optimal size
  - Use predefined (2x) `srcset` break points for hidef screens



  - `url` (mandatory string): The url to an image (e.g. `https://assets.ubuntu.com/v1/9f6916dd-k8s-prometheus-light.png`)
  - `alt` (mandatory string): Alt text to describe the image
  - `hi_def` (mandatory boolean): Has an image been uploaded 2x the width and height of the desired size
  - `width` (mandatory integer): The number of pixels wide the image should be
  - `height` (optional integer): The number of pixels high the image should be
  - `fill` (optional boolean): Set the crop mode to ["fill"](https://cloudinary.com/documentation/image_transformation_reference#crop_parameter)
  - `loading` (optional string, default: "lazy"): Set to ["auto" or "eager"](https://addyosmani.com/blog/lazy-loading/) to disable lazyloading
  - `attrs` (optional dictionary): Extra `<img>` attributes (e.g. `class` or `id`) can be passed as additional arguments





  For local development, it's best to test this module with one of our website projects like [ubuntu.com](https://github.com/canonical-web-and-design/ubuntu.com/). For more information, follow [this guide (internal only)](https://discourse.canonical.com/t/how-to-run-our-python-modules-for-local-development/308).



  The `image_template` function can be used directly to generate image Markup.

  ``` python3
  from canonicalwebteam import image_template

  image_markup = image_template(
      url="https://assets.ubuntu.com/v1/450d7c2f-openstack-hero.svg",
      alt="",
      width="534",
      height="319",
      hi_def=True,
      loading="auto",
  	fill=True,
      attrs={"class": "hero", "id": "openstack-hero"},
  )
  ```

  However, the most common usage is to add it to Django or Flask template contexts, as an `image` function.



  Add it as a template tag:

  ``` python3


  from canonicalwebteam import image_template
  from django import template
  from django.utils.safestring import mark_safe


  register = template.Library()

  @register.simple_tag
  def image(*args, **kwargs):
      return mark_safe(image_template(*args, **kwargs))




  TEMPLATES[0]["OPTIONS"]["builtins"].append("myapp.templatetags")
  ```

  Use it in templates:

  ``` html


  {% image url="https://assets.ubuntu.com/v1/9f6916dd-k8s-prometheus-light.png" alt="Operational dashboard" width="1040" height="585" hi_def=True fill=True %}
  ```



  Add it as a template tag:

  ``` python3


  from canonicalwebteam import image_template
  from flask import Flask

  app = Flask(__name__)

  @app.context_processor
  def utility_processor():
      return {"image": image_template}
  ```

  Use it in templates, e.g.::

  ``` html


  {{
    image(
      url="https://assets.ubuntu.com/v1/450d7c2f-openstack-hero.svg",
      alt="",
      width="534",
      height="319",
      hi_def=True,
  	fill=True,
      loading="auto",
      attrs={"class": "hero", "id": "openstack-hero"},
    ) | safe
  }}
  ```



  The output image markup will be e.g.:

  ``` html
  <img
      src="https://res.cloudinary.com/canonical/image/fetch/f_auto,q_auto,fl_sanitize,w_534,h_319,c_fill/https://assets.ubuntu.com/v1/450d7c2f-openstack-hero.svg"
      srcset="https://res.cloudinary.com/canonical/image/fetch/f_auto,q_auto,fl_sanitize,w_1068,h_638,c_fill/https://assets.ubuntu.com/v1/450d7c2f-openstack-hero.svg 2x"
      alt=""
      width="534"
      height="319"
      loading="auto"
      class="hero"
      id="openstack hero"
  />
  ```



  To add the required markup for this template as a User Snippet, add the following as a HTML snippet (User Snippets under File > Preferences, or Code > Preferences on macOS):

  ```
  "Image module": {
  	"prefix": "image-module",
  	"body": [
  		"{{",
  		"	image_template(",
  		"		url=\"$1\",",
  		"		alt=\"$2\",",
  		"		height=\"$3\",",
  		"		width=\"$4\",",
  		"		hi_def=$5True,",
  		"		loading=\"auto|lazy$6\",",
  		"		attrs={\"class\": \"$7\"}",
  		"	) | safe",
  		"}}"
  	],
  	"description": "Image module include"
  }"
  ```


pkgId: 95326d11c0cf42a02acb4b447a9e4381d1bddf2cea552b85c9a25fbfbbd362ba
name: python-canvascli-help
arch: noarch
version: 0.8.2
epoch: 0
release: 1
summary: Development documents and examples for canvascli
url: https://github.com/joelostblom/canvascli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-canvascli-0.8.2-1.src.rpm
location_href: Packages/python-canvascli-help-0.8.2-1.noarch.rpm
checksum_type: sha256
description:
  `canvascli` downloads grades from Canvas,
  converts them into the format required
  for final submission to the FSC at UBC,
  and creates a few helpful visualizations.



  `canvascli` requires a recent version of Python and its package manager `pip`.
  After installing those ([e.g. via miniconda](https://docs.conda.io/en/latest/miniconda.html)),
  you can run this command from your terminal.

  ```shell
  python -m pip install -U canvascli
  ```



  All `canvascli` functionality requires that you have [created an Canvas API access
  token](https://community.canvaslms.com/t5/Instructor-Guide/How-do-I-manage-API-access-tokens-as-an-instructor/ta-p/1177),
  so do that first if you don't have one already.

  > When running `canvascli`,
  you can either paste your Canvas token when prompted at the command line
  (ideally using a password manager, e.g. [KeePassXC](https://keepassxc.org/)),
  or [store it in an environment variable](https://www.poftut.com/how-to-set-environment-variables-for-linux-windows-bsd-and-macosx/) named `CANVAS_PAT`.

  Typing `canvascli` at the command prompt will show the general help message
  including the available sub-commands.
  The most common use case
  is probably to prepare final grades for FSC submission,
  which you can do like so:

  ```shell
  canvascli prepare-fsc-grades --course-id 53665
  ```

  This will save a CSV file in the current directory
  which can be uploaded to the FSC.
  The file should automatically be correctly formatted,
  but it is a good idea to double check
  in case there are unexpected changes
  to how UBC inputs course info on Canvas.

  `canvascli` drops students without a grade by default,
  and creates a few helpful visualizations of the final grades
  and assignment scores.
  Run `canvascli prepare-fsc-grades --help`
  to view all available options.

  If you don't know the Canvas course id of your course,
  `canvascli` can check for you:

  ```shell
  canvascli show-courses
  ```

  This will output a table with all the courses
  your API token has access to.
  Run `canvascli show-courses --help`
  to view all available options.

  <details><summary>



  </summary>

  If you want suggestions for subcommands and option flags when you press <kbd>TAB</kbd>
  you can download the corresponding completion file
  from the GitHub repository
  and source it in your terminal's configuration file.
  If you don't want to do this manually,
  you can run one of the following commands
  (don't forget to restart your shell afterwards).



  > First make sure that your zsh general shell completion enabled
  by adding `autoload -Uz compinit && compinit` to your `.zshrc`;
  it is important that this line is added before running the command below.

  ```sh
  curl -Ss https://raw.githubusercontent.com/joelostblom/canvascli/main/canvascli-complete.zsh > ~/.canvascli-complete.zsh && echo ". ~/.canvascli-complete.zsh" >> ~/.zshrc
  ```



  > Bash shell completion requires bash >= 4.0
  (notably macOS ships with 3.x so use zsh instead).
  If you are using GitBash for Windows,
  change `.bashrc` to `.bash_profile` in the command below,
  and note that you will only get shell completion after typing `cavascli`,
  not `canvascli.exe`.

  ```sh
  curl -Ss https://raw.githubusercontent.com/joelostblom/canvascli/main/canvascli-complete.bash > ~/.canvascli-complete.bash && echo ". ~/.canvascli-complete.bash" >> ~/.bashrc
  ```

  </details>



  Questions and contributions are welcome!
  The best way to get in touch is to
  [open a new issue or discussion](https://github.com/joelostblom/canvascli/issues/new/choose).
  Remember to follow the [Code of Conduct](CODE_OF_CONDUCT.md)
  when you participate in this project.


pkgId: c552a59ced87a7bb47bb2779c4359720f6d2afd66a4a3a17b29aaf959099aba6
name: python-canvaslms-help
arch: noarch
version: 4.5
epoch: 0
release: 1
summary: Development documents and examples for canvaslms
url: https://github.com/dbosk/canvaslms
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-canvaslms-4.5-1.src.rpm
location_href: Packages/python-canvaslms-help-4.5-1.noarch.rpm
checksum_type: sha256
description:
  This program provides a command-line interface for Canvas. The command
  is `canvaslms` and it has several subcommands in the same style as Git.
  `canvaslms` provides output in a format useful for POSIX tools, this
  makes automating tasks much easier.



  Start by login to your Canvas server

  ``` {.text}
  canvaslms login
  ```

  Let's consider how to grade students logging into the student-shell SSH
  server. We store the list of students' Canvas and KTH IDs in a file.

  ``` {.text}
  canvaslms users -c DD1301 -s | cut -f 1,2 > students.csv
  ```

  Then we check who has logged into student-shell.

  ``` {.text startFrom="2"}
  ssh student-shell.sys.kth.se last | cut -f 1 -d " " | sort | uniq \
    > logged-in.csv
  ```

  Finally, we check who of our students logged in.

  ``` {.text startFrom="4"}
  for s in $(cut -f 2 students.csv); do
    grep $s logged-in.csv && \
  ```

  Finally, we can set their grade to P and add the comment "Well done!" in
  Canvas. We set the grades for the two assignments whose titles match the
  regular expression `(Preparing the terminal|The terminal)`.

  ``` {.text startFrom="6"}
      canvaslms grade -c DD1301 -a "(Preparing the terminal|The terminal)" \
        -u $(grep $s students.csv | cut -f 1) \
        -g P -m "Well done!"
  done
  ```



  Just install the PyPI package:
  ```
  python3 -m pip install canvaslms
  ```
  Some subcommands use `pandoc`, so you will likely have to [install
  pandoc][pandoc] on your system manually.

  [pandoc]: https://pandoc.org/installing.html


pkgId: ddf6d74895717c62a252af29dd7225722eebdcd32d76ab22eaaefbf15871364a
name: python-canvasrobot-help
arch: noarch
version: 0.8.25
epoch: 0
release: 1
summary: Development documents and examples for canvasrobot
url: https://pypi.org/project/canvasrobot/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-canvasrobot-0.8.25-1.src.rpm
location_href: Packages/python-canvasrobot-help-0.8.25-1.noarch.rpm
checksum_type: sha256
description:
  Library which uses
  [Canvasapi](https://canvasapi.readthedocs.io/en/stable/getting-started.html)
  (minimally patched to allow more flexible user search)
  to provide a CanvasRobot class for GUI and commandline use.
  You can install canvasrobot and urltransform (special edition
  to translate video urls in Canvas pages)
  using [UV](https://docs.astral.sh/uv/getting-started/installation/)
  Tip: use `brew` to install on macOS and `winget` on Windows. Check if the
  path is correct, after reopening terminal/Powershell

  ``` commandline
  uv tool install canvasrobot

  canvasrobot --help
  urltransform --help
  ```


  - [CanvasAPI](https://canvasapi.readthedocs.io/en/stable/getting-started.html)
  - rich
  - rich_click
  - keyring (safe store of api token)
  - pydal (local database)
  - pywebview (HTML reporting)
  - [opt] pymemcache (install to add caching canvas interaction)


  In word2quiz library.
  (Not yet ready for general use...)


  ```Python
  import rich
  import canvasrobot as cr

  if __name__ == '__main__':

      console = rich.console.Console(width=160, force_terminal=True)

      robot = cr.CanvasRobot(reset_api_keys=False,
                             console=console)

      
      robot.create_folder_in_all_courses('Tentamens')



      
      

      
      
      
      

      
      

      
      
      
      

      
      
      

      
      

      
      
      
      
      


      

      
      
      
      
      
      
      
  ```


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


pkgId: 254ae580fbd38922e380d6c3f34172208098e6396f7195f0b19941634e02824f
name: python-canvassyncer-help
arch: noarch
version: 2.0.12
epoch: 0
release: 1
summary: Development documents and examples for canvassyncer
url: https://github.com/BoYanZh/Canvas-Syncer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-canvassyncer-2.0.12-1.src.rpm
location_href: Packages/python-canvassyncer-help-2.0.12-1.noarch.rpm
checksum_type: sha256
description:
  [![MIT License](https://img.shields.io/pypi/l/canvassyncer)](https://github.com/BoYanZh/Canvas-Syncer/blob/master/LICENSE)
  [![CodeFactor](https://www.codefactor.io/repository/github/boyanzh/canvas-syncer/badge)](https://www.codefactor.io/repository/github/boyanzh/canvas-syncer)
  [![PyPi Version](https://img.shields.io/pypi/v/canvassyncer)](https://pypi.org/pypi/canvassyncer)

  An async python script that synchronizes files and folders across Canvas LMS Files and local, with extremely fast speed.



  You may use one of the following



  For Windows users, you can find binary(.exe) file here: <https://github.com/BoYanZh/Canvas-Syncer/releases>. Unzip it and double click `canvassyncer.exe` file to run, or calling it in shell.



  ```bash
  pipx install -U canvassyncer
  ```

  If you have not installed `pipx` yet, you may refer to <https://pipx.pypa.io/stable/> or the search engine to get your `pipx`.



  ```bash
  git clone https://github.com/BoYanZh/Canvas-Syncer && cd Canvas-Syncer
  pip install -e .
  ```



  ```bash
  canvassyncer
  ```

  Then input the information following the guide.

  *Note:*
  1. `courseCode` should be something like `VG100`, `ECE4530J`
  2. `courseID` should be an integer. Check the canvas link of the course. e.g. `courseID = 7` for <https://jicanvas.com/courses/7>.

  You can use `canvassyncer -h` to get help.

  Optional arguments:

  ```text
    -h, --help            show this help message and exit
    -r                    recreate config file
    -y                    confirm all prompts
    --no-subfolder        do not create a course code named subfolder when synchronizing files
    -p PATH, --path PATH  appoint config file path
    -c CONNECTION, --connection CONNECTION
                          max connection count with server
    -x PROXY, --proxy PROXY
                          download proxy
    -V, --version         show program's version number and exit
    -d, --debug           show debug information
    --no-keep-older-version
                          do not keep older version
  ```



  Open Your Canvas-Account-Approved Integrations-New Access Token

  Or it can be easily achieved with <https://github.com/BoYanZh/JI-Auth> if you are a UM-SJTU-JI student.




  Please feel free to create issues and pull requests.


pkgId: 843f7042f881a18a0469b79adbc633d16a83dff12f0f06a366c529880c604665
name: python-canvasxpress-help
arch: noarch
version: 2024.12.15.2220
epoch: 0
release: 1
summary: Development documents and examples for canvasxpress
url: https://github.com/docinfosci/canvasxpress-python.git
rpm_license: Copyright 2020 to 2024 CanvasXpress all rights reserved
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-canvasxpress-2024.12.15.2220-1.src.rpm
location_href: Packages/python-canvasxpress-help-2024.12.15.2220-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://www.canvasxpress.org">
  <img src="https://raw.githubusercontent.com/docinfosci/canvasxpress-python/main/readme/images/hexagon.png" align="left" width="175" style="vertical-align:middle;margin:10px 10px">
  </a>
  <br>

  [***CanvasXpress***](https://www.canvasxpress.org) was developed as the core visualization component for bioinformatics
  and systems biology analysis at Bristol-Myers Squibb. It supports a large number
  of [visualizations ](https://www.canvasxpress.org/examples.html)
  to display scientific and non-scientific data. ***CanvasXpress*** also includes a simple and unobtrusive
  [user interface](https://www.canvasxpress.org/docs/interface.html) to explore complex data sets, a sophisticated and
  unique mechanism to keep track of all user customization for
  [Reproducible Research ](https://www.canvasxpress.org/docs/audit.html) purposes, as well as an 'out of the box'
  broadcasting capability to synchronize selected data points across all ***CanvasXpress*** plots in a page. Data can be
  easily sorted, grouped, transposed, transformed or clustered dynamically. The fully customizable mouse events as well as
  the zooming, panning and drag-and-drop capabilities are features that make this library unique in its class.

  <img src="https://raw.githubusercontent.com/docinfosci/canvasxpress-python/main/readme/images/sample_graphs.png" align="center" width="726"></a>

  ***CanvasXpress*** can be used for native Python integration for the following environments:

  - [Shiny for Python](https://shiny.posit.co/py/)
  - [Streamlit](https://streamlit.io/)
  - [Plotly Dash](https://dash.plotly.com/)
  - [Jupyter](https://jupyter.org/)
  - [Flask](https://flask.palletsprojects.com/en/1.1.x/)
  - [Django](https://www.djangoproject.com/)

  The RStudio IDE Viewer is also used when running code chunks in Jupyter, Quarto, and RMD Python code chunks.

  This ***CanvasXpress*** Python package is maintained by [Dr. Todd C. Brett](https://github.com/docinfosci), with support
  from [Aggregate Genius Inc.](https://www.aggregate-genius.com), in cooperation with Dr. Isaac Neuhaus and the
  ***CanvasXpress*** team.



  [![Release](https://img.shields.io/pypi/v/canvasxpress.svg)](https://pypi.org/project/canvasxpress)
  [![Compatibility](https://img.shields.io/pypi/pyversions/canvasxpress.svg)](https://pypi.org/project/canvasxpress)
  [![Implementations](https://img.shields.io/pypi/implementation/canvasxpress.svg)](https://pypi.org/project/canvasxpress)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/canvasxpress)](https://pypi.org/project/canvasxpress)
  [![docinfosci](https://circleci.com/gh/docinfosci/canvasxpress-python/tree/main.svg?style=shield)](https://circleci.com/gh/docinfosci/canvasxpress-python/?branch=main)
  [![Coverage Status](https://coveralls.io/repos/github/docinfosci/canvasxpress-python/badge.svg?branch=main)](https://coveralls.io/github/docinfosci/canvasxpress-python?branch=main)
  [![Activity](https://img.shields.io/github/last-commit/docinfosci/canvasxpress-python/develop)](https://github.com/docinfosci/canvasxpress-python)





  Documentation is maintained at [CanvasXpress.org](https://www.canvasxpress.org) and LinkedIn:

  - [Introduction to CanvasXpress for Python](https://www.linkedin.com/pulse/introducing-canvasxpress-python-todd-brett-hew0f/?trackingId=G8kTE2QyRH%2BrcVSzxJc8Hg%3D%3D)



  CanvasXpress for Python can be installed using _pip_:

  The essential CanvasXpress package, for use with the CLI or flask and similar environments, can be installed using:

  ```terminal
  pip install canvasxpress
  ```

  or

  ```terminal
  pip install "canvasxpress[core]"
  ```

  In addition to _core_, the following additional targets can be used:

  - _jupyter_ - installs additional packages to support rendering in Jupyter, Quarto, and IPython documents
  - _dash_ - installs additional packages to support rendering in Plotly Dash applications
  - _streamlit_ - installs additional packages to support rendering in Snowflake Streamlit applications
  - _shiny_ - installs additional packages to support rendering in Posit Shiny for Python applications
  - _rstudio_ - installs additional packages to support rendering in the Posit RStudio IDE Viewer, plus includes the same packages for jupyter and shiny
  - _all_ - installs all additional packages to support rendering in any supported document or application



  The `CanvasXpress` object defines what a chart should contain and how it should be formatted, but rendering the chart
  is performed by the functions `graph()` and `show_in_browser()`.

  To use `graph()` import it from `canvasxpress.plot` and then call it by passing a `CanvasXpress` object. For example, a
  Quarto, RMD, or Jupyter Notebook code chunk could be:

  ```python
  from random import random

  from canvasxpress.canvas import CanvasXpress
  from canvasxpress.plot import graph

  graph(
      CanvasXpress(
          data={
              "y": {
                  "data": [
                      [random() % 100 for i in range(20)]
                  ],
                  "vars": ["A"],
              }
          },
          config={
              "background": "rgb(255,255,255)",
              "colorScheme": "CanvasXpress",
              "graphOrientation": "vertical",
              "graphType": "Area",
              "objectBorderColor": False,
              "plotBox": False,
              "plotBoxColor": "rgb(204,204,204)",
              "showLegend": False,
              "showLegendBorder": True,
              "smpLabelRotate": 90,
              "smpTitle": "time",
              "xAxis": ["A"],
              "xAxisTickRightShow": False,
              "yAxisTickTopShow": False
          },
          width=609,
          height=609
      )
  )
  ```

  Some application frameworks, such as _Shiny for Python_ and _Plotly Dash_, expect an object to be rendered to the
  framework as part of the reactive flow.  In these contexts, the `graph()` function creates an appropriate object
  and returns it.  That value can be assigned to a variable to be returned at a later point in the code, or be
  immediately returned.  See the Shiny for Python and Dash examples for specific usage.

  `show_in_browser()` is similar to `graph()` except that it opens a browser window on the local system and displays the
  chart.  It's used to facilitate learning and debugging.

  `graph()` does a good job of determining the runtime context to choose how the chart should be rendered, but in the
  case installed packages or runtime configurations confuse the function an environment variable can be set to override
  how `graph()` performs the rendering.  Set `CANVASXPRESS_TARGET_CONTEXT` to be one of these values as appropriate for
  this situation (and don't forget to pip install the necessary package support):

  - rstudio
  - shiny
  - jupyter
  - dash
  - streamlit
  - browser

  For example:

  ```python
  from os import environ
  environ["CANVASXPRESS_TARGET_CONTEXT"] = "jupyter"
  ```

  or via a shell (_bash_ example provided):

  ```shell
  export CANVASXPRESS_TARGET_CONTEXT="jupyter"
  ```



  CanvasXpress for Python generates JavaScript that assumes use of the latest available edition of CanvasXpress for
  JavaScript, but it can be set to use a specific edition.

  Review this site for available versions:
  https://cdnjs.com/libraries/canvasXpress

  The desired version is expressed as a `str`.  Prior to generating a CanvasXpress chart use the following code to set
  the edition that shall be used:

  ```python
  from canvasxpress.canvas import CanvasXpress
  CanvasXpress.set_cdn_edition("48.3")  # Or whatever available version is desired.
  ```

  To use the default edition once again during the runtime session set the value to `None`.

  This is the best way to assure a specific chart behavior for production application releases; however, once set any
  new JavaScript edition features or fixes will not be available until the code is removed or a different version is set.



  Generally speaking, a `CanvasXpress` object accepts the following parameters:



  `render_to` is a `str` value that identifies the chart when rendered into HTML.  JavaScript functions can use this ID
  to access the chart and perform CanvasXpress operations within the browser.  Omitting `render_to` or setting it to
  `None` will make the `CanvasXpress` object assume an anonymous mode in which a new GUID will be generated each time
  `graph()` is called.  If the chart will not be maniluated using JavaScript in the browser it is fine for charts to be anonymous.

  __NOTE:__ React environments regularly destroy and rebuild objects as the page is updated.  In these environments it is
  possible for the timing of object destruction and JavaScript execution to cause a crash.  The best defense is to either
  use anonymous mode, or if an ID must be known then a unique identifier should be set each time `graph()` is called.  In
  this manner an ID for a chart in the middle of being recreated is never referenced.  For example:

  ```python
  chart = CanvasXpress(...)
  chart.render_to = str(guid4()).replace("-", "_")
  return graph(chart)
  ```

  Plotly's Dash framework uses React, and Dash applications should consider using only anonymous charts or assigning
  unique values as the ID similar to the above code.  Shiny for Python does not seem to suffer from this challenge.



  `data` sets the chart's data and metadata.  This is an involved topic, and the [introductory article](https://www.linkedin.com/pulse/introducing-canvasxpress-python-todd-brett-hew0f/?trackingId=G8kTE2QyRH%2BrcVSzxJc8Hg%3D%3D)
  is an excellent read to understand how data should be shaped.  In general, data will be a `dict`, Web URL, or `str`.

  Data dict example:

  ```python
  data_for_use_in_chart = {
      "y": {
          "data": [
              [random() % 100 for i in range(20)]
          ],
          "vars": ["A"],
      }
  }
  ```

  Data URL example:

  ```python
  data_for_use_in_chart = "https://corgis-edu.github.io/corgis/datasets/csv/state_demographics/state_demographics.csv"
  ```

  Data text (CSV) example:

  ```python
  data_for_use_in_chart = """
  "State","Population.Population Percent Change","Population.2014 Population"
  "Connecticut","-10.2","3605944"
  "Delaware","8.4","989948"
  """
  ```



  `config` describes the chart's formatting.  It is a `dict` in which properties are specified and assigned values. All
  of the values must be compliant with Python's `json.dumps()` function.  For example:

  ```python
  config={
      "background": "rgb(255,255,255)",
      "colorScheme": "CanvasXpress",
      "graphOrientation": "vertical",
      "graphType": "Area",
      "objectBorderColor": False,
      "plotBox": False,
      "plotBoxColor": "rgb(204,204,204)",
      "showLegend": False,
      "showLegendBorder": True,
      "smpLabelRotate": 90,
      "smpTitle": "time",
      "xAxis": ["A"],
      "xAxisTickRightShow": False,
      "yAxisTickTopShow": False
  },
  ```



  `width` and `height` specify the chart's dimensions as pixels.  If ommitted the CanvasXpress edition active for the
  browser will assign default values, such as 500px by 500px.



  CanvasXpress provides support for Javascript events via hook functions that are called when events occur, such as mouse
  movement or clicks. These events are supported via the canvasxpress.js sub-package. `CXEvent` objects hold the
  Javascript instructions for Web events.  An example event for graph clicks with popup information is:

  ```python
  from canvasxpress.js.function import CXEvent

  CXEvent(
      id="click",
      script="""
      var s = 'click on var ' + o.y.vars[0] + ' and smp ' + o.y.smps[0];
      t.showInfoSpan(e, s);
      """
  )
  ```

  The general JavaScript template of a CanvasXpress Javascript hook function is:

  ```javascript
  function (o, e, t) {
      // script logic goes here
  };
  ```

  `CXEvent` objects can be provided as a single object or as a list.  Here's an example of an event the provides
  additional information about chart data upon a user click:

  ```python
  from canvasxpress.canvas import CanvasXpress
  from canvasxpress.plot import graph
  from canvasxpress.js.function import CXEvent

  graph(
      CanvasXpress(
          render_to="example_chart",
          data={
              "y": {
                  "vars": ["Gene1"],
                  "smps": ["Smp1", "Smp2", "Smp3"],
                  "data": [[10, 35, 88]]
              }
          },
          config={
              "graphOrientation": "vertical",
              "graphType": "Bar",
              "showLegend": False,
              "smpLabelRotate": 90,
              "smpTitle": "Samples",
              "theme": "CanvasXpress",
              "title": "Bar Graph Title",
              "xAxisTitle": "Value"
          },
          events=[
              CXEvent(
                  id="click",
                  script="""
                  var s = 'click on var ' + o.y.vars[0] + ' and smp ' + o.y.smps[0];
                  t.showInfoSpan(e, s);
                  """
              ),
          ]
      )
  )
  ```



  CanvasXpress for Python can also convert to and from reproducible JSONs usable with the JavaScript and R editions of the
  library.  `convert_to_reproducible_json` takes an existing CanvasXpress object and provides a `str` copy of the JSON,
  which can then be logged for debugging or saved to disk for use elsewhere.  `convert_from_reproducible_json` does the
  opposite by taking a reproducible JSON `str` and providing the CanvasXpress object equivalent.

  _Note: Events are not currently supported for import.  This will be provided in a future edition.  Export supports events._

  For example, do the following to see the JSON in the Python console:

  ```python
  from canvasxpress.canvas import CanvasXpress
  from canvasxpress.plot import convert_to_reproducible_json
  from canvasxpress.js.function import CXEvent

  print(
      convert_to_reproducible_json(
          CanvasXpress(
              render_to="example_chart",
              data={
                  "y": {
                      "vars": ["Gene1"],
                      "smps": ["Smp1", "Smp2", "Smp3"],
                      "data": [[10, 35, 88]]
                  }
              },
              config={
                  "graphOrientation": "vertical",
                  "graphType": "Bar",
                  "showLegend": False,
                  "smpLabelRotate": 90,
                  "smpTitle": "Samples",
                  "theme": "CanvasXpress",
                  "title": "Bar Graph Title",
                  "xAxisTitle": "Value"
              },
              events=[
                  CXEvent(
                      id="click",
                      script="""
                      var s = 'click on var ' + o.y.vars[0] + ' and smp ' + o.y.smps[0];
                      t.showInfoSpan(e, s);
                      """
                  ),
              ]
          )
      )
  )
  ```

  The console would display:

  ```text
  {
      "renderTo": "example_chart",
      "data": {"y": {"vars": ["Gene1"], "smps": ["Smp1", "Smp2", "Smp3"], "data": [[10, 35, 88]]}, "x": {}, "z": {}},
      "config": {"graphOrientation": "vertical", "graphType": "Bar", "showLegend": false, "smpLabelRotate": 90, "smpTitle": "Samples", "theme": "CanvasXpress", "title": "Bar Graph Title", "xAxisTitle": "Value"},
      "afterRender": [],
      "otherParams": {},
      "events": {'click': function(o, e, t){
                      var s = 'click on var ' + o.y.vars[0] + ' and smp ' + o.y.smps[0];
                      t.showInfoSpan(e, s);
                      }},
      "width": 500,
      "height": 500
  }
  ```

  This text could be saved to a file, such as `example.json`, and then dragged onto a CanvasXpress chart in a browser
  to load the equivalent chart.  In fact, CanvasXpress for Python uses the core functionality producing JSON output to
  make charts available in contexts such as Dash and Shiny.





  The RStudio IDE's Viewer panel is now supported for rendering interactive charts in the Viewer!  When the `graph()`
  function is called it detects that RStudio is running and renders the chart in the Viewer instead of a document,
  such as for Quarto code chunks.  However, if the document is a Quarto or RMD file and the appropriate HTML (etc.)
  generation is performed then the CanvasXpress charts will be embedded in the generated output file as normal.



  Charts can be defined in scripts or a console session and then displayed using the default browser, assuming that a
  graphical browser with Javascript support is available on the host system.  To do so use the `show_in_browser()`
  function instead of graph()`.

  ```python
  from canvasxpress.canvas import CanvasXpress
  from canvasxpress.plot import show_in_browser

  if __name__ == "__main__":
      
      chart: CanvasXpress = CanvasXpress(
          data={
              "y": {
                  "vars": ["Gene1"],
                  "smps": ["Smp1", "Smp2", "Smp3"],
                  "data": [[10, 35, 88]]
              }
          },
          config={
              "graphType": "Bar"
          }
      )

      
      show_in_browser(chart)
  ```

  Upon running the example the following chart will be displayed on systems such as MacOS X, Windows, and Linux with
  graphical systems:

  <img src="https://raw.githubusercontent.com/docinfosci/canvasxpress-python/main/readme/examples/flask_bar_chart_basic.png" align="center" width="600"></a>



  [Shiny for Python](https://shiny.posit.co/py/) is a new dashboard framework inspired by the highly successful Shiny for
  R framework produced by Posit (formerly RStudio). This example shows how to create a basic Shiny for Python application
  using a CanvasXpress Shiny element.

  A basic Shiny for Python app provides a means by which:

  1. A local development server can be started
  1. A function can respond to input or draw an initial UI

  First install Shiny for Python and CanvasXpress for Python:

  ```terminal
  pip install shiny
  pip install canvasxpress[shiny]
  ```

  Then create a demo file, such as `app.py`, and insert:

  ```python
  from random import random

  from shiny import App, ui, render, reactive

  from canvasxpress.canvas import CanvasXpress
  from canvasxpress.render.shiny import output_canvasxpress
  from canvasxpress.plot import graph

  app_ui = ui.page_fluid(
      ui.row(
          ui.input_slider(
              "points_desired",
              "Points",
              min=0,
              max=100,
              value=0,
          ),
      ),
      ui.row(
          output_canvasxpress("chart_view"),
      )
  )


  def server(input, output, session):
      @render.ui
      @reactive.event(input.points_desired)
      def chart_view():
          return graph(
              CanvasXpress(
                  data={
                      "y": {
                          "data": [
                              [random() % 100 for i in range(input.points_desired())]
                          ],
                          "vars": ["A"],
                      }
                  },
                  config={
                      "background": "rgb(255,255,255)",
                      "colorScheme": "CanvasXpress",
                      "graphOrientation": "vertical",
                      "graphType": "Area",
                      "objectBorderColor": False,
                      "plotBox": False,
                      "plotBoxColor": "rgb(204,204,204)",
                      "showLegend": False,
                      "showLegendBorder": True,
                      "smpLabelRotate": 90,
                      "smpTitle": "time",
                      "xAxis": ["A"],
                      "xAxisTickRightShow": False,
                      "yAxisTickTopShow": False
                  },
                  width=500,
                  height=500
              )
          )


  app = App(app_ui, server)
  ```



  On the command line, execute:

  ```terminal
  shiny run --reload --launch-browser app.py
  ```

  And output similar to the following will be provided:

  ```terminal
  Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
  ```

  Browsing to `http://localhost:8000/` will result in a page with a CanvasXpress chart, which is being hosted by the Shiny
  for Python framework:

  <img src="https://raw.githubusercontent.com/docinfosci/canvasxpress-python/main/readme/examples/shiny_chart_example.png" align="center" width="600"></a>

  Congratulations!  You have created a Shiny for Python CanvasXpress app!



  [Streamlit](https://streamlit.io) is a popular dashboard framework that is simplified compared to Dash and Shiny, but
  just as powerful in terms of reactivity and extensions. This example shows how to create a basic Streamlit application
  using a CanvasXpress Streamlit element.

  A basic Streamlit app provides a means by which:

  1. A local development server can be started
  1. A function can respond to a URL

  First install Streamlit and CanvasXpress for Python:

  ```terminal
  pip install streamlit
  pip install canvasxpress[streamlit]
  ```

  Then create a demo file, such as `app.py`, and insert:

  ```python
  import random

  import streamlit as st

  from canvasxpress.canvas import CanvasXpress
  from canvasxpress.plot import graph


  chord_chart = CanvasXpress(
      config={
          "graphOrientation": "vertical",
          "plotBox": True,
          "showLegend": False,
          "smpLabelRotate": 90,
          "smpTitle": "Samples",
          "theme": "CanvasXpress",
          "title": "Bar Graph Title",
          "xAxis": ["V1"],
          "xAxisTitle": "Value",
          "graphType": "Bar"
      },
      width=500,
      height=500
  )





  st.title('CanvasXpress in Streamlit!')


  column1, column2 = st.columns(2)


  column1.write(
      
      st.button("Generate New Data")
  )



  chord_chart.data = {
      "y": {
          "vars": ["V1"],
          "smps": ["S1", "S2", "S3"],
          "data": [
              [
                  random.randint(100, 10000),
                  random.randint(100, 10000),
                  random.randint(100, 10000),
              ]
          ]
      }
  }
  column2.write(
      
      graph(chord_chart)
  )
  ```



  On the command line, execute:

  ```terminal
  streamlit run app.py
  ```

  And output similar to the following will be provided:

  ```terminal
  Running on http://localhost:8501/ (Press CTRL+C to quit)
  ```

  Browsing to `http://localhost:8501/` will result in a page with a CanvasXpress chart, which is being hosted by the
  Streamlit framework:

  <img src="https://raw.githubusercontent.com/docinfosci/canvasxpress-python/main/readme/examples/streamlit_chart_basic.png" align="center" width="600"></a>

  Congratulations!  You have created a Streamlit CanvasXpress app!



  [Plotly Dash](https://dash.plotly.com/) is a popular dashboard framework similar to Shiny for Python or R. Dash
  applications are Web pages with widgets and elements facilitating the interactive presentation of information. This
  example shows how to create a basic Dash application using a CanvasXpress Dash element.



  A basic Dash app provides a means by which:

  1. A local development server can be started
  1. A function can respond to a URL

  First install Dash and CanvasXpress for Python:

  ```terminal
  pip install dash
  pip install canvasxpress[dash]
  ```

  Then create a demo file, such as `app.py`, and insert:

  ```python
  from random import random

  from dash import Dash, html

  from canvasxpress.canvas import CanvasXpress
  from canvasxpress.plot import graph

  g_app = Dash(__name__)

  colors = {
      "background": "#111111",
      "text": "rgb(127,219,255)",
  }


  g_app.layout = html.Div(
      style={"backgroundColor": colors["background"]},
      children=[
          html.H1(
              children="Hello Dash",
              style={"textAlign": "center", "color": colors["text"]},
          ),
          html.H2(
              children=(
                  "An Example of the Advanced CanvasXpress and CXDashElementFactory"
                  " Classes for Plotting a CanvasXpress Chart"
              ),
              style={"textAlign": "center", "color": colors["text"]},
          ),
          html.Div(
              id="chart-container",
              children=[
                  html.Div(
                      id="cx-container",
                      style={"textAlign": "center"},
                      children=graph(
                          CanvasXpress(
                              data={
                                  "y": {
                                      "data": [
                                          [random() % 100 for i in range(5)]
                                      ],
                                      "vars": ["A"],
                                  }
                              },
                              config={
                                  "background": "rgb(255,255,255)",
                                  "colorScheme": "CanvasXpress",
                                  "graphOrientation": "vertical",
                                  "graphType": "Area",
                                  "objectBorderColor": False,
                                  "plotBox": False,
                                  "plotBoxColor": "rgb(204,204,204)",
                                  "showLegend": False,
                                  "showLegendBorder": True,
                                  "smpLabelRotate": 90,
                                  "smpTitle": "time",
                                  "xAxis": ["A"],
                                  "xAxisTickRightShow": False,
                                  "yAxisTickTopShow": False
                              },
                              width=500,
                              height=500
                          )
                      ),
                  ),
              ],
          ),
      ],
  )

  if __name__ == "__main__":
      g_app.run_server(debug=True)
  ```



  On the command line, execute:

  ```terminal
  python3 app.py
  ```

  And output similar to the following will be provided:

  ```terminal
  Running on http://127.0.0.1:8050/ (Press CTRL+C to quit)
  ```

  Browsing to `http://127.0.0.1:8050/` will result in a page with a CanvasXpress chart, which is being hosted by the Dash
  framework:

  <img src="https://raw.githubusercontent.com/docinfosci/canvasxpress-python/main/readme/examples/dash_chart_basic.png" align="center" width="600"></a>

  Congratulations!  You have created a Plotly Dash CanvasXpress app!



  [Flask](https://palletsprojects.com/p/flask/) is a popular lean Web development framework for Python based applications.
  Flask applications can serve Web pages, RESTful APIs, and similar backend service concepts. This example shows how to
  create a basic Flask application that provides a basic Web page with a CanvasXpress chart composed using Python in the
  backend.

  The concepts in this example equally apply to other frameworks that can serve Web pages, such as Django and Tornado.



  A basic Flask app provides a means by which:

  1. A local development server can be started
  1. A function can respond to a URL

  First install Flask and CanvasXpress for Python:

  ```terminal
  pip install -U Flask canvasxpress
  ```

  Then create a demo file, such as `app.py`, and insert:

  ```python

  from flask import Flask

  app = Flask(__name__)


  @app.route('/')
  def canvasxpress_example():
      return "Hello!"
  ```

  On the command line, execute:

  ```terminal
  flask run
  ```

  And output similar to the following will be provided:

  ```terminal
  Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
  ```

  Browsing to `http://127.0.0.1:5000/` will result in a page with the text
  *Hello!*.



  CanvasXpress for Python can be used to define a chart with various attributes and then generate the necessary HTML and
  Javascript for proper display in the browser.

  Add a `templates` directory to the same location as the `app.py` file, and inside add a file
  called `canvasxpress_example.html`. Inside the file add:

  ```html

  <html>
  <head>
      <meta charset="UTF-8">
      <title>Flask CanvasXpress Example</title>

      <!-- 2. Include the CanvasXpress library -->
      <link
              href='https://www.canvasxpress.org/dist/canvasXpress.css'
              rel='stylesheet'
              type='text/css'
      />
      <script
              src='https://www.canvasxpress.org/dist/canvasXpress.min.js'
              type='text/javascript'>
      </script>

      <!-- 3. Include script to initialize object -->
      <script type="text/javascript">
          onReady(function () {
              {
                  {
                      canvas_source | safe
                  }
              }
          })
      </script>

  </head>
  <body>

  <!-- 1. DOM element where the visualization will be displayed -->
  {{canvas_element|safe}}

  </body>
  </html>
  ```

  The HTML file, which uses [Jinja syntax](https://palletsprojects.com/p/jinja/) achieves three things:

  1. Provides a location for a `<div>` element that marks where the chart will be placed.
  1. References the CanvasXpress CSS and JS files needed to illustrate and operate the charts.
  1. Provides a location for the Javascript that will replace the chart `<div>` with a working element on page load.

  Going back to our Flask app, we can add a basic chart definition with some data to our example function:

  ```python
  from flask import Flask, render_template
  from canvasxpress.canvas import CanvasXpress

  app = Flask(__name__)


  @app.route('/')
  def canvasxpress_example():
      
      chart: CanvasXpress = CanvasXpress(
          data={
              "y": {
                  "vars": ["Gene1"],
                  "smps": ["Smp1", "Smp2", "Smp3"],
                  "data": [[10, 35, 88]]
              }
          },
          config={
              "graphType": "Bar"
          }
      )

      
      html_parts: dict = chart.render_to_html_parts()

      
      return render_template(
          "canvasxpress_example.html",
          canvas_element=html_parts["cx_canvas"],
          canvas_source=html_parts["cx_js"]
      )
  ```



  Rerun the flask app on the command line and browse to the indicated IP and URL. A page similar to the following will be
  displayed:

  <img src="https://raw.githubusercontent.com/docinfosci/canvasxpress-python/main/readme/examples/flask_bar_chart_basic.png" align="center" width="600"></a>

  Congratulations!  You have created a Flask CanvasXpress app!


pkgId: 32843427da558138947add0e04896d3e0c3aa049dcc8dbeac85e3508cfaff4aa
name: python-capella-console-client-help
arch: noarch
version: 0.14.0
epoch: 0
release: 1
summary: Development documents and examples for capella-console-client
url: https://github.com/capellaspace/console-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-capella-console-client-0.14.0-1.src.rpm
location_href: Packages/python-capella-console-client-help-0.14.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/capella-console-client.svg)](https://pypi.org/project/capella-console-client/)
  [![License](https://img.shields.io/pypi/l/capella-console-client.svg)](#)
  [![CI](https://github.com/capellaspace/console-client/workflows/CI/badge.svg)](#)
  [![Coverage](https://coveralls.io/repos/github/capellaspace/console-client/badge.svg?branch=main)](https://coveralls.io/github/capellaspace/console-client)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/capella-console-client.svg)](https://pypi.org/project/capella-console-client/)
  [![Documentation](https://readthedocs.org/projects/capella-console-client/badge/?version=main)](https://capella-console-client.readthedocs.io)

  Python SDK for api.capellaspace.com (task, search, order, download)




  ```bash
  pip install capella-console-client
  ```



  * python >= 3.8, <4.0
  * `capella-console-client` requires an active account on [console.capellaspace.com](https://console.capellaspace.com/). Sign up for an account at [https://www.capellaspace.com/community/](https://www.capellaspace.com/community/).




  ![Quickstart](docs/images/quickstart.gif)

  ```python
  from capella_console_client import CapellaConsoleClient


  client = CapellaConsoleClient(
      verbose=True
  )


  stac_items = client.search(
      instrument_mode="spotlight",
      product_type__in=["SLC", "GEO"],
      collections=["capella-open-data"],
      limit=2
  )


  order_id = client.submit_order(items=stac_items, omit_search=True)


  product_paths = client.download_products(
      order_id=order_id,
      local_dir='/tmp',
      show_progress=True
  )
  ```




  The documentation for `capella-console-client` can be found [here](https://capella-console-client.readthedocs.io).


  starting with `capella-console-client>=0.8.0` the SDK ships with an interactive wizard-like CLI: `capella-console-wizard`


  ```
  pip install capella-console-client[wizard]
  ```


  ```
  capella-console-wizard --help
  ```

  see




  Please [open an issue](https://github.com/capellaspace/console-client/issues/new)
  with enough information for us to reproduce your problem.
  A [minimal, reproducible example](https://stackoverflow.com/help/minimal-reproducible-example)
  would be very helpful.



  Contributions are very much welcomed and appreciated. See [how to contribute](https://capella-console-client.readthedocs.io/en/main/pages/contributors.html) for more information.



  • Licensed under the [MIT License](https://github.com/capellaspace/console-client/blob/master/LICENSE) • Copyright 2024 • Capella Space •


pkgId: fbca711a6bd7d5c0f5e1ff3ed9bcdcaf99f1836e111f05d8feec6b6212cdd4ae
name: python-capellambse-help
arch: noarch
version: 0.6.11
epoch: 0
release: 1
summary: Development documents and examples for capellambse
url: https://github.com/DSD-DBS/py-capellambse
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-capellambse-0.6.11-1.src.rpm
location_href: Packages/python-capellambse-help-0.6.11-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/capellambse)
  ![Code QA](https://github.com/DSD-DBS/py-capellambse/actions/workflows/code-qa.yml/badge.svg)
  ![License: Apache-2.0](https://img.shields.io/github/license/dsd-dbs/py-capellambse)
  ![REUSE status](https://api.reuse.software/badge/github.com/DSD-DBS/py-capellambse)
  ![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)
  ![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)
  *A Python 3 headless implementation of the Capella modeling tool*


pkgId: f0e003db735ef61df3cf2e0bcaafef5ba36e5e421b3d0c5491fb36ea201f673f
name: python-caracara-help
arch: noarch
version: 0.9.2
epoch: 0
release: 1
summary: Development documents and examples for caracara
url: https://pypi.org/project/caracara/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-caracara-0.9.2-1.src.rpm
location_href: Packages/python-caracara-help-0.9.2-1.noarch.rpm
checksum_type: sha256
description:
  ![CrowdStrike Falcon](https://raw.githubusercontent.com/CrowdStrike/falconpy/main/docs/asset/cs-logo.png) [![Twitter URL](https://img.shields.io/twitter/url?label=Follow%20%40CrowdStrike&style=social&url=https%3A%2F%2Ftwitter.com%2FCrowdStrike)](https://twitter.com/CrowdStrike)<br/>





  <!--
  ![PyPI - Status](https://img.shields.io/pypi/status/caracara)
  [![Pylint](https://github.com/CrowdStrike/caracara/actions/workflows/pylint.yml/badge.svg)](https://github.com/CrowdStrike/caracara/actions/workflows/pylint.yml)
  [![Flake8](https://github.com/CrowdStrike/caracara/actions/workflows/flake8.yml/badge.svg)](https://github.com/CrowdStrike/caracara/actions/workflows/flake8.yml)
  [![Bandit](https://github.com/CrowdStrike/caracara/actions/workflows/bandit.yml/badge.svg)](https://github.com/CrowdStrike/caracara/actions/workflows/bandit.yml)
  [![CodeQL](https://github.com/CrowdStrike/caracara/actions/workflows/codeql.yml/badge.svg)](https://github.com/CrowdStrike/caracara/actions/workflows/codeql.yml)
  -->
  [![PyPI](https://img.shields.io/pypi/v/caracara)](https://pypi.org/project/caracara/)
  ![OSS Lifecycle](https://img.shields.io/osslifecycle/CrowdStrike/caracara)

  A friendly wrapper to help you interact with the CrowdStrike Falcon API. Less code, less fuss, better performance, and full interoperability with [FalconPy](https://github.com/CrowdStrike/falconpy/).

  - [Features](#features)
  - [Installation](#installation-instructions)
  - [Basic Usage](#basic-usage-example)
  - [Examples](#examples-collection)
  - [Documentation](#documentation)
  - [Contributing](#contributing)



  A few of the developer experience enhancements provided by the Caracara toolkit include:
  | Feature | Details |
  | :---  | :--- |
  | __Automatic pagination with concurrency__ | Caracara will handle all request pagination for you, so you do not have to think about things like batch sizes, batch tokens or parallelisation. Caracara will also multithread batch data retrieval requests where possible, dramatically reducing data retrieval times for large datasets such as host lists. |
  | __Friendly to your IDE (and you!)__ | Caracara is written with full support for IDE autocomplete in mind. We have tested autocomplete in Visual Studio Code and PyCharm, and will accept issues and patches for more IDE support where needed. Furthermore, all code, where possible, is written with type hints so you can be confident in parameters and return values. |
  | __Logging__ | Caracara is built with the in-box `logging` library provided with Python 3. Simply set up your logging handlers in your main code file, and Caracara will forward over `debug`, `info` and `error` logs as they are produced. Note that the `debug` logs are very verbose, and we recommend writing these outputs to a file as opposed to the console when retrieving large amounts of lightly filtered data. |
  | __Real Time Response (RTR) batch session abstraction__ | Caracara provides a rich interface to RTR session batching, allowing you to connect to as many hosts as possible. Want to download a specific file from every system in your Falcon tenant? Caracara will even extract it from the `.7z` container for you. |
  | __Rich and detailed sample code__ | Every module of Caracara comes bundled with executable, fully configurable code samples that address frequent use cases. All samples are built around a common structure allowing for code reuse and easy reading. Just add your API credentials to `config.yml`, and all samples will be ready to go. |
  | __Simple filter syntax__ | Caracara provides an object-orientated Falcon Query Language (FQL) generator. The `FalconFilter` object lets you specify filters such as `Hostname`, `OS` and `Role`, automatically converting them to valid FQL. Never write a FQL filter yourself again! |
  | __Single authentication point of entry__ | Authenticate once and have access to every module. |
  | __100% FalconPy compatibility__ | Caracara is built on FalconPy, and can even be configured with a FalconPy `OAuth2` object via the `auth_object` constructor parameter, allowing you to reuse FalconPy authentication objects across Caracara and FalconPy. Authenticate once with FalconPy, and access every feature of FalconPy and Caracara. |



  Caracara supports all major Python packaging solutions. Instructions for [Poetry](https://python-poetry.org) and [Pip](https://pypi.org/project/pip/) are provided below.

  Caracara supports Python versions that are still supported by the Python Software Foundation, i.e., **Python 3.8 and up**.

  <details>
  <summary><h3>Installing Caracara from PyPI using Poetry (Recommended!)</h3></summary>



  ```shell
  poetry add caracara
  ```



  ```shell
  poetry update caracara
  ```



  ```shell
  poetry remove caracara
  ```
  </details>

  <details>
  <summary><h3>Installing Caracara from PyPI using Pip</h3></summary>



  ```shell
  python3 -m pip install caracara
  ```



  ```shell
  python3 -m pip install caracara --upgrade
  ```



  ```shell
  python3 -m pip uninstall caracara
  ```

  </details>



  ```python
  """List Windows devices.

  This example will use the API credentials provided as keywords to list the
  IDs and hostnames of all systems within your Falcon tenant that run Windows.
  """

  from caracara import Client

  client = Client(
      client_id="12345abcde",
      client_secret="67890fghij",
  )

  filters = client.FalconFilter()
  filters.create_new_filter("OS", "Windows")

  response_data = client.hosts.describe_devices(filters)
  print(f"Found {len(response_data)} devices running Windows")

  for device_id, device_data in response_data.items():
      hostname = device_data.get("hostname", "Unknown Hostname")
      print(f"{device_id} - {hostname}")
  ```

  You can also leverage the built in context manager and environment variables.

  ```python
  """List stale sensors.

  This example will use the API credentials set in the environment to list the
  hostnames and IDs of all systems within your Falcon tenant that have not checked
  into your CrowdStrike tenant within the past 7 days.

  This is determined based on the filter LastSeen less than or equal (LTE) to 7 days ago (-7d).
  """

  from caracara import Client


  with Client(client_id="${CLIENT_ID_ENV_VARIABLE}", client_secret="${CLIENT_SECRET_ENV_VARIABLE}") as client:
      filters = client.FalconFilter()
      filters.create_new_filter("LastSeen", "-7d", "LTE")
      response_data = client.hosts.describe_devices(filters)

  print(f"Found {len(response_data)} stale devices")

  for device_id, device_data in response_data.items():
      hostname = device_data.get("hostname", "Unknown Hostname")
      print(f"{device_id} - {hostname}")
  ```



  Each API wrapper is provided alongside example code. Cloning or downloading/extracting this repository allows you to execute examples directly.

  Using the examples collection requires that you install our Python packaging tool of choice, [Poetry](https://python-poetry.org). Please refer to the Poetry project's [installation guide](https://python-poetry.org/docs/#installation) if you do not yet have Poetry installed.

  Once Poetry is installed, make sure you run `poetry install` within the root repository folder to set up the Python virtual environment.

  To configure the examples, first copy `examples/config.example.yml` to `examples/config.yml`. Then, add your API credentials and example-specific settings to `examples/config.yml`. Once you have set up profiles for each Falcon tenant you want to test with, execute examples using one of the two options below.



  There are two ways to use Poetry to execute the examples.

  <details>
  <summary><h4>Executing from a Poetry Shell</h4></summary>

  The `poetry shell` command will enter you into the virtual environment. All future commands will run within the Caracara virtual environment using Python 3, until you run the `deactivate` command.

  ```shell
  poetry shell
  examples/get_devices/list_windows_devices.py
  ```

  </details>

  <details>
  <summary><h4>Executing without Activating the Virtual Environment</h4></summary>

  If you do not want to enter the Caracara virtual environment (e.g., because you are using your system's installation of Python for other purposes), you can use the `poetry run` command to temporarily invoke the virtual environment for one-off commands.

  ```shell
  poetry run examples/get_devices/list_windows_devices.py
  ```

  All examples are also configured in the `pyproject.toml` file as scripts, allowing them to be executed simply.

  ```shell
  poetry run stale-sensors
  ```

  > To get a complete list of available examples, execute the command `util/list-examples.sh` from the root of the repository folder.

  </details>



  __*Coming soon!*__



  Interested in taking part in the development of the Caracara project? Start [here](CONTRIBUTING.md).



  Simple! We like birds at CrowdStrike, so what better bird to name a Python project after one that eats just about anything, including snakes :)


pkgId: ac67969840d795730b6138e2a5f175ff7f916961dfc51d42383ef73dd4dbd61d
name: python-card-creator-utils-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for card-creator-utils
url: https://github.com/simonghrt/card-creator-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-card-creator-utils-0.1.0-1.src.rpm
location_href: Packages/python-card-creator-utils-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A utility package for creating cards with images and text.



  ```bash
  pip install card-creator-utils
  ```



  ```python
  from card_creator_utils import create_card

  create_card("Hello, World!", "image.png", "output.png")
  ```



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


pkgId: f0f56f8e0622a4375c68b785637d3c7420ffef9eab62752475b8460e495b34c1
name: python-cardanomsg-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for cardanomsg
url: https://github.com/primaryobjects/cardanomsg
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cardanomsg-0.1.1-1.src.rpm
location_href: Packages/python-cardanomsg-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Send ADA with a message in the metadata using the Cardano blockchain.



  You can install the module using pip:

  ```sh
  pip install cardanomsg
  ```



  A [BlockFrost](https://blockfrost.io/) API account is required *(to prevent needing to run the blockchain locally on your PC)*.

  ```python
  from cardanomsg.transaction import send_ada_message

  blockfrost_project_id = "your_blockfrost_project_id"
  skey_path_name = "path_to_your_secret_json_key_file"
  recipient_address = "your_recipient_address"

  transaction_hash = send_ada_message(blockfrost_project_id, skey_path_name, recipient_address, 1000000, "Hello World")
  ```



  You can view the message on the blockchain using Cardanoscan.

  https://preview.cardanoscan.io/transaction/{transaction_hash}?tab=metadata

  Here is an example of the output:

  ```
  Summary | UTXOs | Metadata (1)

  Metadata Hash: 12345abcdefg606ab2b5f01298abxyz848e45187cf2c798ab389e6abcdefg
  Public Label: 1
  Value: "Hello World"
  ```



  The secret key for the sender is [generated](https://github.com/primaryobjects/cardano-tutorial/blob/main/generate.py) by pycardano. The format contains the following:

  ```json
  {
    "type": "PaymentSigningKeyShelley_ed25519",
    "description": "Payment Signing Key",
    "cborHex": "<SENDER_SECRET_KEY>"
  }
  ```



  MIT



  Kory Becker
  http://primaryobjects.com


pkgId: e70cb38c69677d1dcb2b29f5c40e86d6e1bc61d0be426db858b1c36741e2f968
name: python-cars-forge-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for cars-forge
url: https://github.com/carsdotcom/cars-forge/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cars-forge-1.1.1-1.src.rpm
location_href: Packages/python-cars-forge-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Forge is a Python-based command-line tool that starts a single or cluster of EC2 instances, and runs the required scripts on these instances. Forge can be used by anyone to create their own environment where they can do anything like develop products, analyze data, host interactive dashboards, or run production workloads on terabytes of RAM. Forge gives you complete flexibility while making it easy to run everything on spot EC2 instances saving you up to 90%.

  Install Forge with Pip:
  ```
  pip install cars-forge
  ```

  To get started using Forge you can follow the [Documentation](https://carsdotcom.github.io/cars-forge/).

  This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
  Please refer to the [Changelog](https://github.com/carsdotcom/cars-forge/blob/main/CHANGELOG.md) for information regarding the differences between versions of the project.


pkgId: 9538d08e4b1f52ee83eb3772bbaf3f7ecd42c7ecce2e213af84193c861876be3
name: python-casanovo-help
arch: noarch
version: 4.3.0
epoch: 0
release: 1
summary: Development documents and examples for casanovo
url: https://github.com/Noble-Lab/casanovo
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-casanovo-4.3.0-1.src.rpm
location_href: Packages/python-casanovo-help-4.3.0-1.noarch.rpm
checksum_type: sha256
description:
  **_De Novo_ Mass Spectrometry Peptide Sequencing with a Transformer Model**

  ![image](https://user-images.githubusercontent.com/32707537/152622912-ca87da20-a64c-4e3f-9ca1-721c6b0d9c64.png)

  Casanovo is a state-of-the-art deep learning tool designed for _de novo_ peptide sequencing.
  Powered by a transformer neural network, Casanovo "translates" peaks in MS/MS spectra into amino acid sequences with remarkable precision.
  Casanovo can be used for to find unexpected peptide sequences in any data-dependent acquisition, bottom-up tandem mass spectrometry dataset, and is particularly useful for immunopeptidomics, metaproteomics, paleoproteomics, venomics, or any setting in which you are interested in identifying peptides that may not be in your protein database.

  Why choose Casanovo?

  - Unmatched accuracy: Cutting-edge AI ensures precise and reliable peptide sequencing, even in challenging datasets.
  - Open-source innovation: Freely available and easy to integrate into existing visualization workflows.
  - Actively maintained: Join a growing network of researchers and developers to stay at the forefront of technology.


pkgId: 3f4d87606cdbd4f155971dbee6c9f3208e491530f982f174c5bbaab665e8b507
name: python-cat-win
arch: noarch
version: 1.10.2
epoch: 0
release: 1
summary: Simple Text-Processing and -Analytics Command Line Tool made in Python.
url: https://github.com/SilenZcience/cat_win
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cat-win-1.10.2-1.src.rpm
location_href: Packages/python-cat-win-1.10.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Unittests]](https://github.com/SilenZcience/cat_win/actions/workflows/unit_test.yml)
  [![Build-and-Check]](https://github.com/SilenZcience/cat_win/actions/workflows/package_test.yml)
  [![Coverage]](https://github.com/SilenZcience/cat_win/actions/workflows/coverage.yml)
  [![Tests]](https://github.com/SilenZcience/cat_win/actions/workflows/coverage.yml)
  [![GitHub-Issues]](https://github.com/SilenZcience/cat_win/issues)
  <!-- [![Compile-and-Push]](https://github.com/SilenZcience/cat_win/actions/workflows/build_executable.yml) -->
  This project copies the fundamental framework of the most essential command-line tools from Unix and translates its features to an OS Independent program using Python.</br>
  The project includes the basic functionality of subject areas like 'cat', 'echo', 'grep', 'ls', 'base64', 'xxd', ...
  Additionally, it includes an **editor** and a **hex editor**, as well as the feature to visualize data in various ways.
  It enables the user to manipulate the content of any given file, displaying meta-data, calculating checksums, converting hexadecimal, decimal, octal and binary numbers within any text, and much *much* <a href="#usage">more</a> ...
  This project does not aim to exactly replicate existing tools or their specific functionalities but rather to deliver essential core features in a user-friendly manner, providing straightforward access to helpful and valuable tools. It is purposefully designed to be lightweight and offer a streamlined, accessible solution to engage with powerful utilities by providing a practical and effective resource for users seeking core functionality without unnecessary overhead.
  <div id="made-with"></div>

  [![MadeWith-Python]](https://www.python.org/)
  [![Python-Version]](https://www.python.org/)
  <p align="right">(<a href="#top">↑back to top↑</a>)</p>
  <div id="getting-started"></div>
  <h2>
  	<a href="#">&#x200B;</a>
  	<a href="#getting-started" title="Noto Emoji, licensed under CC BY 4.0">
  		<img unselectable="on" pointer-events="none" src="https://fonts.gstatic.com/s/e/notoemoji/latest/1f680/512.gif" width="30" />
  	</a>
  	<b>Getting Started</b>
  </h2>
  <div id="prerequisites"></div>

  Using cat_win as a `Python Package` demands a Python-Interpreter (>= 3.6).
  Using cat_win as a `Binary Executable` demands no prerequisites, hereby the stand-alone executables are sufficient.
  <div id="installation"></div>

  [![CurrentVersion]](https://pypi.org/project/cat-win/)
  [![GitHub-Release]](https://github.com/SilenZcience/cat_win/releases)
  [![GitHub-Release-Date]](https://github.com/SilenZcience/cat_win/releases)
  `Python Package` </br>
  Simply install the python package (via [PyPI-cat_win](https://pypi.org/project/cat-win/)):
  ```console
  python -m pip install -U cat_win[clip]
  ```
  ```console
  python -m pip install -U cat_win
  ```
  cat_win uses the [pyperclip](https://pypi.org/project/pyperclip/) module by default. Should any problems occur, you can also use
  the [pyperclip3](https://pypi.org/project/pyperclip3/) or [pyclip](https://pypi.org/project/pyclip/) module.
  In this case simply don't install with `[clip]` and manually install the desired module yourself.
  On older Windows systems colored output may not be displayed correctly.
  In this case you can try to fix the problem by installing the cat_win-package with the optional color-fix `[cfix]` dependency.
  This fix will use the [colorama](https://pypi.org/project/colorama/) module
  which can also be installed after the fact to patch the problem.
  `Binary Executable` </br>
  **OR alternatively** you can use the (standalone) binary executable version:
  <div id="download"></div>
  Direct Download:
  </br>
  [Windows - __catw.exe__](https://raw.githubusercontent.com/SilenZcience/cat_win/binaries/bin/windows/catw.exe) </br>
  [Windows - __cats.exe__ (REPL)](https://raw.githubusercontent.com/SilenZcience/cat_win/binaries/bin/windows/cats.exe) </br>
  [Linux - __catw__](https://raw.githubusercontent.com/SilenZcience/cat_win/binaries/bin/linux/catw) </br>
  [Linux - __cats__ (REPL)](https://raw.githubusercontent.com/SilenZcience/cat_win/binaries/bin/linux/cats) </br>
  [MacOS - __catw__](https://raw.githubusercontent.com/SilenZcience/cat_win/binaries/bin/darwin/catw) </br>
  [MacOS - __cats__ (REPL)](https://raw.githubusercontent.com/SilenZcience/cat_win/binaries/bin/darwin/cats) </br>
  (compiled using PyInstaller) </br>
  It is recommended to add the file path(s) to your system-environment `PATH`-variables.
  > [!CAUTION]
  > **You should never trust any executable file!** Feel free to compile the package yourself (e.g. using [PyInstaller](https://pyinstaller.org/en/stable/)).\
  > You can verify the creation of the executable files yourself by reading the [source code](https://github.com/SilenZcience/cat_win/blob/main/cat_win/src/cat.py), checking the [origin](https://github.com/SilenZcience/cat_win/tree/binaries/bin) of the file and validating the corresponding [workflow](https://github.com/SilenZcience/cat_win/blob/main/.github/workflows/build_executable.yml) used.
  <p align="right">(<a href="#top">↑back to top↑</a>)</p>
  <div id="usage"></div>
  <h2>
  	<a href="#">&#x200B;</a>
  	<a href="#usage" title="Noto Emoji, licensed under CC BY 4.0">
  		<img unselectable="on" pointer-events="none" src="https://fonts.gstatic.com/s/e/notoemoji/latest/2699_fe0f/512.gif" width="30" />
  	</a>
  	<b>Usage</b>
  </h2>
  ```console
  > catw [FILE]... [OPTION]...
  > catw --help
  Concatenate FILE(s) to standard output.
  ```
  ```console
  > cats [OPTION]...
  > cats --help
  Interactively manipulate standard input.
  ```
  <div id="documentation"></div>
  <h3>
  	<a href="#">&#x200B;</a>
  	<a href="#documentation" title="Noto Emoji, licensed under CC BY 4.0">
  		<img unselectable="on" pointer-events="none" src="https://fonts.gstatic.com/s/e/notoemoji/latest/1f4a1/512.gif" width="25" />
  	</a>
  	<b>Documentation</b>
  </h3>
  > [!TIP]
  > 👉 A detailed [Documentation](https://github.com/SilenZcience/cat_win/blob/main/DOCUMENTATION.md) of all **Parameters**, **Configurations** and **General Usage** has moved to another File.\
  > Read about specific **Arguments & Options** [here](https://github.com/SilenZcience/cat_win/blob/main/DOCUMENTATION.md#arguments--options).
  <div id="examples"></div>

  <details>
     <summary><b>📂 Images 📂</b></summary>
     </br>
     <p float="left">
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew1.png" width="49%"/>
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew2.png" width="49%"/>
     </p>
     <p float="left">
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew3.png" width="49%"/>
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew4.png" width="49%"/>
     </p>
     <p float="left">
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew5.png" width="49%"/>
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew6.png" width="49%"/>
     </p>
     <p float="left">
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew7.png" width="49%"/>
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew8.png" width="49%"/>
     </p>
     <p float="left">
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examplew9.png" width="49%"/>
     </p>
     - - - -
     <p float="left">
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examples1.png" width="49%"/>
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examples2.png" width="49%"/>
     </p>
     <p float="left">
        <img src="https://raw.githubusercontent.com/SilenZcience/cat_win/main/img/examples3.png" width="49%"/>
     </p>
  </details>
  </br>
  ```py
  > echo "Hello World :)" | catw - [6:] | catw - [::-1] -ln
  1) [8] ): dlroW
  ```
  - - - -
  ```py
  > cats --eval --dec
  > >>> 0xF * 5
  75 [Bin: 0b1001011, Oct: 0o113, Hex: 0x4b]
  > >>> ...
  ```
  <p align="right">(<a href="#top">↑back to top↑</a>)</p>
  <div id="changelog"></div>
  <h2>
  	<a href="#">&#x200B;</a>
  	<a href="#changelog" title="Noto Emoji, licensed under CC BY 4.0">
  		<img unselectable="on" pointer-events="none" src="https://fonts.gstatic.com/s/e/notoemoji/latest/270f_fe0f/512.gif" width="30" />
  	</a>
  	<b>Changelog</b>
  </h2>
  > [!NOTE]
  > Take a look at the [Changelog](https://github.com/SilenZcience/cat_win/blob/main/CHANGELOG.md) file.
  <div id="license"></div>
  <h2>
  	<a href="#">&#x200B;</a>
  	<a href="#license" title="Noto Emoji, licensed under CC BY 4.0">
  		<img unselectable="on" pointer-events="none" src="https://fonts.gstatic.com/s/e/notoemoji/latest/2757/512.gif" width="30" />
  	</a>
  	<b>License</b>
  </h2>
  <a href="https://github.com/SilenZcience/cat_win/blob/main/LICENSE" alt="License">
     <img src="https://img.shields.io/pypi/l/cat_win" align="right">
  </a>
  > [!IMPORTANT]
  > This software is provided "as is," **without warranty** of any kind. There are **no guarantees** of its functionality or suitability for any purpose. Use at your own risk—**No responsibility** for any issues, damages, or losses that may arise from using this software are taken.
  This project is licensed under the MIT License - see the [LICENSE](https://github.com/SilenZcience/cat_win/blob/main/LICENSE) file for details
  <div id="contact"></div>
  <h2>
  	<a href="#">&#x200B;</a>
  	<a href="#contact" title="Noto Emoji, licensed under CC BY 4.0">
  		<img unselectable="on" pointer-events="none" src="https://fonts.gstatic.com/s/e/notoemoji/latest/1f4ab/512.gif" width="30" />
  	</a>
  	<b>Contact</b>
  </h2>
  > **SilenZcience** <br/>
  [![GitHub-SilenZcience][GitHub-SilenZcience]](https://github.com/SilenZcience)
  [OS-Windows]: https://img.shields.io/badge/os-windows-green?label=OS
  [OS-Linux]: https://img.shields.io/badge/os-linux-green?label=OS
  [OS-MacOS]: https://img.shields.io/badge/os-macOS-green?label=OS
  [Unittests]: https://github.com/SilenZcience/cat_win/actions/workflows/unit_test.yml/badge.svg?branch=dev
  [Build-and-Check]: https://github.com/SilenZcience/cat_win/actions/workflows/package_test.yml/badge.svg?branch=dev
  [Compile-and-Push]: https://github.com/SilenZcience/cat_win/actions/workflows/build_executable.yml/badge.svg?branch=dev
  [Coverage]: https://raw.githubusercontent.com/SilenZcience/cat_win/badges/badges/badge-coverage.svg
  [Tests]: https://raw.githubusercontent.com/SilenZcience/cat_win/badges/badges/badge-tests.svg
  [GitHub-Last-Commit]: https://img.shields.io/github/last-commit/SilenZcience/cat_win/dev
  [GitHub-Issues]: https://img.shields.io/github/issues/SilenZcience/cat_win
  [GitHub-Release]: https://img.shields.io/github/v/release/SilenZcience/cat_win?label=Github
  [GitHub-Release-Date]: https://img.shields.io/github/release-date/SilenZcience/cat_win?label=Release%20Date
  [Github-Stars]: https://img.shields.io/github/stars/SilenZcience/cat_win?style=flat&color=yellow
  [Github-Forks]: https://img.shields.io/github/forks/SilenZcience/cat_win?style=flat&color=purple
  [Github-Watchers]: https://img.shields.io/github/watchers/SilenZcience/cat_win?style=flat&color=purple
  [MadeWith-Python]: https://img.shields.io/badge/Made%20with-Python-brightgreen
  [Python-Version]: https://img.shields.io/badge/Python-3.6%20--%203.13%20%7C%20pypy--3.6%20--%20pypy--3.10-blue
  <!-- https://img.shields.io/badge/Python-3.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%20pypy--3.7%20%7C%20pypy--3.8%20%7C%20pypy--3.9%20%7C%20pypy--3.10-blue -->
  [CurrentVersion]: https://img.shields.io/pypi/v/cat_win?label=PyPI
  [License]: https://img.shields.io/pypi/l/cat_win
  [GitHub-SilenZcience]: https://img.shields.io/badge/GitHub-SilenZcience-orange


pkgId: ced2c30c2d621b16835aaf7e68bbf8e6a06512daaa6ad978e62ded923971f6b4
name: python-catalystwan-help
arch: noarch
version: 0.40.0
epoch: 0
release: 1
summary: Development documents and examples for catalystwan
url: https://github.com/cisco-en-programmability/catalystwan-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-catalystwan-0.40.0-1.src.rpm
location_href: Packages/python-catalystwan-help-0.40.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="#"><img src="docs/images/catalystwan.svg" alt="Cisco Catalyst WAN SDK Logo" style="height:150px" />
  </p>

  [![Python-Supported](https://img.shields.io/static/v1?label=Python&logo=Python&color=3776AB&message=3.8%20|%203.9%20|%203.10%20|%203.11%20|%203.12)](https://www.python.org/)

  Cisco Catalyst WAN SDK is a package for creating simple and parallel automatic requests via official SD-WAN Manager API. It is intended to serve as a multiple session handler (provider, provider as a tenant, tenant). The library is not dependent on environment which is being run in, you just need a connection to any SD-WAN Manager.



  Welcome to the Cisco Catalyst WAN SDK!

  We are thrilled to announce that Cisco Catalyst WAN SDK is now available in early beta. This is an exciting step forward in enabling developers to harness the full potential of Cisco's networking solutions.  Please be aware that, as an early beta release, this version of the SDK is still undergoing development and testing. As such, it is provided "as is" and support to address any issues are limited and best effort.


  We encourage developers to explore and test the SDK's capabilities, but please exercise caution when using it in production environments.  We are dedicated to improving the Cisco Catalyst WAN SDK and we value your input. Your feedback is crucial to us-it will guide us in refining and enhancing the SDK to better meet your needs.
  To report any issues, share your insights, or suggest improvements, please visit our Issues page on GitHub or reach out to us through the provided communication channels.

  Thank you for being a part of our development journey!


  ```console
  pip install catalystwan
  ```


  In order to execute SDK APIs **ManagerSession** needs to be created. The fastest way to get started is to use `create_manager_session()` method which configures session, performs authentication for given credentials and returns **ManagerSession** instance in operational state. **ManagerSession** provides a collection of supported APIs in `api` instance variable.
  Please check example below:

  ```python
  from catalystwan.session import create_manager_session

  url = "example.com"
  username = "admin"
  password = "password123"

  with create_manager_session(url=url, username=username, password=password) as session:
      devices = session.api.devices.get()
      print(devices)
  ```

  **ManagerSession** extends [requests.Session](https://requests.readthedocs.io/en/latest/user/advanced/#session-objects) so all functionality from [requests](https://requests.readthedocs.io/en/latest/) library is avaiable to user, it also implements python [contextmanager](https://docs.python.org/3.8/library/contextlib.html#contextlib.contextmanager) and automatically frees server resources on exit.

  <details>
      <summary> <b>Configure Manager Session before using</b> <i>(click to expand)</i></summary>

  It is possible to configure **ManagerSession** prior sending any request.

  ```python
  from catalystwan.session import ManagerSession
  from catalystwan.vmanage_auth import vManageAuth

  url = "example.com"
  username = "admin"
  password = "password123"


  auth = vManageAuth(username, password)
  session = ManagerSession(url=url, auth=auth)

  session.login()
  session.get("/dataservice/device")
  session.close()
  ```
  When interacting with the SDWAN Manager API without using a context manager, it's important
  to manually execute the `close()` method to release the user session resource.
  Ensure that the `close()` method is called after you have finished using the session to maintain optimal resource management and avoid potential errors.

  </details>

  <details>
      <summary> <b>Login as Tenant</b> <i>(click to expand)</i></summary>

  Tenant domain needs to be provided in url together with Tenant credentials.

  ```python
  from catalystwan.session import create_manager_session

  url = "tenant.example.com"
  username = "tenant_user"
  password = "password123"

  with create_manager_session(url=url, username=username, password=password) as session:
      print(session.session_type)
  ```

  </details>

  <details>
      <summary> <b>Login as Provider-as-Tenant</b> <i>(click to expand)</i></summary>

  Tenant `subdomain` needs to be provided as additional argument together with Provider credentials.

  ```python
  from catalystwan.session import create_manager_session

  url = "example.com"
  username = "provider"
  password = "password123"
  subdomain = "tenant.example.com"

  with create_manager_session(url=url, username=username, password=password, subdomain=subdomain) as session:
      print(session.session_type)
  ```

  </details>

  <details>
      <summary> <b>Login using Api Gateway</b> <i>(click to expand)</i></summary>

  ```python
  from catalystwan.session import create_apigw_session

  with create_apigw_session(
      url="example.com",
      client_id="client_id",
      client_secret="client_secret",
      org_name="Org-Name",
      username="user",
      mode="user",
      token_duration=10,
  ) as session:
      devices = session.api.devices.get()
      print(devices)
  ```
  </details>

  <details>
      <summary> <b>Threading</b> <i>(click to expand)</i></summary>

  ```python
  from threading import Thread
  from catalystwan.session import ManagerSession
  from catalystwan.vmanage_auth import vManageAuth
  from copy import copy

  def print_devices(manager: ManagerSession):
      
      with manager.login() as session:
          print(session.api.devices.get())

  if __name__ =="__main__":

      
      auth = vManageAuth(username="username", password="password")
      
      manager = ManagerSession(base_url="https://url:port", auth=auth)

      
      t1 = Thread(target=print_devices, args=(manager,))
      t2 = Thread(target=print_devices, args=(copy(manager),))
      t3 = Thread(target=print_devices, args=(copy(manager),))

      t1.start()
      t2.start()
      t3.start()

      t1.join()
      t2.join()
      t3.join()

      print("Done!")
  ```
  Threading can be achieved by using a shared auth object with sessions in each thread. As `ManagerSession` is not guaranteed to be thread-safe, it is recommended to create one session per thread. `ManagerSession` also comes in with a default `RequestLimiter`, which limits the number of concurrent requests to 50. It keeps `ManagerSession` from overloading the server and avoids HTTP 503 and HTTP 429 errors.
  If you wish to modify the limit, you can pass a modified `RequestLimiter` to `ManagerSession`:
  ```python
  from catalystwan.session import ManagerSession
  from catalystwan.vmanage_auth import vManageAuth
  from catalystwan.request_limiter import RequestLimiter

  auth = vManageAuth(username="username", password="password")
  limiter = RequestLimiter(max_requests=30)
  manager = ManagerSession(base_url="https://url:port", auth=auth, request_limiter=limiter)
  ```
  </details>


  All examples below assumes `session` variable contains logged-in [Manager Session](#Manager-Session) instance.

  <details>
      <summary> <b>Get devices</b> <i>(click to expand)</i></summary>

  ```python
  devices = session.api.devices.get()
  ```

  </details>

  <details>
      <summary> <b>Admin Tech</b> <i>(click to expand)</i></summary>

  ```Python
  admin_tech_file = session.api.admin_tech.generate("172.16.255.11")
  session.api.admin_tech.download(admin_tech_file)
  session.api.admin_tech.delete(admin_tech_file)
  ```
  </details>

  <details>
      <summary> <b>Speed test</b> <i>(click to expand)</i></summary>

  ```python
  devices = session.api.devices.get()
  speedtest = session.api.speedtest.speedtest(devices[0], devices[1])
  ```

  </details>

  <details>
      <summary> <b>Upgrade device</b> <i>(click to expand)</i></summary>

  ```python

  controllers = session.endpoints.configuration_device_inventory.get_device_details('controllers')
  vsmarts = controllers.filter(personality=Personality.VSMART)
  image = "viptela-20.7.2-x86_64.tar.gz"


  session.api.repository.upload_image(image)



  install_task = session.api.software.install(devices=vsmarts, image=image)


  install_task.wait_for_completed()
  ```

  </details>

  <details>
      <summary> <b>Get alarms</b> <i>(click to expand)</i></summary>
  To get all alarms:

  ```python
  alarms = session.api.alarms.get()
  ```

  To get all not viewed alarms:

  ```python
  not_viewed_alarms = session.api.alarms.get().filter(viewed=False)
  ```

  To get all alarms from past `n` hours:

  ```python
  n = 24
  alarms_from_n_hours = session.api.alarms.get(from_time=n)
  ```

  To get all critical alarms from past `n` hours:

  ```python
  from catalystwan.utils.alarm_status import Severity
  n = 48
  critical_alarms = session.api.alarms.get(from_time=n).filter(severity=Severity.CRITICAL)
  ```

  </details>

  <details>
      <summary> <b>Users</b> <i>(click to expand)</i></summary>

  ```python

  session.api.users.get()


  from catalystwan.endpoints.administration_user_and_group import User
  new_user = User(username="new_user", password="new_user", group=["netadmin"], description="new user")
  session.api.users.create(new_user)


  new_user_update = UserUpdateRequest(username="new_user", group=["netadmin", "netops"], locale="en_US", description="updated-new_user-description")
  session.api.users.update(new_user_update)


  session.api.users.update_password("new_user", "n3W-P4s$w0rd")


  session.api.users.reset("new_user")


  session.api.users.delete("new_user")


  session.api.users.get_auth_type()
  session.api.users.get_role()
  ```

  </details>

  <details>
      <summary> <b>User Groups</b> <i>(click to expand)</i></summary>

  ```python

  session.api.user_groups.get()


  group = UserGroup("new_user_group", [])
  group.enable_read({"Audit Log", "Alarms"})
  group.enable_read_and_write({"Device Inventory"})
  session.api.user_groups.create(group)


  group.disable({"Alarms"})
  session.api.user_groups.update(group)


  session.api.user_groups.delete(group.group_name)
  ```

  </details>

  </details>

  <details>
      <summary> <b>Sessions</b> <i>(click to expand)</i></summary>

  ```python

  active_sessions = session.api.sessions.get()


  new_user_sessions = active_sessions.filter(raw_username="new_user")
  session.api.sessions.invalidate(new_user_sessions)
  ```

  </details>

  <details>
      <summary> <b>Resource Groups</b> <i>(click to expand)</i></summary>

  ```python

  session.api.resource_groups.get()


  new_resource_group = ResourceGroup(
      name="new_resource_group",
      desc="Custom Resource Group #1",
      siteIds=[]
  )
  session.api.resource_groups.create(new_resource_group)


  resource_group = session.api.resource_groups.get().filter(name="new_resource_group").single_or_default()
  updated_resource_group = ResourceGroupUpdateRequest(
      id=resource_group.id,
      name=resource_group.name,
      desc="Custom Resource Group #1 with updated description and site ids",
      siteIds=[200]
  )


  session.api.resource_groups.switch("new_resource_group")


  session.api.resource_groups.delete(resource_group.id)
  ```

  </details>

  <details>
      <summary> <b>Tenant management</b> <i>(click to expand)</i></summary>

  ```python
  api = session.api.tenant_management

  tenants = [
      Tenant(
          name="tenant1",
          org_name="CiscoDevNet",
          subdomain="alpha.bravo.net",
          desc="This is tenant for unit tests",
          edge_connector_enable=True,
          edge_connector_system_ip="172.16.255.81",
          edge_connector_tunnel_interface_name="GigabitEthernet1",
          wan_edge_forecast=1,
      )
  ]
  create_task = api.create(tenants)
  create_task.wait_for_completed()

  tenants_data = api.get_all()

  tenant = tenants_data.filter(name="tenant1").single_or_default()

  tenant_id = tenant.tenant_id

  vsessionid = api.vsession_id(tenant_id)

  delete_task = api.delete([tenant_id])
  delete_task.wait_for_completed()

  api.get_hosting_capacity_on_vsmarts()
  api.get_statuses()
  api.get_vsmart_mapping()
  ```
  </details>

  <details>
      <summary> <b>Tenant migration</b> <i>(click to expand)</i></summary>

  ```python
  from pathlib import Path
  from catalystwan.session import create_manager_session
  from catalystwan.models.tenant import TenantExport
  from catalystwan.workflows.tenant_migration import migration_workflow

  tenant = TenantExport(
      name="mango",
      desc="Mango tenant description",
      org_name="Provider Org-Mango Inc",
      subdomain="mango.fruits.com",
      wan_edge_forecast=100,
      migration_key="MangoTenantMigrationKey",   # only for SDWAN Manager >= 20.13
      is_destination_overlay_mt=True,            # only for SDWAN Manager >= 20.13
  )

  with create_manager_session(url="10.0.1.15", username="st-admin", password="") as origin_session, \
       create_manager_session(url="10.9.0.16", username="mt-provider-admin", password="") as target_session:
      migration_workflow(
          origin_session=origin_session,
          target_session=target_session,
          workdir=Path("workdir"),
          tenant=tenant,
          validator="10.9.12.26"
      )
  ```

  `migration_workflow` performs multi-step migration procedure according to [Migrate Single-Tenant Cisco SD-WAN Overlay to Multitenant Cisco SD-WAN Deployment](https://www.cisco.com/c/en/us/td/docs/routers/sdwan/configuration/system-interface/vedge-20-x/systems-interfaces-book/sdwan-multitenancy.html#concept_sjj_jmm_z4b)


  Since 20.13 also MT to ST is supported (just provide suitable origin/target sessions, and `is_destination_overlay_mt` parameter)


  Each step of the `migration_workflow` procedure can be executed independently using api methods: `export_tenant`, `download`, `import_tenant`, `store_token`, `migrate_network`

  ```python
  origin_api = origin_session.api.tenant_migration_api
  target_api = target_session.api.tenant_migration_api
  tenant_file = Path("~/tenant.tar.gz")
  token_file = Path("~/tenant-token.txt")

  export_task = origin_api.export_tenant(tenant=tenant)
  remote_filename = export_task.wait_for_file()

  origin_api.download(export_path, remote_filename)

  import_task = target_api.import_tenant(export_path, tenant.migration_key)
  import_task.wait_for_completed()

  migration_id = import_task.import_info.migration_token_query_params.migration_id
  target_api.store_token(migration_id, token_path)

  migrate_task = origin_api.migrate_network(token_path)
  migrate_task.wait_for_completed()
  ```
  </details>



  To remove `InsecureRequestWarning`, you can include in your scripts (warning is suppressed when `catalystwan_devel` environment variable is set):
  ```Python
  import urllib3
  urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
  ```


  ```python
  try:
      session.api.users.delete("bogus-user-name")
  except ManagerHTTPError as error:
      
      print(error.response.status_code)
      print(error.info.code)
      print(error.info.message)
      print(error.info.details)

  ```








  You can contact us by submitting [issues](https://github.com/cisco-en-programmability/catalystwan-sdk/issues), or directly via mail on catalystwan@cisco.com.


pkgId: c7912029d7246a67fa01fd3c046277f2568f408f47c0d54b6e793753b02923de
name: python-catbench-help
arch: noarch
version: 0.1.19
epoch: 0
release: 1
summary: Development documents and examples for catbench
url: https://github.com/JinukMoon/catbench
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-catbench-0.1.19-1.src.rpm
location_href: Packages/python-catbench-help-0.1.19-1.noarch.rpm
checksum_type: sha256
description:
  CatBench: Benchmark Framework for Graph Neural Networks in Adsorption Energy Predictions



  ```bash
  pip install catbench
  ```


  ![CatBench Schematic](assets/CatBench_Schematic.png)
  CatBench is a comprehensive benchmarking framework designed to evaluate Graph Neural Networks (GNNs) for adsorption energy predictions. It provides tools for data processing, model evaluation, and result analysis.




  CatBench supports two types of data sources:



  ```python

  import catbench


  catbench.cathub_preprocess("Catalysis-Hub_Dataset_tag")
  ```

  **Example:**
  ```python


  catbench.cathub_preprocess("AraComputational2022")
  ```


  For custom datasets, prepare your data structure as follows:

  The data structure should include:
  - Gas references (`gas/`) containing VASP output files for gas phase molecules
  - Surface structures (`surface1/`, `surface2/`, etc.) containing:
    - Clean slab calculations (`slab/`)
    - Adsorbate-surface systems (`H/`, `OH/`, etc.)

  Note: Each directory must contain CONTCAR and OSZICAR files. Other VASP output files can be present as well - the `process_output` function will automatically clean up (delete) all files except CONTCAR and OSZICAR.

  ```
  data/
  ├── gas/
  │   ├── H2gas/
  │   │   ├── CONTCAR
  │   │   └── OSZICAR
  │   └── H2Ogas/
  │       ├── CONTCAR
  │       └── OSZICAR
  ├── surface1/
  │   ├── slab/
  │   │   ├── CONTCAR
  │   │   └── OSZICAR
  │   ├── H/
  │   │   ├── CONTCAR
  │   │   └── OSZICAR
  │   └── OH/
  │       ├── CONTCAR
  │       └── OSZICAR
  └── surface2/
      ├── slab/
      │   ├── CONTCAR
      │   └── OSZICAR
      ├── H/
      │   ├── CONTCAR
      │   └── OSZICAR
      └── OH/
          ├── CONTCAR
          └── OSZICAR
  ```

  Then process using:

  ```python
  import catbench








  coeff_setting = {
      "H": {
          "slab": -1,      # Coefficient for clean surface
          "adslab": 1,     # Coefficient for adsorbate-surface system
          "H2gas": -1/2,   # Coefficient for H2 gas reference
      },
      "OH": {
          "slab": -1,      # Coefficient for clean surface
          "adslab": 1,     # Coefficient for adsorbate-surface system
          "H2gas": +1/2,   # Coefficient for H2 gas reference
          "H2Ogas": -1,    # Coefficient for H2O gas reference
      },
  }


  catbench.process_output("data", coeff_setting)
  catbench.userdata_preprocess("data")
  ```




  This is a general benchmark setup. The `range()` value determines the number of repetitions for reproducibility testing. If reproducibility testing is not needed, it can be set to 1.

  Note: This benchmark is only compatible with GNN models that output total system energy. For example, OC20 GNN models that are trained to directly predict adsorption energies cannot be used with this framework.

  ```python
  import catbench
  from your_calculator import Calculator




  calculators = [Calculator() for _ in range(5)]

  config = {}
  catbench.execute_benchmark(calculators, **config)
  ```

  After execution, the following files and directories will be created:

  1. A `result` directory is created to store all calculation outputs.
  2. Inside the `result` directory, subdirectories are created for each GNN.
  3. Each GNN's subdirectory contains:
     - `gases/`: Gas reference molecules for adsorption energy calculations
     - `log/`: Slab and adslab calculation logs
     - `traj/`: Slab and adslab trajectory files
     - `{GNN_name}_gases.json`: Gas molecules energies
     - `{GNN_name}_outlier.json`: Outlier detection status for each adsorption data
     - `{GNN_name}_result.json`: Raw data (energies, calculation times, outlier detection, slab displacements, etc.)


  Since OC20 project GNN models are trained to predict adsorption energies directly rather than total energies, they are handled with a separate function.

  The overall usage is similar to the general benchmark, but each GNN will only have the following subdirectories:

  - `log/`: Slab and adslab calculation logs
  - `traj/`: Slab and adslab trajectory files
  - `{GNN_name}_outlier.json`: Outlier detection status for each adsorption data
  - `{GNN_name}_result.json`: Raw data (energies, calculation times, outlier detection, slab displacements, etc.)

  ```python
  import catbench
  from your_calculator import Calculator




  calculators = [Calculator() for _ in range(5)]

  config = {}
  catbench.execute_benchmark_OC20(calculators, **config)
  ```



  ```python
  import catbench
  from your_calculator import Calculator

  calculator = Calculator()

  config = {}
  catbench.execute_benchmark_single(calculator, **config)
  ```



  ```python
  import catbench

  config = {}
  catbench.analysis_GNNs(**config)
  ```

  The analysis function processes the calculation data stored in the `result` directory and generates:

  1. A `plot/` directory:
     - Parity plots for each GNN model
     - Combined parity plots for comparison
     - Performance visualization plots

  2. An Excel file `{dataset_name}_Benchmarking_Analysis.xlsx`:
     - Comprehensive performance metrics for all GNN models
     - Statistical analysis of predictions
     - Model-specific details and parameters



  ```python
  import catbench

  config = {}
  catbench.analysis_GNNs_single(**config)
  ```




  You can plot adsorption energy parity plots for each adsorbate across all GNNs, either simply or by adsorbate.
  <p float="left">
    <img src="assets/mono_plot.png" width="400" />
    <img src="assets/multi_plot.png" width="400" />
  </p>


  View various metrics for all GNNs.
  ![Comparison Table](assets/comparison_table.png)


  See how outliers are detected for all GNNs.
  ![Comparison Table](assets/outlier_table.png)


  Observe how each GNN predicts for each adsorbate.
  ![Comparison Table](assets/adsorbate_comp_table.png)




  | Option | Description | Default |
  |--------|-------------|---------|
  | GNN_name | Name of your GNN | Required |
  | benchmark | Name of benchmark dataset | Required |
  | F_CRIT_RELAX | Force convergence criterion | 0.05 |
  | N_CRIT_RELAX | Maximum number of steps | 999 |
  | rate | Fix ratio for surface atoms (0: use original constraints, >0: fix atoms from bottom up to specified ratio) | 0.5 |
  | disp_thrs_slab | Displacement threshold for slab | 1.0 |
  | disp_thrs_ads | Displacement threshold for adsorbate | 1.5 |
  | again_seed | Seed variation threshold | 0.2 |
  | damping | Damping factor for optimization | 1.0 |
  | gas_distance | Cell size for gas molecules | 10 |
  | optimizer | Optimization algorithm | "LBFGS" |


  | Option | Description | Default |
  |--------|-------------|---------|
  | GNN_name | Name of your GNN | Required |
  | benchmark | Name of benchmark dataset | Required |
  | gas_distance | Cell size for gas molecules | 10 |


  | Option | Description | Default |
  |--------|-------------|---------|
  | Benchmarking_name | Name for output files | Current directory name |
  | calculating_path | Path to result directory | "./result" |
  | GNN_list | List of GNNs to analyze | All GNNs in result directory |
  | target_adsorbates | Target adsorbates to analyze | All adsorbates |
  | specific_color | Color for plots | "black" |
  | min | Plot y-axis minimum | Auto-calculated |
  | max | Plot y-axis maximum | Auto-calculated |
  | figsize | Figure size | (9, 8) |
  | mark_size | Marker size | 100 |
  | linewidths | Line width | 1.5 |
  | dpi | Plot resolution | 300 |
  | legend_off | Toggle legend | False |
  | error_bar_display | Toggle error bars | False |


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


  This work will be published soon.


pkgId: 648c2100a1325ad0217e01ca0bcc07f1c23eb0de4e6665e45de7640a655d8454
name: python-catboost-extensions-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for catboost-extensions
url: https://github.com/dubovikmaster/catboost-extensions
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-catboost-extensions-2.3.0-1.src.rpm
location_href: Packages/python-catboost-extensions-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  This library provides an easy-to-use interface for hyperparameter tuning of CatBoost models using Optuna. The `OptunaTuneCV` class simplifies the process of defining parameter spaces, configuring trials, and running cross-validation with CatBoost.

  To install the library, use pip:
  ```bash
  pip install catboost-extensions
  ```


  Here is an example of how to use the library to tune a [CatBoost](https://catboost.ai/en/docs/) model using [Optuna](https://optuna.org/):

  ```python
  from pprint import pprint
  import pandas as pd
  from catboost_extensions.optuna import (
      OptunaTuneCV,
      CatboostParamSpace,
  )
  from catboost import CatBoostRegressor
  from sklearn.datasets import fetch_california_housing
  import optuna
  ```

  ```python

  data = fetch_california_housing()
  X = pd.DataFrame(data.data, columns=data.feature_names)
  y = data.target
  ```

  ```python
  model = CatBoostRegressor(verbose=False, task_type='CPU')
  ```

  The `CatboostParamSpace` class allows you to define a parameter space for your CatBoost model. You can remove parameters that you don't want to tune using the `del_params` method.
  ```python
  param_space = CatboostParamSpace(params_preset='general', task_type='CPU')
  param_space.del_params(['depth', 'l2_leaf_reg'])
  pprint(param_space.get_params_space())
  ```
  Out:
  ```python
  {'bootstrap_type': CategoricalDistribution(choices=('Bayesian', 'MVS', 'Bernoulli', 'No')),
   'grow_policy': CategoricalDistribution(choices=('SymmetricTree', 'Depthwise', 'Lossguide')),
   'iterations': IntDistribution(high=5000, log=False, low=100, step=1),
   'learning_rate': FloatDistribution(high=0.1, log=True, low=0.001, step=None),
   'max_bin': IntDistribution(high=512, log=False, low=8, step=1),
   'random_strength': FloatDistribution(high=10.0, log=True, low=0.01, step=None),
   'rsm': FloatDistribution(high=1.0, log=False, low=0.01, step=None),
   'score_function': CategoricalDistribution(choices=('Cosine', 'L2'))}
  ```
  Also you can change the default values of the parameters:
  ```python
  param_space.iterations=(1000, 2000)
  ```

  The `OptunaTuneCV` class helps to define an objective function for Optuna. You can specify the CatBoost model, the parameter space, the dataset, and other options such as the trial timeout and the scoring metric.
  ```python
  objective = OptunaTuneCV(model, param_space, X, y, trial_timeout=10, scoring='r2')
  ```

  You can choose an Optuna sampler (e.g., `TPESampler`) and then create a study to optimize the objective function.
  ```python
  sampler = optuna.samplers.TPESampler(seed=20, multivariate=True)
  study = optuna.create_study(direction='maximize', sampler=sampler)
  study.optimize(objective, n_trials=10)
  ```

  After the study completes, you can analyze the results to see the best hyperparameters found during the optimization.
  ```python
  print("Best trial:")
  trial = study.best_trial
  print(f"  Value: {trial.value}")
  print(f"  Params: ")
  for key, value in trial.params.items():
      print(f"    {key}: {value}")
  ```

  If you want to contribute to this library, please open an issue or submit a pull request on GitHub.

  This project is licensed under the MIT License.


pkgId: 7f208a13f6dd47a104844019f4a593a62d1f6af4dab028dca22a3165cecada24
name: python-catface-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for catface
url: https://github.com/YanickJair/catface
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-catface-0.1.4-1.src.rpm
location_href: Packages/python-catface-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <img src="static/catface-logo.png" alt="httpx" width="200px">
    <br>
  </h1>

  <p align="center">
  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-_red.svg"></a>
  </p>

  `catface` s a Command Line Interface (CLI) tool that helps you create Python projects with best practices built-in. It uses [cookiecutter](https://www.cookiecutter.io/) under the hood to provide project templates that you can customize based on your needs.




  - **Documentation (MkDocs)**
    - Automatic API documentation
    - Material design theme
    - Ready-to-deploy structure

  - **Docker Integration**
    - Multi-stage builds
    - Production-ready configuration
    - Python version specific base images

  - **Development Tools**
    - Pre-commit hooks for code quality
    - Ruff for fast linting and formatting
    - Tox for testing across Python versions



  ```bash

  pip install catface


  catface my-awesome-project
  ```



    - Task automation: Using Tox we can automate repetitive tasks
    - Test against multiple Python versions
    - Environment management: Using Tox we can create different environments each with its dependencies
    - Lint and format code using Ruff

  ```bash

  cd my-awesome-project

  tox # runs all environments
  tox -e <env_name> # running each environment individually by name
  tox -p all # parallel execution


pkgId: 4880f8f31cbe1bac632df77b7181219cae4053aad3c0afe1a5d4bbe9dcba3b1c
name: python-catholic-mass-readings-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for catholic-mass-readings
url: https://pypi.org/project/catholic-mass-readings/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-catholic-mass-readings-0.1.0-1.src.rpm
location_href: Packages/python-catholic-mass-readings-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CI Build](https://github.com/rcolfin/catholic-mass-readings/actions/workflows/ci.yml/badge.svg)](https://github.com/rcolfin/catholic-mass-readings/actions/workflows/ci.yml)
  [![PyPI Version](https://img.shields.io/pypi/v/catholic-mass-readings)](https://pypi.python.org/pypi/catholic-mass-readings)
  [![versions](https://img.shields.io/pypi/pyversions/catholic-mass-readings.svg)](ttps://github.com/rcolfin/catholic-mass-readings)

  Provides an API for scraping the web page from [Daily Readings](https://bible.usccb.org/bible/readings/) website of United States Conference of Catholic Bishops.





  Run [scripts/console.sh](../scripts/console.sh) poetry install



  Run [scripts/lock.sh](../scripts/lock.sh)



  Run [scripts/console.sh](../scripts/console.sh) poetry run catholic_mass_readings




  ```python
  import datetime

  from catholic_mass_readings import USCCB


  async with USCCB() as usccb:
      mass = await usccb.get_mass_from_date(datetime.date(2024, 12, 25))
      print(mass.dumps())


  async with USCCB() as usccb:
      masses: list[models.Mass] = []
      dates = usccb.get_sunday_mass_dates(datetime.date(2024, 12, 25), datetime.date(2024, 1, 25))
      for task in asyncio.as_completed([usccb.get_mass_from_date(dt) for dt in dates]):
          mass = await task
          if mass:
              print(mass.dumps())

      masses.sort(key=lambda m: m.date.toordinal() if m.date else -1)
      print(mass.dumps())


  async with USCCB() as usccb:
      masses: list[models.Mass] = []
      dates = usccb.get_mass_dates(datetime.date(2024, 12, 25), datetime.date(2024, 1, 25), step=datetime.timedelta(days=1))
      for task in asyncio.as_completed([usccb.get_mass_from_date(dt) for dt in dates]):
          mass = await task
          if mass:
              print(mass.dumps())

      masses.sort(key=lambda m: m.date.toordinal() if m.date else -1)
      print(mass.dumps())
  ```

  As a CLI

  ```sh

  python -m catholic_mass_readings get-mass --date 2024-12-25


  python -m catholic_mass_readings get-sunday-mass-range --start 2024-12-25 --end 2025-01-01


  python -m catholic_mass_readings get-mass-range --start 2024-12-25 --end 2025-01-01 --step 7
  ```

  ...Or saving to a file

  ```sh

  python -m catholic_mass_readings get-mass --date 2024-12-25 --save mass.json


  python -m catholic_mass_readings get-sunday-mass-range --start 2024-12-25 --end 2025-01-01 --save mass.json


  python -m catholic_mass_readings get-mass-range --start 2024-12-25 --end 2025-01-01 --step 7 --save mass.json
  ```


pkgId: adf76b8d49926e1ccd05a5e2af0ff378cd2f7a0687486ee3e101829e161ef887
name: python-catholic-mass-readings-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for catholic-mass-readings
url: https://pypi.org/project/catholic-mass-readings/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-catholic-mass-readings-0.2.2-1.src.rpm
location_href: Packages/python-catholic-mass-readings-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  [![CI Build](https://github.com/rcolfin/catholic-mass-readings/actions/workflows/ci.yml/badge.svg)](https://github.com/rcolfin/catholic-mass-readings/actions/workflows/ci.yml)
  [![PyPI Version](https://img.shields.io/pypi/v/catholic-mass-readings)](https://pypi.python.org/pypi/catholic-mass-readings)
  [![versions](https://img.shields.io/pypi/pyversions/catholic-mass-readings.svg)](ttps://github.com/rcolfin/catholic-mass-readings)

  Provides an API for scraping the web page from [Daily Readings](https://bible.usccb.org/bible/readings/) website of United States Conference of Catholic Bishops.





  Run [scripts/console.sh](../scripts/console.sh) poetry install



  Run [scripts/lock.sh](../scripts/lock.sh)



  Run [scripts/console.sh](../scripts/console.sh) poetry run catholic_mass_readings




  ```python
  import asyncio
  import datetime

  from catholic_mass_readings import USCCB


  async with USCCB() as usccb:
      mass = await usccb.get_mass_from_date(datetime.date(2024, 12, 25))
      print(mass.dumps())


  async with USCCB() as usccb:
      masses: list[models.Mass] = []
      dates = usccb.get_sunday_mass_dates(datetime.date(2024, 12, 25), datetime.date(2024, 1, 25))
      for task in asyncio.as_completed([usccb.get_mass_from_date(dt) for dt in dates]):
          mass = await task
          if mass:
              print(mass.dumps())

      masses.sort(key=lambda m: m.date.toordinal() if m.date else -1)
      print(mass.dumps())


  async with USCCB() as usccb:
      masses: list[models.Mass] = []
      dates = usccb.get_mass_dates(datetime.date(2024, 12, 25), datetime.date(2024, 1, 25), step=datetime.timedelta(days=1))
      for task in asyncio.as_completed([usccb.get_mass_from_date(dt) for dt in dates]):
          mass = await task
          if mass:
              print(mass.dumps())

      masses.sort(key=lambda m: m.date.toordinal() if m.date else -1)
      print(mass.dumps())
  ```

  As a CLI

  ```sh

  python -m catholic_mass_readings get-mass --date 2024-12-25


  python -m catholic_mass_readings get-sunday-mass-range --start 2024-12-25 --end 2025-01-01


  python -m catholic_mass_readings get-mass-range --start 2024-12-25 --end 2025-01-01 --step 7
  ```

  or saving to a file...

  ```sh

  python -m catholic_mass_readings get-mass --date 2024-12-25 --save mass.json


  python -m catholic_mass_readings get-sunday-mass-range --start 2024-12-25 --end 2025-01-01 --save mass.json


  python -m catholic_mass_readings get-mass-range --start 2024-12-25 --end 2025-01-01 --step 7 --save mass.json
  ```



  To install catholic-mass-readings from PyPI, use the following command:

      $ pip install catholic-mass-readings

  You can also clone the repo and run the following command in the project root to install the source code as editable:

      $ pip install -e .


  The documentation for `catholic-mass-readings` can be found [here](https://rcolfin.github.io/catholic-mass-readings/) or in the project's docstrings.


pkgId: 6117c7427171e75d7a5aca9bf089cf8aa914571efc710efc6339fb8936561e00
name: python-catomatic-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for catomatic
url: https://github.com/fowler-lab/catomatic
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-catomatic-0.1.2-1.src.rpm
location_href: Packages/python-catomatic-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/fowler-lab/catomatic/branch/ecoff/graph/badge.svg?token=8fnOy6rHCd)](https://codecov.io/gh/fowler-lab/catomatic)



  Python code that algorithmically builds antimicrobial resistance catalogues of mutations.



  This method relies on the logic that mutations that do not cause resistance can co-occur with those that do, and if a mutation in isolation (solo) does not cause resistance, then it will also not contribute to the phenotype when not in isolation.

  Mutations that occur in isolation across specified genes are traversed in sequence, and if their proportion of drug-susceptibility (vs resistance) passes the specified statistical test, they are characterized as benign and removed from the dataset. This step repeats while there are susceptible mutations in isolation. Once the dataset has been 'cleaned' of benign mutations, resistant mutations are classified via their proportions by the specified test, failing which they are added to the catalogue as 'Unclassified'.

  Construction can either rely on homogenous susceptibility for the particular mutation (and no explicit phenotyping is carried out, other than to unlock susceptible variants), use a Binomial test where the proportion of resistance is tested against a specified background rate, or a Fisher's test where the proportion of resistance is tested against a calculated background rate.

  Although the method is entirely algorithmic, there are 2 entry points for intervention. Firstly, one is able to 'seed' the method with neutral mutations (such as those gathered in a literature search - often helpful if a gene contains phylogenetic mutations with high prevalence that add noise), and secondly one can add or overwrite classifications and entries to the catalogue, although not recommended unless aggregating.

  Because the method uses and understands GARC1 grammar, one can supply 'rules' to the catalogue post-hoc - such as `{rpoB@*_fs:R}` for frameshifts in rpoB, which can either simply be added (and would have lower prediction priority to finer grain mutations, such as `rpoB@44_ins`) or can replace any mutations that fall under that rule, effectively aggregating relevant variants.

  The generated catalogue can be returned either as a dictionary, or as a Pandas dataframe which can be exported in a Piezo compatible format for rapid parsing and resistance predictions.

  Contingency tables, proportions, p_values, and Wilson's Confidence Intervals are logged under the 'EVIDENCE' column of the catalogue.

  A workflow with example parameters:

  ![Catalogue Diagram](docs/workflow.png)





  It is recommended to manage the Python environment and dependencies through Conda. You can install Catomatic within a Conda environment by following these steps:



  First, ensure that you have Conda installed. Then, create and activate a new environment, and install catomatic:

  ```bash
  conda env create -f env.yml
  conda activate catomatic
  pip install .
  ```



  At the most basic level, the method takes 2 input dataframes: a `samples dataframe` which contains 1 row per sample with 'R' vs 'S' binary phenotypes, and a `mutations dataframe` which contains 1 row per mutation. They have to be joinable on their `UNIQUEID` columns.

  If exporting to Piezo format, the `MUTATION` column must contain GARC1 grammer (ie `gene@mutation`). One must also supply a path to the `wildcards.json` file, which should contain Piezo wildcards in a json object/dictionary (example file in `/data/bdq_wildcards.json`).

  If seeding or updating the catalogue, the mutation grammar must match that of the `MUTATION` column.



  After installation, the simplest way to run the catomatic catalogue builder is via the command line interface. ` --to_piezo` or `--to_json ` flags will need to specified to save the catalogue (with additional arguments if using --to_piezo)

  `BuildCatalogue --samples path/to/samples.csv --mutations path/to/mutations.csv  --to_json --outfile path/to/out/catalogue.json`

  or

  `BuildCatalogue --samples path/to/samples.csv --mutations path/to/mutations.csv  --to_piezo --outfile path/to/out/catalogue.csv --genbank_ref '...' --catalogue_name '...' --version '...' --drug '...' --wildcards path/to/wildcards.json`



  Should you wish to run catomatic in a notebook, for example, you can do so simply by calling BuildCatalogue after import.

  ```python
  from catomatic.CatalogueBuilder import BuildCatalogue


  catalogue = BuildCatalogue(samples = samples_df, mutations = mutations_df)


  catalogue.return_catalogue()


  catalogue.build_piezo(genbank_ref='...', catalogue_name='...', version='...', drug='...', wildcards='path/to/wildcards.json')
  ```

  More detailed examples on running catomatic can be found in `examples/demo.ipynb`



  | Parameter          | Type    | Description                                                                                       |
  | ------------------ | ------- | ------------------------------------------------------------------------------------------------- |
  | `--samples`        | `str`   | Path to the samples file. Required.                                                               |
  | `--mutations`      | `str`   | Path to the mutations file. Required.                                                             |
  | `--FRS`            | `float` | Fraction Read Support threshold. Optional.                                                        |
  | `--seed`           | `list`  | List of seed mutations using GARC grammar. Optional.                                              |
  | `--test`           | `str`   | Type of statistical test to run: `None`, `Binomial`, or `Fisher`. Optional.                       |
  | `--background`     | `float` | Background mutation rate for the binomial test. Required if using test = Binomial. Optional.      |
  | `--p`              | `float` | Significance level for statistical testing. Optional. Defaults to `0.95`.                         |
  | `--strict_unlock`  | `bool`  | Enforce strict unlocking for classifications, which requires p < 0.05. Optional.                  |
  | `--to_json`        | `bool`  | Export the catalogue to JSON format. Optional.                                                    |
  | `--outfile`        | `str`   | Path to output file for exporting the catalogue. Used with `--to_json` or `--to_piezo`. Optional. |
  | `--to_piezo`       | `bool`  | Export catalogue to Piezo format. Optional.                                                       |
  | `--genbank_ref`    | `str`   | GenBank reference for the catalogue. Required if to_piezo = True. Optional.                       |
  | `--catalogue_name` | `str`   | Name of the catalogue. Required if to_piezo = True. Optional.                                     |
  | `--version`        | `str`   | Version of the catalogue. Required if to_piezo = True. Optional.                                  |
  | `--drug`           | `str`   | Drug associated with the mutations. Required if to_piezo = True. Optional.                        |
  | `--wildcards`      | `str`   | JSON file with wildcard rules. Required if to_piezo = True. Optional.                             |
  | `--grammar`        | `str`   | Grammar used in the catalogue. Optional. Defaults to `GARC1`.                                     |
  | `--values`         | `str`   | Values used for predictions in the catalogue. Optional. Defaults to `RUS`.                        |


pkgId: 5eb703985807f8a53848aa2ce2c6a72d350a818f0868c8e7baa55b4ac0260e41
name: python-causalexplain-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for causalexplain
url: https://github.com/renero/causalgraph
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-causalexplain-0.5.0-1.src.rpm
location_href: Packages/python-causalexplain-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  ![logo](./docs/_static/logo-light.png)

  [![License](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
  [![Python](https://img.shields.io/badge/Python-3.10%2B-blue.svg)](https://www.python.org/downloads/release/python-31012/)
  [![Platform](https://img.shields.io/badge/Platform-Linux%20%7C%20macOS-lightgrey.svg)](#)
  [![Build Status](https://github.com/renero/causalgraph/actions/workflows/codecov.yaml/badge.svg)](https://github.com/renero/causalgraph/actions/workflows/codecov.yaml)
  [![codecov](https://codecov.io/gh/renero/causalgraph/graph/badge.svg?token=HCV0IJDFLQ)](https://codecov.io/gh/renero/causalgraph)
  [![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue.svg)](https://renero.github.io/causalgraph/)




  '**causalgraph**' is a library that implements methods to extract the causal graph,
  from tabular data, specifically the **ReX** method, and other compared methods
  like GES, PC, FCI, LiNGAM, CAM, and NOTEARS.

  **ReX** is a causal discovery method that leverages machine learning (ML) models
  coupled with explainability techniques, specifically Shapley values, to
  identify and interpret significant causal relationships among variables.
  Comparative evaluations on synthetic datasets comprising tabular data reveal that
  **ReX** outperforms state-of-the-art causal discovery methods across diverse data
  generation processes, including non-linear and additive noise models. Moreover,
  **ReX** was tested on the Sachs single-cell protein-signaling dataset, achieving a
  precision of 0.952 and recovering
  key causal relationships with no incorrect edges. Taking together, these
  results showcase **ReX**’s effectiveness in accurately recovering true causal
  structures while minimizing false positive pre- dictions, its robustness
  across diverse datasets, and its applicability to real-world problems.
  By combining ML and explainability techniques with causal discovery, **ReX**
  bridges the gap between predictive modeling and causal inference, offering an
  effective tool for understanding complex causal structures.

  ![ReX Schema](./docs/_static/REX.png)

  It is built using SKLearn estimators, so that it can be used in scikit-learn
  pipelines and (hyper)parameter search, while facilitating testing (including
  some API compliance), documentation, open source development, packaging,
  and continuous integration.

  The datasets used in the examples can be generated using the `generators`
  module, which is also part of this library. But in case you want to
  reproduce results from the articles that we used as reference, you can find
  the datasets in the `data` folder.



  - Operating System: Linux or macOS
  - Environment Manager: PyEnv or Conda
  - Programming Language: Python 3.10.12 or higher
  - Hardware: CPU



  In the comming days the library will be made available in PyPI.
  In the meantime, you can install it from the source code:

  ```bash
  $ git clone
  $ cd causalgraph
  $ pip install .
  ```



  The datasets used to reproduce the results presented in the manuscript are
  available under the `data` folder. The datasets were generated using the
  `generators` module.



  To run `causalgraph` on your data, you can use the `causalgraph` command:

  ```
  $ python -m causalgraph
     ____                      _  ____                 _
    / ___|__ _ _   _ ___  __ _| |/ ___|_ __ __ _ _ __ | |__
   | |   / _` | | | / __|/ _` | | |  _| '__/ _` | '_ \| '_ \
   | |__| (_| | |_| \__ \ (_| | | |_| | | | (_| | |_) | | | |
    \____\__,_|\__,_|___/\__,_|_|\____|_|  \__,_| .__/|_| |_|
                                                |_|
  usage: causalgraph [-h] -d DATASET [-m {rex,pc,fci,ges,lingam,cam,notears}]
                     [-t TRUE_DAG] [-l LOAD_MODEL] [-T THRESHOLD] [-u UNION]
                     [-i ITERATIONS] [-b BOOTSTRAP] [-r REGRESSOR] [-S SEED]
                     [-s [SAVE_MODEL]] [-v] [-q] [-o OUTPUT]
  ```

  that will present you with a menu to choose the dataset you want to use, the
  method you want to use to infer the causal graph, and the hyperparameters you
  want to use.

  The minimum required to run `causalgraph` is a dataset file in CSV format,
  with the first row containing the names of the variables, and the rest of
  the rows containing the values of the variables. The method selected by default
  is ReX, but you can also choose between PC, FCI, GES, LiNGAM, CAM, NOTEARS.
  At the end of the execution, the edges of the plausible causal graph will be
  displayed along with the metrics obtained, if the true dag is provided
  (argument `-t`).




  The following command illustrates how to run `causalgraph` on the toy dataset
  using the ReX method:

  ```bash
  $ python -m causalgraph -d /path/to/toy_dataset.csv -t /path/to/toy_dataset.dot
  ```

  The same command can be used to run `causalgraph` on the toy dataset using the
  CAM method:

  ```bash
  $ python -m causalgraph -d /path/to/toy_dataset.csv -m cam -t /path/to/toy_dataset.dot
  ```

  For more information on command line options, run `causalgraph -h` or go to
  the [Quickstart](https://renero.github.io/causalgraph/quickstart.html) section in the documentation.



  WIP


pkgId: 1e77a97791944c061efaf06bfa6fd518531d2c8746262392be49d3e97e5ea1d4
name: python-causaltune-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for causaltune
url: https://github.com/py-why/causaltune
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-causaltune-0.1.8-1.src.rpm
location_href: Packages/python-causaltune-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  [CausalTune Docs](https://causaltune.readthedocs.io/en/latest/)

  **CausalTune** is a library for automated tuning and selection for causal estimators.

  Its estimators are taken from [EconML](https://github.com/microsoft/EconML/) augmented by a couple of extra models
  (currently Transformed Outcome and a dummy model to be used as a baseline), all called in a uniform fashion via a
  [DoWhy](https://github.com/microsoft/DoWhy/) wrapper.

  Our contribution is enabling automatic estimator tuning and selection by out-of-sample scoring of causal estimators, notably using the [energy score](https://arxiv.org/abs/2212.10076).
  We use [FLAML](https://github.com/microsoft/FLAML) for hyperparameter optimisation.

  We perform automated hyperparameter tuning of first stage models (for the treatment and outcome models)
  as well as hyperparameter tuning and model selection for the second stage model (causal estimator).

  The estimators provide not only per-row treatment impact estimates, but also confidence intervals for these,
  using builtin EconML functionality for that where it is available and bootstrapping where it is not (see [example notebook](https://github.com/py-why/causaltune/blob/main/notebooks/Standard%20errors.ipynb)).

  Just like DoWhy and EconML, we assume that the causal graph provided by the user accurately describes the data-generating process.
  So for example, we assume that for CATE estimation, the list of backdoor variables under the graph/confounding variables
  provided by the user do reflect all sources of confounding between the treatment and the outcome. See [here](https://github.com/py-why/causaltune/blob/main/notebooks/CausalityDataset%20setup.ipynb) for a detailed explanation of causal graphs that are supported by CausalTune.

  The validation methods in CausalTune cannot catch such violations and therefore this is an important assumption.

  We also implement the [ERUPT](https://medium.com/building-ibotta/erupt-expected-response-under-proposed-treatments-ff7dd45c84b4)
  [calculation](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3111957) (also known as policy value),
  allowing after an (even partially) randomized test to estimate what the impact
  of other treatment assignment policies would have been. This can also be used as an alternative out-of-sample score,
  though energy score performed better in our synthetic data experiments.

  <summary><strong><em>Table of Contents</em></strong></summary>

  - [CausalTune: A library for automated Causal Inference model estimation and selection](#causaltune-a-library-for-automated-causal-inference-model-estimation-and-selection)
    - [What can this do for you?](#what-can-this-do-for-you)
      - [1. Supercharge A/B tests by getting impact by customer, instead of just an average](#1-supercharge-ab-tests-by-getting-impact-by-customer-instead-of-just-an-average)
      - [2. Continuous testing combined with exploitation: (Dynamic) uplift modelling](#2-continuous-testing-combined-with-exploitation-dynamic-uplift-modelling)
      - [3. Estimate the benefit of smarter (but still partially random) assignment compared to fully random without the need for an actual fully random test group](#3-estimate-the-benefit-of-smarter-but-still-partially-random-assignment-compared-to-fully-random-without-the-need-for-an-actual-fully-random-test-group)
      - [4. Observational inference](#4-observational-inference)
      - [5. IV models: Impact of customer choosing to use a feature](#5-iv-models-impact-of-customer-choosing-to-use-a-feature)
    - [Installation](#installation)
      - [Requirements](#requirements)
      - [Installation Guide for Mac (for installation from source):](#installation-guide-for-mac-for-installation-from-source)
    - [Quick Start](#quick-start)
    - [Supported Models](#supported-models)
    - [Supported Metrics](#supported-metrics)
    - [Citation](#citation)
    - [For Developers](#for-developers)
      - [Installation from source](#installation-from-source)
      - [Testing](#testing)
    - [Contribution](#contribution)




  The automated search over the many powerful models from EconML and elsewhere allows you to easily do the following



  By enriching the results of a regular A/B/N test with customer features, and running CausalTune on the
  resulting dataset, you can get impact estimates as a function of customer features, allowing precise targeting by
  impact in the next iteration. CausalTune also serves as a variance reduction method leveraging the availability of any additional features. [Example notebook](https://github.com/py-why/causaltune/blob/main/notebooks/AB%20testing.ipynb)



  The per-customer impact estimates, even if noisy, can be used to implement per-customer Thompson sampling for new customers, biasing random treatment assignment towards ones we think are most likely to work. As we still control the per-customer propensity to treat, same methods as above can be applied to keep refining our impact estimates.

  Thus, there is no need to either wait for the test to gather enough data for significance, nor to ever end the
  test, before using its results to assign the most impactful treatment (based on our knowledge so far) to each customer.

  As in this case the propensity to treat is known for each customer, we [allow to explicitly supply it](https://github.com/py-why/causaltune/blob/main/notebooks/Propensity%20Model%20Selection.ipynb)
  as a column to the estimators, instead of estimating it from the data like in other cases.



  The previous section described using causal estimators to bias treatment assignment towards the choice we think is
  most likely to work best for a given customer.

  However, after the fact we would like to know the extra benefit of that compared to a fully random assignment.
  The ERUPT technique [sample notebook](https://github.com/py-why/causaltune/blob/main/notebooks/ERUPT%20under%20simulated%20random%20assignment.ipynb) re-weights the actual outcomes to produce an unbiased estimate of the average outcome that a fully random assignment would have yielded, with no actual additional group needed.




  The traditional application of causal inference. For example, estimating the impact on
  volumes and churn likelihood of the time it takes us to answer a customer query. As the set of customers
  who have support queries is most likely not randomly sampled, confounding corrections are needed.

  As with other usecases, the advanced causal inference models allow impact estimation as a function
  of customer features, rather than just averages, **under the assumption that all relevant confounders are observed**.

  To use this, just set `propensity_model` to an instance of the desired classifier when instantiating `CausalTune`, or to `"auto"` if you want to use the FLAML classifier (the default setting is `"dummy"` which assumes random assigment and infers
  the assignment probability from the data). [Example notebook](https://github.com/py-why/causaltune/blob/main/notebooks/Propensity%20Model%20Selection.ipynb)

  If you have reason to suppose unobserved confounders, such as customer intent (did the customer do a lot of volume
  because of the promotion, or did they sign up for the promotion because they intended to do lots of volume anyway?)
  consider looking for an instrumental variable instead.
  <!--
  Can we reformulate to (did the customer do a lot of volume because of the promotion or is the customer more likely
  to sign up for the promotion because they have a higher volume per se?)
  -->

  Note that our derivation of energy score as a valid out-of-sample score for causal models is strictly speaking not
  applicable for this usecase, but still appears to work reasonably well in practice.



  Instrumental variable (IV) estimation to avoid an estimation bias from unobserved confounders.

  A natural use case for IV models is making a feature or a promotion available to a customer, and trying to
  measure the impact of the customer actually choosing to use the feature (the impact of making the feature
  available can be solved with 1. and 2. above).

  Here we use feature availability as an instrumental variable (assuming its assignment to be strictly randomized),
  and search over IV models in EconML to estimate the impact of the customer choosing to use it. To score IV model fits out of sample, we again use the [energy score](https://arxiv.org/abs/2212.10076). [Example notebook](https://github.com/py-why/causaltune/blob/main/notebooks/Comparing%20IV%20Estimators.ipynb)

  Please be aware we have not yet extensively used the IV model fitting functionality internally, so if you run into any issues, please report them!


  To install from source, see [For Developers](#for-developers) section below.




  CausalTune works with Python 3.8 and 3.9.

  It requires the following libraries to work:
  - NumPy
  - Pandas
  - EconML
  - DoWhy
  - FLAML
  - Scikit-Learn
  - Dcor

  The easiest way to install the dependencies is via
  ```
  pip install -r requirements.txt
  ```
  into the virtual environment of your choice.



  Mac/ OS users: For some machines, it can happen that the package LightGBM which is a dependency of AutoML / Flaml will not automatically be installed properly. In that case, a workaround is to set up a conda environment and install LightGBM through the conda-forge channel

  1. Clone the Repository and navigate to the repository

  2. Set Up a Conda Environment using an appropriate Python Version
  	- Ensure Anaconda or Miniconda is installed.
  	- Create a new Conda environment: `conda create -n causaltune-env python=3.9.x`
  	- Activate the environment: `conda activate causaltune-env`.

  3. Install the dependency lightgbm seperatly before attempting to install other dependencies
  	- `conda install -c conda-forge lightgbm`

  4. Install Dependencies
  	- Navigate to the directory containing 'requirements.txt'.
  	- Install dependencies: `pip3 install -r requirements.txt`.

  5. Load CausalTune from the Local Repository
     	- Adjust Python script paths as needed before running import causaltune, e.g.:
      ```
      import sys
      sys.path.append('path/to/cloned/repository')
      import causaltune
      ```




  The CausalTune package can be used like a scikit-style estimator:

  ```Python
  from causaltune import CausalTune
  from causaltune.datasets import synth_ihdp


  data = synth_ihdp()
  data.preprocess_dataset()



  ct = CausalTune(time_budget=600, metric="energy_distance")


  ct.fit(data)


  print(f"Best estimator: {ct.best_estimator}")

  ```

  Now if ***outcome_model="auto"*** in the CausalTune constructor, we search over a simultaneous search space for the EconML estimators and for FLAML wrappers for common regressors. The old behavior is now achieved by ***outcome_model="nested"*** (Refitting AutoML for each estimator).

  You can also preprocess the data in the CausalityDataset using one of the popular category encoders: ***OneHot, WoE, Label, Target***.


  The package supports the following causal estimators:
  * Meta Learners:
      * S-Learner
      * T-Learner
      * X-Learner
      * Domain Adaptation Learner
  * DR Learners:
      * Forest DR Learner
      * Linear DR Learner
      * Sparse Linear DR Learner
  * DML Learners:
      * Linear DML
      * Sparse Linear DML
      * Causal Forest DML
  * Ortho Forests:
      * DR Ortho Forest
      * DML Ortho Forest
  * Transformed Outcome


  We support a variety of different metrics that quantify the performance of a causal model:
  * Energy distance
  * ERUPT (Expected Response Under Proposed Treatments)
  * Qini coefficient and AUC (area under curve)
  * ATE (average treatment effect)


  If you use CausalTune in your research, please cite us as follows:

  Timo Debono, Julian Teichgräber, Timo Flesch, Edward Zhang, Guy Durant, Wen Hao Kho, Mark Harley, Egor Kraev. **CausalTune: A Python package for Automated Causal Inference model estimation and selection.** https://github.com/py-why/causaltune. 2022. Version 0.x
  You can use the following BibTex entry:
  ```
  @misc{CausalTune,
    author={Timo Debono, Julian Teichgr\"aber, Timo Flesch, Edward Zhang, Guy Durant, Wen Hao Kho, Mark Harley, Egor Kraev},
    title={{CausalTune}: {A Python package for Automated Causal Inference model estimation and selection}},
    howpublished={https://github.com/py-why/causaltune},
    note={Version 0.x},
    year={2022}
  }
  ```


  We use [Setuptools](https://setuptools.readthedocs.io/en/latest/index.html) for building and distributing our package. To install the latest version from source, clone this repository and run the following command from the top-most folder of the repository
  ```
  pip install -e .
  ```

  We use [PyTest](https://docs.pytest.org/) for testing. If you want to contribute code, make sure that the tests run without errors.


  See the [Contribution file](https://github.com/py-why/causaltune/blob/main/CONTRIBUTING.md) for contribution licensing and code guidelines.


