# packages

pkgId: f4f51937258d0bbd1ba2f3cfc7ded86b0af6d4ed51dbab12ca4c7c982d4305d3
name: python-cycode
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Boost security in your dev lifecycle via SAST, SCA, Secrets & IaC scanning.
url: https://github.com/cycodehq/cycode-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cycode-2.0.0-1.src.rpm
checksum_type: sha256
description:
  The Cycode Command Line Interface (CLI) is an application you can install on your local machine which can scan your locally stored repositories for any secrets or infrastructure as code misconfigurations.

  This guide will guide you through both installation and usage.



  1. [Prerequisites](#prerequisites)
  2. [Installation](#installation)
      1. [Install Cycode CLI](#install-cycode-cli)
          1. [Using the Auth Command](#using-the-auth-command)
          2. [Using the Configure Command](#using-the-configure-command)
          3. [Add to Environment Variables](#add-to-environment-variables)
              1. [On Unix/Linux](#on-unixlinux)
              2. [On Windows](#on-windows)
      2. [Install Pre-Commit Hook](#install-pre-commit-hook)
  3. [Cycode Command](#cycode-cli-commands)
  4. [Scan Command](#scan-command)
      1. [Running a Scan](#running-a-scan)
          1. [Repository Scan](#repository-scan)
              1. [Branch Option](#branch-option)
          2. [Monitor Option](#monitor-option)
          3. [Report Option](#report-option)
          4. [Package Vulnerabilities Scan](#package-vulnerabilities-option)
              1. [License Compliance Option](#license-compliance-option)
              2. [Severity Threshold](#severity-threshold)
          5. [Path Scan](#path-scan)
              1. [Terraform Plan Scan](#terraform-plan-scan)
          6. [Commit History Scan](#commit-history-scan)
              1. [Commit Range Option](#commit-range-option)
          7. [Pre-Commit Scan](#pre-commit-scan)
          8. [Lock Restore Options](#lock-restore-options)
              1. [SBT Scan](#sbt-scan)
      2. [Scan Results](#scan-results)
          1. [Show/Hide Secrets](#showhide-secrets)
          2. [Soft Fail](#soft-fail)
          3. [Example Scan Results](#example-scan-results)
              1. [Secrets Result Example](#secrets-result-example)
              2. [IaC Result Example](#iac-result-example)
              3. [SCA Result Example](#sca-result-example)
              4. [SAST Result Example](#sast-result-example)
          4. [Company’s Custom Remediation Guidelines](#companys-custom-remediation-guidelines)
      3. [Ignoring Scan Results](#ignoring-scan-results)
          1. [Ignoring a Secret Value](#ignoring-a-secret-value)
          2. [Ignoring a Secret SHA Value](#ignoring-a-secret-sha-value)
          3. [Ignoring a Path](#ignoring-a-path)
          4. [Ignoring a Secret, IaC, or SCA Rule](#ignoring-a-secret-iac-sca-or-sast-rule)
          5. [Ignoring a Package](#ignoring-a-package)
          6. [Ignoring using config file](#ignoring-using-config-file)
  5. [Report command](#report-command)
      1. [Generating SBOM Report](#generating-sbom-report)
  6. [Syntax Help](#syntax-help)



  - The Cycode CLI application requires Python version 3.8 or later.
  - Use the [`cycode auth` command](#using-the-auth-command) to authenticate to Cycode with the CLI
    - Alternatively, you can obtain a Cycode Client ID and Client Secret Key by following the steps detailed in the [Service Account Token](https://docs.cycode.com/reference/creating-a-service-account-access-token) and [Personal Access Token](https://docs.cycode.com/reference/creating-a-personal-access-token-1) pages, which contain details on obtaining these values.



  The following installation steps are applicable to both Windows and UNIX / Linux operating systems.

  > [!NOTE]
  > The following steps assume the use of `python3` and `pip3` for Python-related commands; however, some systems may instead use the `python` and `pip` commands, depending on your Python environment’s configuration.



  To install the Cycode CLI application on your local machine, perform the following steps:

  1. Open your command line or terminal application.

  2. Execute one of the following commands:

     - `pip3 install cycode` - to install from PyPI
     - `brew install cycode` - to install from Homebrew

  3. Navigate to the top directory of the local repository you wish to scan.

  4. There are three methods to set the Cycode client ID and client secret:

     - [cycode auth](#using-the-auth-command) (**Recommended**)
     - [cycode configure](#using-the-configure-command)
     - Add them to your [environment variables](#add-to-environment-variables)



  > [!NOTE]
  > This is the **recommended** method for setting up your local machine to authenticate with Cycode CLI.

  1. Type the following command into your terminal/command line window:

     `cycode auth`

  2. A browser window will appear, asking you to log into Cycode (as seen below):

      ![Cycode login](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/cycode_login.png)

  3. Enter your login credentials on this page and log in.

  4. You will eventually be taken to the page below, where you'll be asked to choose the business group you want to authorize Cycode with (if applicable):

      ![authorize CLI](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/authorize_cli.png)

     > [!NOTE]
      > This will be the default method for authenticating with the Cycode CLI.

  5. Click the **Allow** button to authorize the Cycode CLI on the selected business group.

      ![allow CLI](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/allow_cli.png)

  6. Once completed, you'll see the following screen, if it was selected successfully:

      ![successfully auth](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/successfully_auth.png)

  7. In the terminal/command line screen, you will see the following when exiting the browser window:

    ```bash
    Successfully logged into cycode
    ```



  > [!NOTE]
  > If you already set up your Cycode Client ID and Client Secret through the Linux or Windows environment variables, those credentials will take precedent over this method.

  1. Type the following command into your terminal/command line window:

     `cycode configure`

  2. Enter your Cycode API URL value (you can leave blank to use default value).

      ```bash
      Cycode API URL [https://api.cycode.com]: https://api.onpremise.com
      ```

  3. Enter your Cycode APP URL value (you can leave blank to use default value).

      ```bash
      Cycode APP URL [https://app.cycode.com]: https://app.onpremise.com
      ```

  4. Enter your Cycode Client ID value.

      ```bash
      Cycode Client ID []: 7fe5346b-xxxx-xxxx-xxxx-55157625c72d
      ```

  5. Enter your Cycode Client Secret value.

      ```bash
      Cycode Client Secret []: c1e24929-xxxx-xxxx-xxxx-8b08c1839a2e
      ```

  6. If the values were entered successfully, you'll see the following message:

      ```bash
      Successfully configured CLI credentials!
      ```

     or/and

      ```bash
      Successfully configured Cycode URLs!
      ```

  If you go into the `.cycode` folder under your user folder, you'll find these credentials were created and placed in the `credentials.yaml` file in that folder.
  And the URLs were placed in the `config.yaml` file in that folder.





  ```bash
  export CYCODE_CLIENT_ID={your Cycode ID}
  export CYCODE_CLIENT_SECRET={your Cycode Secret Key}
  ```



  1. From the Control Panel, navigate to the System menu:

      ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/image1.png)

  2. Next, click Advanced system settings:

      ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/image2.png)

  3. In the System Properties window that opens, click the Environment Variables button:

      ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/image3.png)

  4. Create `CYCODE_CLIENT_ID` and `CYCODE_CLIENT_SECRET` variables with values matching your ID and Secret Key, respectively:

      ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/image4.png)

  5. Insert the cycode.exe into the path to complete the installation.



  Cycode’s pre-commit hook can be set up within your local repository so that the Cycode CLI application will identify any issues with your code automatically before you commit it to your codebase.

  > [!NOTE]
  > pre-commit hook is only available to Secrets and SCA scans.

  Perform the following steps to install the pre-commit hook:

  1. Install the pre-commit framework (Python 3.8 or higher must be installed):

     `pip3 install pre-commit`

  2. Navigate to the top directory of the local Git repository you wish to configure.

  3. Create a new YAML file named `.pre-commit-config.yaml` (include the beginning `.`) in the repository’s top directory that contains the following:

      ```yaml
      repos:
        - repo: https://github.com/cycodehq/cycode-cli
          rev: v1.11.0
          hooks:
            - id: cycode
              stages:
                - commit
      ```

  4. Modify the created file for your specific needs. Use hook ID `cycode` to enable scan for Secrets. Use hook ID `cycode-sca` to enable SCA scan. If you want to enable both, use this configuration:

      ```yaml
      repos:
        - repo: https://github.com/cycodehq/cycode-cli
          rev: v1.11.0
          hooks:
            - id: cycode
              stages:
                - commit
            - id: cycode-sca
              stages:
                - commit
      ```

  5. Install Cycode’s hook:

     `pre-commit install`

     A successful hook installation will result in the message: `Pre-commit installed at .git/hooks/pre-commit`.

  6. Keep the pre-commit hook up to date:

     `pre-commit autoupdate`

     It will automatically bump "rev" in ".pre-commit-config.yaml" to the latest available version of Cycode CLI.

  > [!NOTE]
  > Trigger happens on `git commit` command.
  > Hook triggers only on the files that are staged for commit.



  The following are the options and commands available with the Cycode CLI application:

  | Option                               | Description                                                        |
  |--------------------------------------|--------------------------------------------------------------------|
  | `-o`, `--output [text\|json\|table]` | Specify the output (`text`/`json`/`table`). The default is `text`. |
  | `-v`, `--verbose`                    | Show detailed logs.                                                |
  | `--help`                             | Show options for given command.                                    |

  | Command                                   | Description                                                                                                                           |
  |-------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
  | [auth](#using-the-auth-command)           | Authenticates your machine to associate CLI with your Cycode account.                                                                 |
  | [configure](#using-the-configure-command) | Initial command to authenticate your CLI client with Cycode using client ID and client secret.                                        |
  | [ignore](#ignoring-scan-results)          | Ignore a specific value, path or rule ID.                                                                                             |
  | [scan](#running-a-scan)                   | Scan content for secrets/IaC/SCA/SAST violations. You need to specify which scan type: `ci`/`commit_history`/`path`/`repository`/etc. |
  | [report](#report-command)                 | Generate report for SCA SBOM.                                                                                                         |
  | version                                   | Show the version and exit.                                                                                                            |





  The Cycode CLI application offers several types of scans so that you can choose the option that best fits your case. The following are the current options and commands available:

  | Option                                                     | Description                                                                                                                                                                                                                                             |
  |------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | `-t, --scan-type [secret\|iac\|sca\|sast]`                 | Specify the scan you wish to execute (`secret`/`iac`/`sca`/`sast`), the default is `secret`                                                                                                                                                             |
  | `--secret TEXT`                                            | Specify a Cycode client secret for this specific scan execution                                                                                                                                                                                         |
  | `--client-id TEXT`                                         | Specify a Cycode client ID for this specific scan execution                                                                                                                                                                                             |
  | `--show-secret BOOLEAN`                                    | Show secrets in plain text. See [Show/Hide Secrets](#showhide-secrets) section for more details.                                                                                                                                                        |
  | `--soft-fail BOOLEAN`                                      | Run scan without failing, always return a non-error status code. See [Soft Fail](#soft-fail) section for more details.                                                                                                                                  |
  | `--severity-threshold [INFO\|LOW\|MEDIUM\|HIGH\|CRITICAL]` | Show only violations at the specified level or higher (supported for the SCA scan type only).                                                                                                                                                           |
  | `--sca-scan`                                               | Specify the SCA scan you wish to execute (`package-vulnerabilities`/`license-compliance`). The default is both                                                                                                                                          |
  | `--monitor`                                                | When specified, the scan results will be recorded in the knowledge graph. Please note that when working in `monitor` mode, the knowledge graph will not be updated as a result of SCM events (Push, Repo creation). (Supported for SCA scan type only). |
  | `--report`                                                 | When specified, a violations report will be generated. A URL link to the report will be printed as an output to the command execution                                                                                                                   |
  | `--no-restore`                                             | When specified, Cycode will not run restore command. Will scan direct dependencies ONLY!                                                                                                                                                                |
  | `--help`                                                   | Show options for given command.                                                                                                                                                                                                                         |

  | Command                                | Description                                                     |
  |----------------------------------------|-----------------------------------------------------------------|
  | [commit_history](#commit-history-scan) | Scan all the commits history in this git repository             |
  | [path](#path-scan)                     | Scan the files in the path supplied in the command              |
  | [pre_commit](#pre-commit-scan)         | Use this command to scan the content that was not committed yet |
  | [repository](#repository-scan)         | Scan git repository including its history                       |



  A repository scan examines an entire local repository for any exposed secrets or insecure misconfigurations. This more holistic scan type looks at everything: the current state of your repository and its commit history. It will look not only for secrets that are currently exposed within the repository but previously deleted secrets as well.

  To execute a full repository scan, execute the following:

  `cycode scan repository {{path}}`

  For example, consider a scenario in which you want to scan your repository stored in `~/home/git/codebase`. You could then execute the following:

  `cycode scan repository ~/home/git/codebase`

  The following option is available for use with this command:

  | Option              | Description                                            |
  |---------------------|--------------------------------------------------------|
  | `-b, --branch TEXT` | Branch to scan, if not set scanning the default branch |



  To scan a specific branch of your local repository, add the argument `-b` (alternatively, `--branch`) followed by the name of the branch you wish to scan.

  Consider the previous example. If you wanted to only scan a branch named `dev`, you could execute the following:

  `cycode scan repository ~/home/git/codebase -b dev`

  or:

  `cycode scan repository ~/home/git/codebase --branch dev`



  > [!NOTE]
  > This option is only available to SCA scans.

  To push scan results tied to the [SCA policies](https://docs.cycode.com/docs/sca-policies) found in an SCA type scan to Cycode's knowledge graph, add the argument `--monitor` to the scan command.

  Consider the following example. The following command will scan the repository for SCA policy violations and push them to Cycode:

  `cycode scan -t sca --monitor repository ~/home/git/codebase`

  or:

  `cycode scan --scan-type sca --monitor repository ~/home/git/codebase`

  When using this option, the scan results from this scan will appear in the knowledge graph, which can be found [here](https://app.cycode.com/query-builder).

  > [!WARNING]
  > You must be an `owner` or an `admin` in Cycode to view the knowledge graph page.



  > [!NOTE]
  > This option is not available to IaC scans.

  To push scan results tied to the [SCA policies](https://docs.cycode.com/docs/sca-policies) found in the Repository scan to Cycode, add the argument `--report` to the scan command.

  `cycode scan -t sca --report repository ~/home/git/codebase`
  `cycode scan -t secret --report repository ~/home/git/codebase`

  or:

  `cycode scan --scan-type sca --report repository ~/home/git/codebase`
  `cycode scan --scan-type secret --report repository ~/home/git/codebase`

  When using this option, the scan results from this scan will appear in the On-Demand Scans section of Cycode. To get to this page, click the link that appears after the printed results:

  > :warning: **NOTE**<br/>
  > You must be an `owner` or an `admin` in Cycode to view this page.

  ![cli-report](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/sca_report_url.png)


  The report page will look something like below:

  ![](https://raw.githubusercontent.com/cycodehq/cycode-cli/main/images/scan_details.png)



  > [!NOTE]
  > This option is only available to SCA scans.

  To scan a specific package vulnerability of your local repository, add the argument `--sca-scan package-vulnerabilities` following the `-t sca` or `--scan-type sca` option.

  Consider the previous example. If you wanted to only run an SCA scan on package vulnerabilities, you could execute the following:

  `cycode scan -t sca --sca-scan package-vulnerabilities repository ~/home/git/codebase`

  or:

  `cycode scan --scan-type sca --sca-scan package-vulnerabilities repository ~/home/git/codebase`



  > [!NOTE]
  > This option is only available to SCA scans.

  To scan a specific branch of your local repository, add the argument `--sca-scan license-compliance` followed by the name of the branch you wish to scan.

  Consider the previous example. If you wanted to only scan a branch named `dev`, you could execute the following:

  `cycode scan -t sca --sca-scan license-compliance repository ~/home/git/codebase -b dev`

  or:

  `cycode scan --scan-type sca --sca-scan license-compliance repository ~/home/git/codebase`



  > [!NOTE]
  > This option is only available to SCA scans.

  To limit the results of the `sca` scan to a specific severity threshold, add the argument `--severity-threshold` to the scan command.

  Consider the following example. The following command will scan the repository for SCA policy violations that have a severity of Medium or higher:

  `cycode scan -t sca --security-threshold MEDIUM repository ~/home/git/codebase`

  or:

  `cycode scan --scan-type sca --security-threshold MEDIUM repository ~/home/git/codebase`



  A path scan examines a specific local directory and all the contents within it, instead of focusing solely on a GIT repository.

  To execute a directory scan, execute the following:

  `cycode scan path {{path}}`

  For example, consider a scenario in which you want to scan the directory located at `~/home/git/codebase`. You could then execute the following:

  `cycode scan path ~/home/git/codebase`




  Cycode CLI supports Terraform plan scanning (supporting Terraform 0.12 and later)

  Terraform plan file must be in JSON format (having `.json` extension)

  _How to generate a Terraform plan from Terraform configuration file?_

  1. Initialize a working directory that contains Terraform configuration file:

      `terraform init`

  2. Create Terraform execution plan and save the binary output:

      `terraform plan -out={tfplan_output}`

  3. Convert the binary output file into readable JSON:

      `terraform show -json {tfplan_output} > {tfplan}.json`

  4. Scan your `{tfplan}.json` with Cycode CLI:

      `cycode scan -t iac path ~/PATH/TO/YOUR/{tfplan}.json`



  A commit history scan is limited to a local repository’s previous commits, focused on finding any secrets within the commit history, instead of examining the repository’s current state.

  To execute a commit history scan, execute the following:

  `cycode scan commit_history {{path}}`

  For example, consider a scenario in which you want to scan the commit history for a repository stored in `~/home/git/codebase`. You could then execute the following:

  `cycode scan commit_history ~/home/git/codebase`

  The following options are available for use with this command:

  | Option                    | Description                                                                                              |
  |---------------------------|----------------------------------------------------------------------------------------------------------|
  | `-r, --commit_range TEXT` | Scan a commit range in this git repository, by default cycode scans all commit history (example: HEAD~1) |



  The commit history scan, by default, examines the repository’s entire commit history, all the way back to the initial commit. You can instead limit the scan to a specific commit range by adding the argument `--commit_range` followed by the name you specify.

  Consider the previous example. If you wanted to scan only specific commits on your repository, you could execute the following:

  `cycode scan commit_history -r {{from-commit-id}}...{{to-commit-id}} ~/home/git/codebase`

  OR

  `cycode scan commit_history --commit_range {{from-commit-id}}...{{to-commit-id}} ~/home/git/codebase`



  A pre-commit scan automatically identifies any issues before you commit changes to your repository. There is no need to manually execute this scan; simply configure the pre-commit hook as detailed under the Installation section of this guide.

  After your install the pre-commit hook and, you may, on occasion, wish to skip scanning during a specific commit. Simply add the following to your `git` command to skip scanning for a single commit:

  `SKIP=cycode git commit -m <your commit message>`





  We use sbt-dependency-lock plugin to restore the lock file for SBT projects.
  To disable lock restore in use `--no-restore` option.

  Prerequisites
  * sbt-dependency-lock Plugin: Install the plugin by adding the following line to `project/plugins.sbt`:
  `addSbtPlugin("software.purpledragon" % "sbt-dependency-lock" % "1.5.1")`



  Each scan will complete with a message stating if any issues were found or not.

  If no issues are found, the scan ends with the following success message:

  `Good job! No issues were found!!! 👏👏👏`

  If an issue is found, a `Found issue of type:` message appears upon completion instead:

  ```bash
  ⛔  Found issue of type: generic-password (rule ID: ce3a4de0-9dfc-448b-a004-c538cf8b4710) in file: config/my_config.py
  Secret SHA: a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0  ⛔
  0 | @@ -0,0 +1 @@
  1 | +my_password = 'h3l***********350'
  2 | \ No newline at end of file
  ```

  In the event an issue is found, review the file in question for the specific line highlighted by the result message. Implement any changes required to resolve the issue, then execute the scan again.



  In the above example, a secret was found in the file `secret_test`, located in the subfolder `cli`. The second part of the message shows the specific line the secret appears in, which in this case is a value assigned to `googleApiKey`.

  Note how the above example obscures the actual secret value, replacing most of the secret with asterisks. Scans obscure secrets by default, but you may optionally disable this feature in order to view the full secret (assuming the machine you are viewing the scan result on is sufficiently secure from prying eyes).

  To disable secret obfuscation, add the `--show-secret` argument to any type of scan, then assign it a `1` value to show the full secret in the result message, or `0` to hide the secret (which is done by default).

  In the following example, a Path Scan is executed against the `cli` subdirectory with the option enabled to display any secrets found in full:

  `cycode scan --show-secret=1 path ./cli`

  The result would then not be obfuscated:

  ```bash
  ⛔  Found issue of type: generic-password (rule ID: ce3a4de0-9dfc-448b-a004-c538cf8b4710) in file: config/my_config.py
  Secret SHA: a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0  ⛔
  0 | @@ -0,0 +1 @@
  1 | +my_password = 'h3110w0r1d!@#$350'
  2 | \ No newline at end of file
  ```



  Using the soft fail feature will not fail the CI/CD step within the pipeline if the Cycode scan detects an issue.
  If an issue occurs during the Cycode scan, using a soft fail feature will automatically execute with success (`0`) to avoid interference.

  To configure this feature, add the `--soft-fail` option to any type of scan. This will force the scan results to succeed (exit code `0`).

  Scan results are assigned with a value of exit code `1` when issues are found in the scan results; this will result in a failure within the CI/CD tool. Use the option `--soft-fail` to force the results with the exit code `0` to have no impact (i.e., to have a successful result).





  ```bash
  ⛔  Found issue of type: generic-password (rule ID: ce3a4de0-9dfc-448b-a004-c538cf8b4710) in file: config/my_config.py
  Secret SHA: a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0  ⛔
  0 | @@ -0,0 +1 @@
  1 | +my_password = 'h3l***********350'
  2 | \ No newline at end of file
  ```



  ```bash
  ⛔  Found issue of type: Resource should use non-default namespace (rule ID: bdaa88e2-5e7c-46ff-ac2a-29721418c59c) in file: ./k8s/k8s.yaml   ⛔

  7 |   name: secrets-file
  8 |   namespace: default
  9 |   resourceVersion: "4228"
  ```



  ```bash
  ⛔  Found issue of type: Security vulnerability in package 'pyyaml' referenced in project 'Users/myuser/my-test-repo': Improper Input Validation in PyYAML (rule ID: d003b23a-a2eb-42f3-83c9-7a84505603e5) in file: Users/myuser/my-test-repo/requirements.txt   ⛔

  1 | PyYAML~=5.3.1
  2 | vyper==0.3.1
  3 | cleo==1.0.0a5
  ```



  ```bash
  ⛔  Found issue of type: Detected a request using 'http://'. This request will be unencrypted, and attackers could listen into traffic on the network and be able to obtain sensitive information. Use 'https://' instead. (rule ID: 3fbbd34b-b00d-4415-b9d9-f861c076b9f2) in file: ./requests.py   ⛔

  2 |
  3 | res = requests.get('http://example.com', timeout=1)
  4 | print(res.content)
  ```



  If your company has set custom remediation guidelines in the relevant policy via the Cycode portal, you'll see a field for “Company Guidelines” that contains the remediation guidelines you added. Note that if you haven't added any company guideline, this field will not appear in the CLI tool.



  Ignore rules can be added to ignore specific secret values, specific SHA512 values, specific paths, and specific Cycode secret and IaC rule IDs. This will cause the scan to not alert these values. The ignore rules are written and saved locally in the `./.cycode/config.yaml` file.

  > :warning: **Warning**<br/>
  > Adding values to be ignored should be done with careful consideration of the values, paths, and policies to ensure that the scans will pick up true positives.

  The following are the options available for the `cycode ignore` command:

  | Option                                     | Description                                                                                                                                                              |
  |--------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | `--by-value TEXT`                          | Ignore a specific value while scanning for secrets. See [Ignoring a Secret Value](#ignoring-a-secret-value) for more details.                                            |
  | `--by-sha TEXT`                            | Ignore a specific SHA512 representation of a string while scanning for secrets. See [Ignoring a Secret SHA Value](#ignoring-a-secret-sha-value) for more details.        |
  | `--by-path TEXT`                           | Avoid scanning a specific path. Need to specify scan type. See [Ignoring a Path](#ignoring-a-path) for more details.                                                     |
  | `--by-rule TEXT`                           | Ignore scanning a specific secret rule ID/IaC rule ID/SCA rule ID. See [Ignoring a Secret or Iac Rule](#ignoring-a-secret-iac-sca-or-sast-rule) for more details.        |
  | `--by-package TEXT`                        | Ignore scanning a specific package version while running an SCA scan. Expected pattern - `name@version`. See [Ignoring a Package](#ignoring-a-package) for more details. |
  | `-t, --scan-type [secret\|iac\|sca\|sast]` | Specify the scan you wish to execute (`secret`/`iac`/`sca`/`sast`), The default value is `secret`                                                                        |
  | `-g, --global`                             | Add an ignore rule and update it in the global `.cycode` config file                                                                                                     |

  In the following example, a pre-commit scan runs and finds the following:

  ```bash
  ⛔  Found issue of type: generic-password (rule ID: ce3a4de0-9dfc-448b-a004-c538cf8b4710) in file: config/my_config.py
  Secret SHA: a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0  ⛔
  0 | @@ -0,0 +1 @@
  1 | +my_password = 'h3l***********350'
  2 | \ No newline at end of file
  ```

  If this is a value that is not a valid secret, then use the `cycode ignore` command to ignore the secret by its value, SHA value, specific path, or rule ID. If this is an IaC scan, then you can ignore that result by its path or rule ID.



  To ignore a specific secret value, you will need to use the `--by-value` flag. This will ignore the given secret value from all future scans. Use the following command to add a secret value to be ignored:

  `cycode ignore --by-value {{secret-value}}`

  In the example at the top of this section, the command to ignore a specific secret value is as follows:

  `cycode ignore --by-value h3110w0r1d!@#$350`

  In the example above, replace the `h3110w0r1d!@#$350` value with your non-masked secret value. See the Cycode scan options for details on how to see secret values in the scan results.



  To ignore a specific secret SHA value, you will need to use the `--by-sha` flag. This will ignore the given secret SHA value from all future scans. Use the following command to add a secret SHA value to be ignored:

  `cycode ignore --by-sha {{secret-sha-value}}`

  In the example at the top of this section, the command to ignore a specific secret SHA value is as follows:

  `cycode ignore --by-sha a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0`

  In the example above, replace the `a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0` value with your secret SHA value.



  To ignore a specific path for either secret, IaC, or SCA scans, you will need to use the `--by-path` flag in conjunction with the `-t, --scan-type` flag (you must specify the scan type). This will ignore the given path from all future scans for the given scan type. Use the following command to add a path to be ignored:

  `cycode ignore -t {{scan-type}} --by-path {{path}}`

  OR

  `cycode ignore --scan-type {{scan-type}} --by-path {{path}}`

  In the example at the top of this section, the command to ignore a specific path for a secret is as follows:

  `cycode ignore -t secret --by-path ~/home/my-repo/config`

  In the example above, replace the `~/home/my-repo/config` value with your path value.

  In the example at the top of this section, the command to ignore a specific path from IaC scans is as follows:

  `cycode ignore -t iac --by-path ~/home/my-repo/config`

  In the example above, replace the `~/home/my-repo/config` value with your path value.

  In the example at the top of this section, the command to ignore a specific path from SCA scans is as follows:

  `cycode ignore -t sca --by-path ~/home/my-repo/config`

  In the example above, replace the `~/home/my-repo/config` value with your path value.



  To ignore a specific secret, IaC, SCA, or SAST rule, you will need to use the `--by-rule` flag in conjunction with the `-t, --scan-type` flag (you must specify the scan type). This will ignore the given rule ID value from all future scans. Use the following command to add a rule ID value to be ignored:

  `cycode ignore -t {{scan-type}} --by-rule {{rule-ID}}`

  OR

  `cycode ignore --scan-type {{scan-type}} --by-rule {{rule-ID}}`

  In the example at the top of this section, the command to ignore the specific secret rule ID is as follows:

  `cycode ignore --scan-type secret --by-rule ce3a4de0-9dfc-448b-a004-c538cf8b4710`

  In the example above, replace the `ce3a4de0-9dfc-448b-a004-c538cf8b4710` value with the rule ID you want to ignore.

  In the example at the top of this section, the command to ignore the specific IaC rule ID is as follows:

  `cycode ignore --scan-type iac --by-rule bdaa88e2-5e7c-46ff-ac2a-29721418c59c`

  In the example above, replace the `bdaa88e2-5e7c-46ff-ac2a-29721418c59c` value with the rule ID you want to ignore.

  In the example at the top of this section, the command to ignore the specific SCA rule ID is as follows:

  `cycode ignore --scan-type sca --by-rule dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b`

  In the example above, replace the `dc21bc6b-9f4f-46fb-9f92-e4327ea03f6b` value with the rule ID you want to ignore.



  > [!NOTE]
  > This option is only available to the SCA scans.

  To ignore a specific package in the SCA scans, you will need to use the `--by-package` flag in conjunction with the `-t, --scan-type` flag (you must specify the `sca` scan type). This will ignore the given package, using the `{{package_name}}@{{package_version}}` formatting, from all future scans. Use the following command to add a package and version to be ignored:

  `cycode ignore --scan-type sca --by-package {{package_name}}@{{package_version}}`

  OR

  `cycode ignore -t sca --by-package {{package_name}}@{{package_version}}`

  In the example below, the command to ignore a specific SCA package is as follows:

  `cycode ignore --scan-type sca --by-package pyyaml@5.3.1`

  In the example above, replace `pyyaml` with package name and `5.3.1` with the package version you want to ignore.



  The applied ignoring rules are stored in the configuration file called `config.yaml`.
  This file could be easily shared between developers or even committed to remote Git.
  These files are always located in the `.cycode` folder.
  The folder starts with a dot (.), and you should enable the displaying of hidden files to see it.



  By default, all `cycode ignore` commands save the ignoring rule to the current directory from which CLI has been run.

  Example: running ignoring CLI command from `/Users/name/projects/backend` will create `config.yaml` in `/Users/name/projects/backend/.cycode`

  ```shell
  ➜  backend  pwd
  /Users/name/projects/backend
  ➜  backend  cycode ignore --by-value test-value
  ➜  backend  tree -a
  .
  └── .cycode
      └── config.yaml

  2 directories, 1 file
  ```

  The second option is to save ignoring rules to the global configuration files.
  The path of the global config is `~/.cycode/config.yaml`,
  where `~` means user\`s home directory, for example, `/Users/name` on macOS.

  Saving to the global space could be performed with the `-g` flag of the `cycode ignore` command.
  For example: `cycode ignore -g --by-value test-value`.



  This is incredibly important to place the `.cycode` folder and run CLI from the same place.
  You should double-check it when working with different environments like CI/CD (GitHub Actions, Jenkins, etc.).

  You could commit the `.cycode` folder to the root of your repository.
  In this scenario, you must run CLI scans from the repository root.
  If it doesn't fit your requirements, you could temporarily copy the `.cycode` folder
  wherever you want and perform a CLI scan from this folder.



  It's important to understand how CLI stores ignore rules to be able to read these configuration files or even modify them without CLI.

  The abstract YAML structure:
  ```yaml
  exclusions:
    *scanTypeName*:
      *ignoringType:
      - *ignoringValue1*
      - *ignoringValue2*
  ```

  Possible values of `scanTypeName`: `iac`, `sca`, `sast`, `secret`.
  Possible values of `ignoringType`: `paths`, `values`, `rules`, `packages`, `shas`.

  > [!WARNING]
  > Values for "ignore by value" are not stored as plain text!
  > CLI stores sha256 hashes of the values instead.
  > You should put hashes of the string when modifying the configuration file by hand.

  Example of real `config.yaml`:
  ```yaml
  exclusions:
    iac:
      rules:
      - bdaa88e2-5e7c-46ff-ac2a-29721418c59c
    sca:
      packages:
      - pyyaml@5.3.1
    secret:
      paths:
      - /Users/name/projects/build
      rules:
      - ce3a4de0-9dfc-448b-a004-c538cf8b4710
      shas:
      - a44081db3296c84b82d12a35c446a3cba19411dddfa0380134c75f7b3973bff0
      values:
      - a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3
      - 60303ae22b998861bce3b28f33eec1be758a213c86c93c076dbe9f558c11c752
  ```





  A software bill of materials (SBOM) is an inventory of all constituent components and software dependencies involved in the development and delivery of an application.
  Using this command you can create an SBOM report for your local project or for your repository URI.

  The following options are available for use with this command:

  | Option                                             | Description                    | Required | Default                                               |
  |----------------------------------------------------|--------------------------------|----------|-------------------------------------------------------|
  | `-f, --format [spdx-2.2\|spdx-2.3\|cyclonedx-1.4]` | SBOM format                    | Yes      |                                                       |
  | `-o, --output-format [JSON]`                       | Specify the output file format | No       | json                                                  |
  | `--output-file PATH`                               | Output file                    | No       | autogenerated filename saved to the current directory |
  | `--include-vulnerabilities`                        | Include vulnerabilities        | No       | False                                                 |
  | `--include-dev-dependencies`                       | Include dev dependencies       | No       | False                                                 |

  The following commands are available for use with this command:

  | Command          | Description                                                     |
  |------------------|-----------------------------------------------------------------|
  | `path`           | Generate SBOM report for provided path in the command           |
  | `repository_url` | Generate SBOM report for provided repository URI in the command |



  To create an SBOM report for a repository URI:\
  `cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> repository_url <repository url>`

  For example:\
  `cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies repository_url https://github.com/cycodehq/cycode-cli.git`



  To create an SBOM report for a path:\
  `cycode report sbom --format <sbom format> --include-vulnerabilities --include-dev-dependencies --output-file </path/to/file> path </path/to/project>`

  For example:\
  `cycode report sbom --format spdx-2.3 --include-vulnerabilities --include-dev-dependencies path /path/to/local/project`



  You may add the `--help` argument to any command at any time to see a help message that will display available options and their syntax.

  To see general help, simply enter the command:

  `cycode --help`

  To see scan options, enter:

  `cycode scan --help`

  To see the options available for a specific type of scan, enter:

  `cycode scan {{option}} --help`

  For example, to see options available for a Path Scan, you would simply enter:

  `cycode scan path --help`

  To see the options available for the ignore scan function, use this command:

  `cycode ignore --help`

  To see the options available for report, use this command:

  `cycode report --help`


  To see the options available for a specific type of report, enter:

  `cycode scan {{option}} --help`


pkgId: 40972a0124817bd3897dbbdbeac9821421d9ae940e7f27bd35227414c923703a
name: python-cyecca
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cyecca/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cyecca-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/CogniPilot/cyecca/actions/workflows/ci.yml/badge.svg)](https://github.com/CogniPilot/cyecca/actions/workflows/ci.yml)

  Estimation and Control with Computer Algebra systems



  * Install poetry: https://python-poetry.org/docs/

  ```bash
  sudo apt install graphviz
  git clone git@github.com:CogniPilot/cyecca.git
  cd cyecca
  poetry install
  poetry shell
  jupyter lab
  ```


pkgId: 2b4080d4586bfab5a7c08b4aeb93692c90fee2c33a9430df216c9c96552ec535
name: python-cygrpc
arch: src
version: 1.0.4.post6
epoch: 0
release: 1
summary: gRPC Micro framework
url: https://github.com/cuemby/python-cygrpc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cygrpc-1.0.4.post6-1.src.rpm
checksum_type: sha256
description:
  Micro-Framwork for gRPC with REST expose support.



  - Using pip
  ```
  pip install cygrpc
  ```
  - Using git repository
  ```
  git+https://github.com/cuemby/python-cygrpc.git#egg=cygrpc
  ```




  Params:

  * host : str =  server host, by default is '0.0.0.0'
  * port : int = server port for listen. by default is 50051
  * max_threads : int =  set threads workers for server, by default is 10
  * interceptors: tuple(InterceptorImplementation) = server interceptors middlewares. by default is None.
  * http_port: int = port for http gateway

  if you decide used all values by default, you can setup the server in less lines
  ```python
  from cygrpc.server import Server
  server = Server()
  server.add_service(calculator_api_pb2_grpc, ServiceImpl)
  server.start()
  ```

  Example using all params:
  ```python
  from cygrpc.server import Server


  server = Server(host="0.0.0.0", port=50051, max_threads=10, interceptors=(MyAuthInterceptor(),))


  server.add_service(calculator_api_pb2_grpc, ServiceImpl)


  server.start()
  ```



  The implementation is the same.

  ```python

  from cygrpc.gateway.http import rest

  class ServiceImpl(calculator_api_pb2_grpc.CalculatorAPIServicer):
      """
      Service logic implementation.
      """

      def Sum(self, request, context):
          total = 0
          for addend in request.addends:
              total += addend

          response = pb.SumResponse(sum=total)
          return response
  ```



  for add rest route add the decorator @rest to method definition:

  ```python

  from cygrpc.gateway.http import rest


  class ServiceImpl(calculator_api_pb2_grpc.CalculatorAPIServicer):
      """
      Service logic implementation.
      """
      @rest("/v1/calculator/sum", method="POST")
      def Sum(self, request, context):
          total = 0
          for addend in request.addends:
              total += addend

          response = pb.SumResponse(sum=total)
          return response
  ```




  - Base Interceptor : Base interceptor implementation for create your custom interceptor

  ```python
  from cygrpc.middleware import CyGrpcInterceptor

  class CustomInterceptor(CyGrpcInterceptor):
      def intercept_service(self, continuation, handler_call_details):
          
          return self.on_success(continuation, handler_call_details)
          
          return self.on_failed(grpc.StatusCode.UNAUTHENTICATED, "Validate authentication failed.")

  ```

  - Authentication interceptor: provider a base for authentication middleware interceptor

  ```python
  from cygrpc.middleware.auth import CyGrpcAuthInterceptor

  class MyAuthInterceptor(CyGrpcAuthInterceptor):
      def auth_process(self, continuation, handler_call_details):
         """"
         ..... my auth validation process ....
         """
         return True
  ```



  - Fabio Moreno <fabio.moreno@cuemby.com>


pkgId: 5c52c1554e65d5cdee8ea134e5bfe87a214456e92a551177311b4ac481cc0d3e
name: python-cylc-rose
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: A Cylc plugin providing support for the Rose rose-suite.conf file.
url: https://cylc.github.io/cylc-doc/latest/html/plugins/cylc-rose.html
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cylc-rose-1.4.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/cylc-rose)](https://pypi.org/project/cylc-rose/)
  [![tests](https://github.com/cylc/cylc-rose/actions/workflows/tests.yml/badge.svg)](https://github.com/cylc/cylc-rose/actions/workflows/tests.yml)
  [![Codecov](https://img.shields.io/codecov/c/github/cylc/cylc-rose)](https://app.codecov.io/gh/cylc/cylc-rose)

  A [Cylc](https://github.com/cylc/cylc-flow) plugin providing support for the
  [Rose](https://github.com/metomi/rose) `rose-suite.conf` file.

  For use with Cylc 8 and Rose 2.



  Install from PyPi:

  ```
  pip install cylc-rose
  ```

  Or Conda:

  ```
  conda install cylc-rose
  ```

  No further configuration is required, Cylc will load this plugin automatically.



  In the past Rose provided a wrapper to Cylc providing additional capabilities
  including workflow installation.

  As of Cylc 8 and Rose 2 some of this functionality has been re-built directly
  in Cylc, the rest has been migrated into this Plugin.

  The last versions of Cylc and Rose which use the wrapper are:

  * Cylc 7
  * Rose 2019

  For all later versions please install this plugin into your Cylc/Rose
  environment for Rose integration.



  This plugin provides support for the `rose-suite.conf` file, namely:

  * Jinja2/EmPy template variables.
  * Scheduler environment variables.
  * File installation.
  * Optional configurations.



  * Support the `root-dir*` configurations, these have been deprecated by
    the new Cylc `symlink dirs` functionality.
  * Graphical configuration editors.



  For developer documentation, see [DEVELOPING](DEVELOPING.md).



  [![Contributors](https://img.shields.io/github/contributors/cylc/cylc-rose.svg?color=9cf)](https://github.com/cylc/cylc-rose/graphs/contributors)
  [![Commit activity](https://img.shields.io/github/commit-activity/m/cylc/cylc-rose.svg?color=yellowgreen)](https://github.com/cylc/cylc-rose/commits/master)
  [![Last commit](https://img.shields.io/github/last-commit/cylc/cylc-rose.svg?color=ff69b4)](https://github.com/cylc/cylc-rose/commits/master)

  * Read the [contributing](CONTRIBUTING.md) page.
  * Development setup instructions are in the
    [developer docs](https://cylc.github.io/cylc-admin/#cylc-8-developer-docs).
  * Involved change proposals can be found in the
    [admin pages](https://cylc.github.io/cylc-admin/#change-proposals).
  * Touch base in the
    [developers chat](https://matrix.to/#/#cylc-general:matrix.org).

  > **Note:** If also developing Cylc and or Rose you may wish to install
    cylc-rose in the same environment before installing cylc-rose.

  ```
  pip install -e cylc-rose[all]
  ```



  [![License](https://img.shields.io/github/license/cylc/cylc-flow.svg?color=lightgrey)](https://github.com/cylc/cylc-flow/blob/master/COPYING)

  Copyright (C) 2008-<span actions:bind='current-year'>2024</span> NIWA &
  British Crown (Met Office) & Contributors.

  Cylc-rose 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.

  Cylc-rose 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
  Cylc-rose.  If not, see [GNU licenses](http://www.gnu.org/licenses/).


pkgId: 40852d4d2b0d1b379c34c136a66b2ddd46002195a712e8673d247b34f2dbb388
name: python-cyluhn
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Fast library to validate and generate check digits using the Luhn algorithm
url: https://github.com/idemockle/cyluhn
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cyluhn-0.2.1-1.src.rpm
checksum_type: sha256
description:
  %timeit cyluhn.verify('136260325312871')
  192 ns ± 0.122 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
  %timeit luhn.verify('136260325312871')


pkgId: 19feb67e8ba14f1d676ae7996eaed8501ef9a7833c7e0e3e2c31a510269b721f
name: python-cymbology
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: financial identifier validation.
url: https://github.com/pmart123/cymbology
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cymbology-0.2.3-1.src.rpm
checksum_type: sha256
description:
  cymbology identifies and validates financial security ids.  Currently the following identifiers are supported:

  1. Sedol
  2. Cusip
  3. Isin


  This package can be used to validate these identifiers, discover the validation error, or create checksum digits.




  ```python
  from cymbology import Isin, cusip_from_isin
  isin = Isin()


  >>> valid_isin = isin.validate('US0378331005')
  >>> valid_isin
  'US0378331005'


  >>> tf = isin.is_valid('US0378331005')
  >>> tf
  True


  check_digit = isin.calculate_checksum('US037833100')


  >>> cusip_from_isin('US0378331005')
  '037833100'
  ```



  This package currently only relies on the standard library, and has not been tested for Python 2.X.



  PYTHONPATH=. py.test --cov



  Idenifiers that rely on alpha-numeric codes should be able to be easily extended.  Feel free to add additional identification algorithmns.  Legal Indenifiers(LEI) ids will be added to master branch of repo soon.


pkgId: f66e5faf7e02a765432e4fac29c49d13b6c0950e98e5ff3d17b9efd40be1a2b1
name: python-cymem
arch: src
version: 2.0.8
epoch: 0
release: 1
summary: Manage calls to calloc/free through Cython
url: https://github.com/explosion/cymem
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cymem-2.0.8-1.src.rpm
checksum_type: sha256
description:
  <a href="https://explosion.ai"><img src="https://explosion.ai/assets/img/logo.svg" width="125" height="125" align="right" /></a>



  cymem provides two small memory-management helpers for Cython. They make it easy
  to tie memory to a Python object's life-cycle, so that the memory is freed when
  the object is garbage collected.

  [![tests](https://github.com/explosion/cymem/actions/workflows/tests.yml/badge.svg)](https://github.com/explosion/cymem/actions/workflows/tests.yml)
  [![pypi Version](https://img.shields.io/pypi/v/cymem.svg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.python.org/pypi/cymem)
  [![conda Version](https://img.shields.io/conda/vn/conda-forge/cymem.svg?style=flat-square&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/cymem)
  [![Python wheels](https://img.shields.io/badge/wheels-%E2%9C%93-4c1.svg?longCache=true&style=flat-square&logo=python&logoColor=white)](https://github.com/explosion/wheelwright/releases)



  The most useful is `cymem.Pool`, which acts as a thin wrapper around the calloc
  function:

  ```python
  from cymem.cymem cimport Pool
  cdef Pool mem = Pool()
  data1 = <int*>mem.alloc(10, sizeof(int))
  data2 = <float*>mem.alloc(12, sizeof(float))
  ```

  The `Pool` object saves the memory addresses internally, and frees them when the
  object is garbage collected. Typically you'll attach the `Pool` to some cdef'd
  class. This is particularly handy for deeply nested structs, which have
  complicated initialization functions. Just pass the `Pool` object into the
  initializer, and you don't have to worry about freeing your struct at all — all
  of the calls to `Pool.alloc` will be automatically freed when the `Pool`
  expires.



  Installation is via [pip](https://pypi.python.org/pypi/pip), and requires
  [Cython](http://cython.org). Before installing, make sure that your `pip`,
  `setuptools` and `wheel` are up to date.

  ```bash
  pip install -U pip setuptools wheel
  pip install cymem
  ```



  Let's say we want a sequence of sparse matrices. We need fast access, and a
  Python list isn't performing well enough. So, we want a C-array or C++ vector,
  which means we need the sparse matrix to be a C-level struct — it can't be a
  Python class. We can write this easily enough in Cython:

  ```python
  """Example without Cymem

  To use an array of structs, we must carefully walk the data structure when
  we deallocate it.
  """

  from libc.stdlib cimport calloc, free

  cdef struct SparseRow:
      size_t length
      size_t* indices
      double* values

  cdef struct SparseMatrix:
      size_t length
      SparseRow* rows

  cdef class MatrixArray:
      cdef size_t length
      cdef SparseMatrix** matrices

      def __cinit__(self, list py_matrices):
          self.length = 0
          self.matrices = NULL

      def __init__(self, list py_matrices):
          self.length = len(py_matrices)
          self.matrices = <SparseMatrix**>calloc(len(py_matrices), sizeof(SparseMatrix*))

          for i, py_matrix in enumerate(py_matrices):
              self.matrices[i] = sparse_matrix_init(py_matrix)

      def __dealloc__(self):
          for i in range(self.length):
              sparse_matrix_free(self.matrices[i])
          free(self.matrices)


  cdef SparseMatrix* sparse_matrix_init(list py_matrix) except NULL:
      sm = <SparseMatrix*>calloc(1, sizeof(SparseMatrix))
      sm.length = len(py_matrix)
      sm.rows = <SparseRow*>calloc(sm.length, sizeof(SparseRow))
      cdef size_t i, j
      cdef dict py_row
      cdef size_t idx
      cdef double value
      for i, py_row in enumerate(py_matrix):
          sm.rows[i].length = len(py_row)
          sm.rows[i].indices = <size_t*>calloc(sm.rows[i].length, sizeof(size_t))
          sm.rows[i].values = <double*>calloc(sm.rows[i].length, sizeof(double))
          for j, (idx, value) in enumerate(py_row.items()):
              sm.rows[i].indices[j] = idx
              sm.rows[i].values[j] = value
      return sm


  cdef void* sparse_matrix_free(SparseMatrix* sm) except *:
      cdef size_t i
      for i in range(sm.length):
          free(sm.rows[i].indices)
          free(sm.rows[i].values)
      free(sm.rows)
      free(sm)
  ```

  We wrap the data structure in a Python ref-counted class at as low a level as we
  can, given our performance constraints. This allows us to allocate and free the
  memory in the `__cinit__` and `__dealloc__` Cython special methods.

  However, it's very easy to make mistakes when writing the `__dealloc__` and
  `sparse_matrix_free` functions, leading to memory leaks. cymem prevents you from
  writing these deallocators at all. Instead, you write as follows:

  ```python
  """Example with Cymem.

  Memory allocation is hidden behind the Pool class, which remembers the
  addresses it gives out.  When the Pool object is garbage collected, all of
  its addresses are freed.

  We don't need to write MatrixArray.__dealloc__ or sparse_matrix_free,
  eliminating a common class of bugs.
  """
  from cymem.cymem cimport Pool

  cdef struct SparseRow:
      size_t length
      size_t* indices
      double* values

  cdef struct SparseMatrix:
      size_t length
      SparseRow* rows


  cdef class MatrixArray:
      cdef size_t length
      cdef SparseMatrix** matrices
      cdef Pool mem

      def __cinit__(self, list py_matrices):
          self.mem = None
          self.length = 0
          self.matrices = NULL

      def __init__(self, list py_matrices):
          self.mem = Pool()
          self.length = len(py_matrices)
          self.matrices = <SparseMatrix**>self.mem.alloc(self.length, sizeof(SparseMatrix*))
          for i, py_matrix in enumerate(py_matrices):
              self.matrices[i] = sparse_matrix_init(self.mem, py_matrix)

  cdef SparseMatrix* sparse_matrix_init_cymem(Pool mem, list py_matrix) except NULL:
      sm = <SparseMatrix*>mem.alloc(1, sizeof(SparseMatrix))
      sm.length = len(py_matrix)
      sm.rows = <SparseRow*>mem.alloc(sm.length, sizeof(SparseRow))
      cdef size_t i, j
      cdef dict py_row
      cdef size_t idx
      cdef double value
      for i, py_row in enumerate(py_matrix):
          sm.rows[i].length = len(py_row)
          sm.rows[i].indices = <size_t*>mem.alloc(sm.rows[i].length, sizeof(size_t))
          sm.rows[i].values = <double*>mem.alloc(sm.rows[i].length, sizeof(double))
          for j, (idx, value) in enumerate(py_row.items()):
              sm.rows[i].indices[j] = idx
              sm.rows[i].values[j] = value
      return sm
  ```

  All that the `Pool` class does is remember the addresses it gives out. When the
  `MatrixArray` object is garbage-collected, the `Pool` object will also be
  garbage collected, which triggers a call to `Pool.__dealloc__`. The `Pool` then
  frees all of its addresses. This saves you from walking back over your nested
  data structures to free them, eliminating a common class of errors.



  Sometimes external C libraries use private functions to allocate and free
  objects, but we'd still like the laziness of the `Pool`.

  ```python
  from cymem.cymem cimport Pool, WrapMalloc, WrapFree
  cdef Pool mem = Pool(WrapMalloc(priv_malloc), WrapFree(priv_free))
  ```


pkgId: b47b2f8d8254e6a979ff6f64b3fc2c503e034a0f6fbcebe5f1c5fb6b5427ae89
name: python-cymple
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: A productivity enhancer for creating Cypher queries in Python
url: https://pypi.org/project/cymple/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cymple-0.11.0-1.src.rpm
checksum_type: sha256
description:
  A productivity tool for creating Cypher queries in Python.

  [![Documentation Status](https://readthedocs.org/projects/cymple/badge/?version=latest)](https://cymple.readthedocs.io/en/latest/?badge=latest)
  [![Python package](https://github.com/Accenture/Cymple/actions/workflows/python-test.yml/badge.svg)](https://github.com/Accenture/Cymple/actions/workflows/python-test.yml)



  Cymple is a lightweight Python package for creating queries in Cypher, Neo4j's graph database query language.
  Give it a try, it's 'Cymple'!

  Consider using Cymple if you want:
  * auto-completion for writing Cypher
  * to write compound Cypher queries without getting involved with strings
  * to write Cypher queries in a scalable and extensible manner
  * to be able to easily reuse Cypher queries across your code

  ![image](https://user-images.githubusercontent.com/97434370/162214862-2cd00d28-0565-4838-af41-9e0c0f49b090.png)





  ```shell
  pip install cymple
  ```




  Let's take a look at the following snippet.
  ```python
  from cymple import QueryBuilder

  qb = QueryBuilder()
  query = qb.match().node(labels='Person', ref_name='p')
  query = query.where('p.name', '=', '"Michelle"').return_literal('p')
  print(query)
  ```
  This snippet will output the following Cypher query:
  ```cypher
  MATCH (p: Person) WHERE p.name = "Michelle" RETURN p
  ```

  See the `samples` directory for examples.






  Cymple is designed to provide autocompletion on IDEs that support autocompletion. This feature is context aware with respect to the current query being written.


  ![gif1](https://user-images.githubusercontent.com/97434370/162214796-cd1eeb70-9875-4a3c-9008-6bcda7fb4896.gif)



  Two queries can be combined to a create a new one.
  ```python
  qb = QueryBuilder()
  query1 = qb.match().node(labels='Person', ref_name='p').with_('p')
  query2 = qb.match().node(labels='Person', ref_name='q').related_to('friend_of').node(ref_name='p')
  query = query1 + query2
  print(query)
  ```
  This snippet will output the following Cypher query:
  ```cypher
  MATCH (p: Person) WITH p MATCH (q: Person)-[: friend_of]->(p)
  ```



  * Python 3.8+




  We encourage you to help us to improve this package!
  These instructions will give you a copy of the project up and running on your local machine for development and testing purposes.



  ```shell


  python -m venv .venv
  source .venv/bin/activate






  pip install -r requirements-dev.txt
  ```



  * `setuptools` is configured in `setup.cfg`

  * `pycodestyle` is configured in `setup.cfg`

  * `coverage.py` is configured in `pyproject.toml`




  `pytest` is used as a test runner.

  `pytest` configurations reside in `pyproject.toml`

  `pytest` `fixtures` are stored in `tests/conftest.py` file.

  How-to run tests:

  ```shell


  pip install -r requirements-test.txt




  pytest --cov=cymple

  ```


  Adding a new Cypher clause to Cymple consists of few simple steps:
  1. Go to `src/cymple/internal/declarations/`. This directory contains all supported clause declarations.
  2. Add a json file describing the clause and the method(s) interfaces(s) of the new clause that you would like to add to the builder. If you do it for the first time, take a look at existing json files of currently supported Cypher clauses.
  3. Identify all the existing clauses that can precede your new clause, and add your new clause's name to the 'successors' list of those clauses' JSONs.
  4. Run `python src/cymple/internal/internal_renderer.py`. This script generates a new `builder.py` file with all clauses that were declared in `src/cymple/internal/declarations/`.
  5. By default, by adding a declaration json file, the `internal_builder.py` script takes the declared clause and generates a method that simply concatenates your new clause to the builder's current query. However, if you need anything more complex than that, you can write your own implementation by creating a new method with your clause's name at `src/cymple/internal/overloads/`. Don't forget to run `python src/cymple/internal/internal_renderer.py` again :)
  6. If you're satisfied with the new clause, add a unit test in `test_clauses.py` and make sure it generates the expected Cypher string.



  Make sure you run:
  ```
  pip install -r requirements-dev.txt
  ```
  or
  ```
  pip install sphinx
  ```
  to proceed.

  To generate a new HTML documentation, run:
  ```
  cd docs
  make clean html
  make html
  ```



  [Semantic Versioning](http://semver.org/) is used for versioning.

  For the versions available, see the tags on the repository.

  Current version is stored in `src/cymple/version.py`.




  ```shell
  cymple/
  ├── docs/   # Project documentation
  ├── pyproject.toml  # Development and packaging tools configurations
  ├── README.md  # Project general information
  ├── requirements-dev.txt  # Development dependencies, such as packaging tools, etc.
  ├── requirements-test.txt  # Test dependencies
  ├── requirements.txt       # Pinned versions of all the end-user dependency tree
  ├── setup.cfg  # packaging tool configurations
  ├── setup.py   # Packaging script
  ├── src/  # All source code
  │   └── cymple/  # Cymple source code
  │       ├── internal/  # Cypher builder internal renderer
  │       │   ├── declarations/        # clause declarations
  │       │   ├── overloads/           # custom clause implementations
  │       │   ├── finale.py            # A part of the rendered code that comes last
  │       │   ├── internal_renderer.py # Internal renderer implementation for creating Cymple's user-facing code
  │       │   └── preface.py           # A part of the rendered code that comes first
  │       ├── __init__.py  # Package initialization
  │       ├── __main__.py  # Main script when run as a command line tool
  │       ├── builder.py   # Query Builder implementation
  │       ├── typedefs.py  # Query Builder typedefs to be used in Cymple's API
  │       └── version.py   # Package version
  └── tests/  # Tests
      ├── conftest.py  # Fixtures
      ├── data/  # Tests data files, such as input/output files, mocks, etc.
      ├── e2e/   # End-to-End functional tests
      ├── integration  # Integration tests
      └── unit  # Unit tests
          ├── __init__.py
          └── test_real_use_cases.py  # Test project startup


  ```


pkgId: e82dd9773fb8218b9b4b1e4fe9e6e36add3db1c53f91296ce292cb17c7a99f28
name: python-cymruwhois
arch: src
version: 1.6
epoch: 0
release: 1
summary: Client for the whois.cymru.com service
url: http://packages.python.org/cymruwhois/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cymruwhois-1.6-1.src.rpm
checksum_type: sha256
description:
  Perform lookups by ip address and return ASN, Country Code, and Netblock Owner::

  >>> import socket
  >>> ip = socket.gethostbyname("www.google.com")
  >>> from cymruwhois import Client
  >>> c=Client()
  >>> r=c.lookup(ip)
  >>> print r.asn
  15169
  >>> print r.owner
  GOOGLE - Google Inc.


pkgId: 22622dafef7c2038067ce2732e6e375247c27cabad0e1b6a774924c1ae1311df
name: python-cynthion
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Python package and utilities for the Great Scott Gadgets Cynthion USB Test Instrument
url: https://pypi.org/project/cynthion/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cynthion-0.1.7-1.src.rpm
checksum_type: sha256
description:
  This software is developed for python3.



  Unless you are developing software or testing software from git, you can
  install or update Cynthion software with:
  ```
  pip3 install --upgrade cynthion
  ```


pkgId: be8db3cfb110236356d868f3dfaa79526189dc3937af77c819c279670d4310e1
name: python-cyral-gimme-db-token
arch: src
version: 0.8.4
epoch: 0
release: 1
summary: Eases using Cyral for SSO login to databases.
url: https://pypi.org/project/cyral-gimme-db-token/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cyral-gimme-db-token-0.8.4-1.src.rpm
checksum_type: sha256
description:
  The Cyral Gimme DB Token is a tool used for easing the process of SSO login to databases through the command line.


  This tool is **deprecated** and no longer valid with Cyral Control Plane version `4.12` or later. Please use the [Cyral CLI](https://pypi.org/project/cyral/) to retrieve tokens going forward.


pkgId: 3a560bccca43a78ffc21dcdbd6625e073e8f7d5f95c96f6e678a62818828b2c3
name: python-cyrating
arch: src
version: 1.0.17
epoch: 0
release: 1
summary: Python wrapper for https://www.cyrating.com
url: https://www.cyrating.com
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cyrating-1.0.17-1.src.rpm
checksum_type: sha256
description:
  A python wrapper for Cyrating https://www.cyrating.com.

  [![Latest PyPI Release](https://img.shields.io/pypi/v/cyrating.svg)](https://pypi.org/project/cyrating/)
  [![License](https://img.shields.io/pypi/l/cyrating.svg)](https://github.com/wq/python-requirejs/blob/master/LICENSE)
  [![Python Support](https://img.shields.io/pypi/pyversions/cyrating.svg)](https://pypi.org/project/cyrating/)



  ```sh
  pip install cyrating
  ```

  Then in your application root directory use the following command to set up your configuration including your Cyrating token which is provided in your user interface:

  ```sh
  echo -e "[cyrating]\ntoken: cyratingtoken" > cyrating.ini
  ```



  ```python
  >>> import cyrating
  >>> cr = cyrating.init()
  ```

  The init method takes into account 2 optional parameters:

  - token: the Cyrating token
  - proxies: the list of proxies to use when making a request. See [requests docs](https://requests.readthedocs.io/en/master/user/advanced/#proxies) for more information

  Additional methods listed below are available

  | Method         | Description                                                                                           |
  | -------------- | ----------------------------------------------------------------------------------------------------- |
  | main_company   | returns the structure of the main company                                                             |
  | entities       | returns a list of entities                                                                            |
  | suppliers      | returns a list of suppliers                                                                           |
  | competitors    | returns a list of competitors                                                                         |
  | domains        | returns a list of domains for a company                                                               |
  | assets         | returns a list of assets for a given company                                                          |
  | technologies   | returns a list of identified technologies for a given company                                         |
  | set_tags       | sets tags to a given domain (require admin privileges)                                                |
  | facts          | returns the results of best practices controls                                                        |
  | events         | returns a list of active reputation events                                                            |
  | certificate    | returns a certificate of a given company                                                              |
  | members        | returns a list of members, including child subscriptions' ones (require admin privileges)             |
  | rating_history | returns a list of the last 52 ratings numbers for a given company                                     |
  | scope          | returns a list of the last 52 scopes (domain names) taking into account for rating of a given company |
  | scope_updates  | returns a list of the last scope updates including added and removed domains                          |



  **Get info of the main company**
  The method main_company returns a company identified as the main company.

  ```python
  >>> cr.main_company()
  [...]
  ```

  **Get the list of entities**
  The method entities returns the list of companies identified as entities.

  ```python
  >>> cr.entities()
  [...]
  ```

  **Get the list of suppliers**
  The method suppliers returns the list of companies identified as suppliers.

  ```python
  >>> cr.suppliers()
  [...]
  ```

  **Get the list of competitors**
  The method competitors returns the list of companies identified as competitors.

  ```python
  >>> cr.suppliers()
  [...]
  ```

  **Tag a domain or an AS Number**
  The method set_tags affects a list of tags to a domain name or an AS Number. All assets related with this domain name or with this AS Number will be updated too.

  ```python
  >>> cr.set_tags('example.com', ['tag1', 'tag2'])
  [...]
  >>> cr.set_tags('ASXXXXX', ['tag3'])
  [...]
  ```

  **Get the list of assets**

  The method assets returns a list of assets with tags and type attributes. Each key of this dictionary represents an asset and is linked to the following attributes:

  - asset: the asset name
  - type: type of the asset, may be 'domain', 'host' or 'ip'
  - country: geolocation data for IP assets only
  - entities: list of entities linked with the asset. Entities are the ones included in the subscription.
  - tags: list of tags linked with the asset
  - related: list of assets linked with the asset
  - domains: list of domains linked with the asset

  ```python
  >>> cr.assets(main_company)
  [...]
  ```

  **Get the list of detected technologies**

  The method technologies returns a list of detected technologies for a given company. _assets_
  parameter is optional and is needed to provide tags association

  Each item of the detected technologies includes the following attributes:

  - name: name of the detected technology
  - category: name of the technology category
  - asset: name of the asset supporting the detected technology
  - domain: domain name / AS Number linked with the asset
  - entities: list of entities linked with the asset. Entities are the ones included in the subscription.
  - tags: list of tags linked with the asset

  ```python
  >>> main_company = cr.main_company()
  >>> cr.technologies(main_company, assets=cr.assets(main_company))
  [...]
  ```

  **Get the results of best practices controls**

  The method facts returns the results of best practices controls. _assets_
  parameter is optional and is needed to provide tags association. _extra_filter_ is also an optional to filter results server-side.

  Each item of the results includes the following attributes:

  - domain: domain name / AS Number linked with the asset
  - category: name of the best practice's category
  - entities: list of entities linked with the asset. Entities are the ones included in the subscription.
  - tags: list of tags linked with the asset
  - type: type of the asset, may be 'domain', 'host' or 'ip'
  - name: name of the resource
  - results: raw results of the control
  - grade: unitary score of the control
  - impact: impact on rating of controls which lead to a downgrade.

  ```python
  >>> main_company = cr.main_company()
  >>> cr.facts(main_company, assets=cr.assets(main_company))
  [...]
  ```

  **Get the list of active reputation events**

  The method events returns a list of active reputation events. _assets_
  parameter is optional and is needed to provide tags association.

  An active reputation event includes the following attributes:

  - name: name of the asset concerned
  - category: name of the reputation's category
  - domains: list of domains / AS Numbers linked with the asset
  - entities: list of entities linked with the asset. Entities are the ones included in the subscription.
  - tags: list of tags linked with the asset
  - type: type of the asset, may be 'domain', 'host' or 'ip'
  - source: a dictionary with the tag and the url of the reputation source
  - occurrences: dates of occurrences of the event
  - score: deprecated, replaced by impact
  - impact: impact on rating of the company. Please note that Cyrating algorithm streamlines this score by resource and reputation's category

  ```python
  >>> main_company = cr.main_company()
  >>> cr.events(main_company, assets=cr.assets(main_company))
  [...]
  ```

  **Returns certificate of a given company**

  ```python
  >>> main_company = cr.main_company()
  >>> cr.certificate(main_company)
  ```

  **Save the certificate of a given company to a file**

  ```python
  >>> main_company = cr.main_company()
  >>> cr.certificate(main_company, filename='Cyrating - Certificate of {}.pdf'.format(main_company['name']))
  ```

  **Get the list of members**

  ```python
  >>> cr.members()
  [...]
  ```

  **Get a list of the last 52 ratings for a given company**

  ```python
  >>> main_company = cr.main_company()
  >>> cr.rating_history(main_company)
  [...]
  ```

  **Get a list of the last 52 scopes for a given company**

  The method scope returns a list of the last 52 scopes for a given _company_. A scope is a list of domain names taking into account for rating of a given company

  A scope includes the following attribute:

  - domainnames: list of domains names supporting our rating

  ```python
  >>> main_company = cr.main_company()
  >>> cr.scope(main_company)
  [...]
  ```

  **Get a list of scope updates**

  An additional method is available to get scope updates for a given company including added domains and removed domains between several ratings.

  A scope includes the following attributes:

  - added: domains added to a rating scope
  - removed: domains removed from a rating scope
  - date: date of rating

  ```python
  >>> main_company = cr.main_company()
  >>> scope = cr.scope(main_company)
  >>> updates = cr.scope_updates(scope)
  [...]
  ```



  After version 1.0.15, the method assets returns a list instead of a dictionary



  Cyrating – [@cyrating](https://twitter.com/cyrating) – hello@cyrating.com

  Distributed under the ISCL licence. See `LICENSE` for more information.



  1. Send issues to issues@cyrating.com


pkgId: 48f37bbbc03406f04529be0df2196f047a12f0585135d8ed8a0cbd9ef3d34d1d
name: python-cyrebro-domain-validator
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A domain validation package, written by CYREBRO's Innovation team.
url: https://github.com/CYREBRO/cyrebro-domain-validator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cyrebro-domain-validator-0.3.1-1.src.rpm
checksum_type: sha256
description:
  CYREBRO's domain validator checks for:
  1. **regex validity** - deep regex, includes a list of known TLDs.
  3. **HTTP(/s) availability**.
  4. **nslookup**.
  5. **whois**.
  6. **dkim records**.


pkgId: cd4d5946d3a00de9c5fa40c38e702fd1fd8f8272405dc37be962b180dfa4ceb1
name: python-cyrtranslit
arch: src
version: 1.1.1
epoch: 0
release: 1
url: https://github.com/opendatakosovo/cyrillic-transliteration
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cyrtranslit-1.1.1-1.src.rpm
checksum_type: sha256
summary:
  Bi-directional Cyrillic transliteration. Transliterate Cyrillic script to Latin script and vice versa. Supports transliteration for Bulgarian, Montenegrin, Macedonian, Mongolian, Russian, Serbian, Tajik, and Ukrainian.

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


  A Python package for bi-directional transliteration of Cyrillic script to Latin script and vice versa.

  By default, transliterates for the Serbian language. A language flag can be set in order to transliterate to and from Bulgarian, Montenegrin, Macedonian, Mongolian, Russian, Serbian, Tajik, and Ukrainian.


  Transliteration is the conversion of a text from one script to another. For instance, a Latin alphabet transliteration of the Serbian phrase _"Мој ховеркрафт је пун јегуља"_ is _"Moj hoverkraft je pun jegulja"_.


  A citation would be much appreciated if you use CyrTranslit in a research publication:

  [Georges Labrèche. (2023). CyrTranslit (v1.1.1). Zenodo. https://doi.org/10.5281/zenodo.7734906](https://doi.org/10.5281/zenodo.7734906)

  BibTex entry:
  ```bibtex
  @software{georges_labreche_2023_7734906,
    author       = {Georges Labrèche},
    title        = {CyrTranslit},
    month        = mar,
    year         = 2023,
    note         = {{A Python package for bi-directional
                     transliteration of Cyrillic script to Latin script
                     and vice versa. Supports transliteration for
                     Bulgarian, Montenegrin, Macedonian, Mongolian,
                     Russian, Serbian, Tajik, and Ukrainian.}},
    publisher    = {Zenodo},
    version      = {v1.1.1},
    doi          = {10.5281/zenodo.7734906},
    url          = {https://doi.org/10.5281/zenodo.7734906}
  }
  ```


  CyrTranslit is actively used as a reliable tool to advance research! Here's an incomplete list of publications for research projects that have relied on CyrTranslit:
  - Ljajić, Adela & Prodanović, Nikola & Medvecki, Darija & Bašaragin, Bojana & Mitrović, Jelena. (2022). "[Topic Modeling Technique on Covid19 Tweets in Serbian](https://www.researchgate.net/publication/364302202_Topic_Modeling_Technique_on_Covid19_Tweets_in_Serbian)," in 12th International Conference on Information Society and Technology (ICIST), Kopaonik, Serbia.
  - Mussylmanbay, Meiirgali. (2022). "[Addresses Standardization and Geocoding using Natural Language Processing](https://nur.nu.edu.kz/handle/123456789/6705)," Nazarbayev University, Kazakhstan.
  - Jokic, Danka & Stanković, Ranka & Krstev, Cvetana & Šandrih Todorović, Branislava. (2021). "[A Twitter Corpus and Lexicon for Abusive Speech Detection in Serbian](https://drops.dagstuhl.de/opus/volltexte/2021/14549/)," in 3rd Conference on Language, Data and Knowledge (LDK 2021). 10.4230/OASIcs.LDK.2021.13.
  - Lakew, Surafel Melaku (2020). "[Thesis Multilingual Neural Machine Translation for Low Resource Languages](https://surafelml.github.io/phd-thesis/)," University of Trento, Italy.
  - Filo, Denis. (2020). "[Neuronový strojový překlad pro jazykové páry s malým množstvím trénovacích dat: Low-Resource Neural Machine Translation](https://www.fit.vut.cz/study/thesis/23087/.en)," Brno University of Technology, Brno, Czechia.
  - Batanović, Vuk & Nikolic, Bosko. (2019). "[Using Language Technologies to Automate the UNDP Rapid Integrated Assessment Mechanism in Serbian](https://www.researchgate.net/publication/339615659_Using_Language_Technologies_to_Automate_the_UNDP_Rapid_Integrated_Assessment_Mechanism_in_Serbian)," in International Conference on Language Technologies for All: Enabling Linguistic Diversity and Multilingualism Worldwide (LT4All), Paris, France.
  - Brown, J. M. M. & Schmidt, Andreas & Wierzba, Marta (Eds.). (2019). "[Of trees and birds: A Festschrift for Gisbert Fanselow](https://publishup.uni-potsdam.de/opus4-ubp/frontdoor/deliver/index/docId/42654/file/of_trees_and_birds.pdf)," Universitätsverlag Potsdam, Potsdam.
  - Lakew, Surafel Melaku & Erofeeva, Aliia & Federico, Marcello. (2018). "[Neural Machine Translation into Language Varieties](https://aclanthology.org/W18-6316/)," in 3rd Conference on Machine Translation: Research Papers, Brussels, Belgium.
  - Ljajić, Adela & Marovac, Ulfeta. (2018). "[Improving sentiment analysis for twitter data by handling negation rules in the Serbian language](http://www.doiserbia.nb.rs/Article.aspx?ID=1820-02141800013L)," Computer Science and Information Systems. 16. 13-13. 10.2298/CSIS180122013L.
  - Жабран, И., Кикоть, А., Гафияк, А., Бородина, Е., & Алёшин, С. (2017). "[Developing Q-Orca site backend using various Python programming language libraries](https://www.moderntechno.de/index.php/meit/article/view/meit07-03-021)," Modern Engineering and Innovative Technologies, 3(07-03), 48–53.


  CyrTranslit is [hosted in the Python Package Index (PyPI)](https://pypi.python.org/pypi/cyrtranslit) so it can be installed using pip:
  ```
  python -m pip install cyrtranslit         # latest version
  python -m pip install cyrtranslit==1.1.1  # specific version
  python -m pip install cyrtranslit>=1.1.1  # minimum version
  ```


  CyrTranslit currently supports bi-directional transliteration of Bulgarian, Montenegrin, Macedonian, Mongolian, Russian, Serbian, Tajik, and Ukrainian:
  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.supported()
  ['bg', 'me', 'mk', 'mn', 'ru', 'sr', 'tj', 'ua']
  ```

  CyrTranslit can be used both programatically and via command line interface.



  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.to_latin("Съединението прави силата!", "bg")
  "Săedinenieto pravi silata!"
  >>> cyrtranslit.to_cyrillic("Săedinenieto pravi silata!", "bg")
  "Съединението прави силата!"
  ```


  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.to_latin("Република", "me")
  "Republika"
  >>> cyrtranslit.to_cyrillic("Republika", "me")
  "Република"
  ```


  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.to_latin("Моето летачко возило е полно со јагули", "mk")
  "Moeto letačko vozilo e polno so jaguli"
  >>> cyrtranslit.to_cyrillic("Moeto letačko vozilo e polno so jaguli", "mk")
  "Моето летачко возило е полно со јагули"
  ```


  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.to_latin("Амрагаа Сүнжидмаагаа гэсээр ирлээ дээ хө-хө-хө", "mn")
  "Amragaa Sünjidmaagaa geseer irlee dee khö-khö-khö"
  >>> cyrtranslit.to_cyrillic("Amragaa Sünjidmaagaa geseer irlee dee khö-khö-khö", "mn")
  "Амрагаа Сүнжидмаагаа гэсээр ирлээ дээ хө-хө-хө"
  ```


  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.to_latin("Моё судно на воздушной подушке полно угрей", "ru")
  "Moyo sudno na vozdushnoj podushke polno ugrej"
  >>> cyrtranslit.to_cyrillic("Moyo sudno na vozdushnoj podushke polno ugrej", "ru")
  "Моё судно на воздушной подушке полно угрей"
  ```


  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.to_latin("Мој ховеркрафт је пун јегуља")
  "Moj hoverkraft je pun jegulja"
  >>> cyrtranslit.to_cyrillic("Moj hoverkraft je pun jegulja")
  "Мој ховеркрафт је пун јегуља"
  ```


  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.to_latin("Ман мактуб навишта истодам", "tj")
  "Man maktub navišta istodam"
  >>> cyrtranslit.to_cyrillic("Man maktub navišta istodam", "tj")
  "Ман мактуб навишта истодам"
  ```


  ```python
  >>> import cyrtranslit
  >>> cyrtranslit.to_latin("Під лежачий камінь вода не тече", "ua")
  "Pid ležačyj kamin' voda ne teče"
  >>> cyrtranslit.to_cyrillic("Pid ležačyj kamin' voda ne teče", "ua")
  "Під лежачий камінь вода не тече"
  ```


  Sample command line call to transliterate a Russian text file:
  ```bash
  $ cyrtranslit -l RU -i tests/ru.txt -o tests/output.txt
  ```

  Use the -c argument to accomplish the reverse, that is to input latin characters and output cyrillic.

  Use the -h argument for help.

  You can also omit the input and output files and use standard input/output
  ```bash
  $ echo 'Мој ховеркрафт је пун јегуља' | cyrtranslit -l sr
  Moj hoverkraft je pun jegulja
  $ echo 'Moj hoverkraft je pun jegulja' | cyrtranslit -l sr
  Мој ховеркрафт је пун јегуља
  ```

  You can test the "script" by running it directly on the Python command line interface, e.g.:
  ```python
  >>> import sys
  >>> import cyrtranslit.cyrtranslit
  >>> sys.argv.extend(['-l', 'RU'])
  >>> sys.argv.extend(['-i', 'tests/ru.txt'])
  >>> sys.argv.extend(['-o', 'tests/output.txt'])
  >>> cyrtranslit.cyrtranslit.main()
  >>> exit()
  ```



  You can include support for other Cyrillic script alphabets. Follow these steps in order to do so:

  1. Create a new transliteration dictionary in the **[mapping.py](https://github.com/opendatakosovo/cyrillic-transliteration/blob/master/cyrtranslit/mapping.py)** file and reference to it in the _**[TRANSLIT\_DICT](https://github.com/opendatakosovo/cyrillic-transliteration/blob/ab88bb466d12b9a9ad8d3eb6dc86d0bab871175d/cyrtranslit/mapping.py#L326-L360)**_ dictionary.
  2. Watch out for cases where two consecutive Latin alphabet letters are meant to transliterate into a single Cyrillic script letter. These cases need to be explicitly checked for [inside the **to_cyrillic()** function in **\_\_init\_\_.py**](https://github.com/opendatakosovo/cyrillic-transliteration/blob/ab88bb466d12b9a9ad8d3eb6dc86d0bab871175d/cyrtranslit/__init__.py#L62-L191).
  3. Add test cases inside of **[tests.py](https://github.com/opendatakosovo/cyrillic-transliteration/blob/master/tests.py)**.
  4. Add test CLI input files in the **[tests](https://github.com/opendatakosovo/cyrillic-transliteration/tree/master/tests)** directory.
  5. Update the documentation in the **[README.md](https://github.com/opendatakosovo/cyrillic-transliteration/blob/master/README.md)**.
  6. List yourself as one of the contributors.

  Before tagging a release version and deploying to [PyPI](https://pypi.org/):
  1. Update the `version` and `download_url` properties in [setup.py](https://github.com/opendatakosovo/cyrillic-transliteration/blob/master/setup.py).
  2. [Reserve a Zenodo DOI](https://cassgvp.github.io/github-for-collaborative-documentation/docs/tut/6-Zenodo-integration.html) for the release and update this readme's Zenodo badge and [citation instructions](https://github.com/opendatakosovo/cyrillic-transliteration#citation).

  A big thank you to everyone who contributed:
  - Bulgarian 🇧🇬: [@Syndamia](https://github.com/Syndamia) and [@Sparkycz](https://github.com/Sparkycz).
  - Russian 🇷🇺: [@ratijas](https://github.com/ratijas) and [@rominf](https://github.com/rominf).
  - Tajik 🇹🇯: [@diejani](https://github.com/diejani).
  - Ukrainian 🇺🇦: [@AnonymousVoice1](https://github.com/AnonymousVoice1).
  - Mongolian 🇲🇳: [@Serbipunk](https://github.com/Serbipunk).
  - Command Line Interface (CLI): [@ZJaume](https://github.com/ZJaume).


pkgId: 65cfa4202b2f2a9c479420187d3402563014a723a9fe31d657eab70e3e5ddd40
name: python-cysecuretools
arch: src
version: 6.1.0
epoch: 0
release: 1
summary: Python tools for provisioning Cypress/Infineon MCUs
url: https://github.com/Infineon/cysecuretools
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cysecuretools-6.1.0-1.src.rpm
checksum_type: sha256
description:
  This package contains security tools for creating keys, creating certificates, signing user applications, and provisioning Cypress/Infineon MCUs.


  - [HW/SW compatibility](#hwsw-compatibility)
  - [Prerequisites](#prerequisites)
  - [Documentation](#documentation)
  - [Installing package](#installing-package)
  - [Supported devices](#supported-devices)
  - [Interface and Usage](#interface-and-usage)
      - [PSoC 64](#psoc-64)
      - [CYW20829/CYW89829](#cyw20829cyw89829)
      - [XMC7100/7200](#xmc71007200)
  - [Logging](#logging)
  - [Installing libusb driver](#installing-libusb-driver)
  - [Known issues](#known-issues)
  - [License and Contributions](#license-and-contributions)



  <table>
    <thead>
      <tr>
        <td>Target/Kit</td>
        <td>Silicon ID, Silicon Rev., Family ID</td>
        <td>Secure FlashBoot Version</td>
        <td>CyBootloader Version</td>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td colspan="6" style="text-align: center;">512K</td>
      </tr>
      <tr>
        <td>
          cyb06xx5<br>
          cy8cproto&#8209;064b0s3
        </td>
        <td>0xE70D, 0x12, 0x105</td>
        <td>4.0.2.1842</td>
        <td>2.0.1.6441</td>
      </tr>
      <tr>
        <td colspan="6" style="text-align: center;">2M</td>
      </tr>
      <tr>
        <td>
          cyb06xxa<br>
          cy8ckit&#8209;064b0s2&#8209;4343w
        </td>
        <td>0xE470, 0x12, 0x102</td>
        <td>4.0.3.2319</td>
        <td>2.0.2.8102</td>
      </tr>
      <tr>
        <td>
          cys06xxa<br>
          cy8ckit&#8209;064s0s2&#8209;4343w
        </td>
        <td>0xE4A0, 0x12, 0x02</td>
        <td>4.0.3.2319</td>
        <td>2.0.2.8102</td>
      </tr>
      <tr>
        <td colspan="6" style="text-align: center;">1M</td>
      </tr>
      <tr>
        <td>
          cyb06xx7<br>
          cy8cproto&#8209;064s1&#8209;sb<br>
          cy8cproto&#8209;064b0s1&#8209;ble<br>
          cy8cproto&#8209;064b0s1&#8209;ssa
        </td>
        <td>
          0xE262, 0x24, 0x100
          0xE261, 0x24, 0x100
        </td>
        <td>4.0.2.1842</td>
        <td>2.0.0.4041</td>
      </tr>
    </tbody>
  </table>


  <table>
    <thead>
      <tr>
        <td>Target/Kit</td>
        <td>Silicon ID, Silicon Rev., Family ID</td>
        <td>ROM Boot Version</td>
        <td>RAM Applications Version</td>
      </tr>
    </thead>
    <tbody>
    <tr>
      <td>cyw20829</td>
      <td>0xEB43, 0x21, 0x110</td>
      <td>1.2.0.8334</td>
      <td>1.2.0.3073</td>
    </tr>
    <tr>
      <td>cyw89829</td>
      <td>0xEB47, 0x21, 0x110</td>
      <td>1.2.0.8334</td>
      <td>1.2.0.3073</td>
    </tr>
    </tbody>
  </table>


  * General
    * Python 3.8 - 3.12
    * [Installed Infineon OpenOCD](https://github.com/Infineon/openocd/releases)
  * For PSoC 64 / CYW20829 / CYW89829 devices
    * Ensure the KitProg3 programming mode is **CMSIS-DAP Bulk**
    * Ensure the power selection jumper is set to provide 2.5 V to the power supply pin related to eFuse power. This voltage level is required to blow eFuses



  * [PSoC64 Secure MCU Secure Boot SDK User Guide](https://www.cypress.com/documentation/software-and-drivers/psoc-64-secure-mcu-secure-boot-sdk-user-guide)
  * [Changelog](https://github.com/Infineon/cysecuretools/blob/master/CHANGELOG.md)



  The installation of ModusToolbox™ Software 3.1 includes the correct version of Python and CySecureTools 5.0.0. The latest version of CySecureTools is 6.0.0.
  To update the package from the ModusToolbox™ shell (for Windows users):
  * In the ModusToolbox™ GUI open the terminal by clicking the **Terminal** tab in the bottom pane.
  * Then, select a project in the **Project Explorer** to open a shell in the project directory.
  * Enter the following command: `$ pip install --upgrade --force-reinstall edgeprotecttools`


  Install Python 3.12 on your computer. You can download it from https://www.python.org/downloads/.

  Set up the appropriate environment variable(s) for your operating system.

  If Python 2.7 is also installed, make sure that Python312 and Python312\Scripts have higher priority in the
  PATH than CPython27.


  Most distributions of Linux should already have python2 and python3 installed. To verify that python by
  default points to python3 run:
  ```bash
  $ python --version
  ```
  If python3 is not set as default, run the following commands. The number at the end of each command
  denotes a priority:
  ```bash
  $ update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
  $ update-alternatives --install /usr/bin/python python /usr/bin/python3.12 2
  ```


  By default, `python` points to `/usr/bin/python`, which is python2. To make `python` and `pip` resolve to
  python3 versions, execute the following from command line:
  ```bash
  $ echo 'alias python=python3' >> ~/.bash_profile
  $ echo 'alias pip=pip3' >> ~/.bash_profile
  $ source ~/.bash_profile
  $ python --version
  Python 3.12.3
  $ pip --version
  pip 24.0 from
  /Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages/pip (python 3.12)
  ```
  Note: If you use a shell other than bash, update its profile file accordingly. For example `~/.zshrc` if you use zsh instead of `~/.bash_profile`.


  Make sure that you have the latest version of pip installed, use
  the following command.
  ```bash
  $ python -m pip install --upgrade pip
  ```
  Run the following command in your terminal window.
  ```bash
  $ python -m pip install cysecuretools
  ```


  To update the already installed package:
  ```bash
  $ pip install --upgrade --force-reinstall cysecuretools
  ```

  Note 1: During installation, you may see errors saying that cysecuretools requires package version X, but you have package version Y which is incompatible. In most cases, these can be safely ignored.

  Note 2: You can use the following command to show the path to the installed package
  `python -m pip show cysecuretools`.



  Use `device-list` command for output of the supported devices list.
  ```bash
  $ cysecuretools device-list
  ```




  See [README_PSOC64.md](https://github.com/Infineon/cysecuretools/blob/master/docs/README_PSOC64.md)

  See [README_CYW20829.md](https://github.com/Infineon/cysecuretools/blob/master/docs/README_CYW20829.md)

  See [README_XMC7XXX.md](https://github.com/Infineon/cysecuretools/blob/master/docs/README_XMC7XXX.md)



  Every time the tool is invoked, a new log file is created in the _logs_ directory of the project. By default, the console output has INFO logging severity. The log file has the DEBUG logging severity.



  - Using the policy from version 4.0.0 in projects created by version 4.1.0 causes the CY_FB_INVALID_IMG_JWT_SIGNATURE error during re-provisioning on PSoC64-2M devices:
  ```
    ...
    ERROR : SFB status: CY_FB_INVALID_IMG_JWT_SIGNATURE: Invalid image certificate signature. Check the log for details
  ```
  _Workaround_:
  1. Open the policy file.
  2. Navigate to section 1 of the `boot_upgrade/firmware`.
  3. Set `boot_auth` and `bootloader_keys` as follows:
  ```
  "boot_auth": [
      3
  ],
  "bootloader_keys": [
      {
          "kid": 3,
          "key": "../keys/cy_pub_key.json"
      }
  ]
  ```
  - During the installation of the package via _pip_ on Mac OS Big Sur, the following exception is raised:
  ```
    ...
    distutils.errors.DistutilsError: Setup script exited with error: SandboxViolation:
    mkdir('/private/var/root/Library/Caches/com.apple.python/private/tmp/easy_install-y8c1npmz', 511) {}

    The package setup script has attempted to modify files on your system
    that are not within the EasyInstall build area, and has been aborted.

    This package cannot be safely installed by EasyInstall, and may not
    support alternate installation locations even if you run its setup
    script by hand.  Please inform the package's author and the EasyInstall
    maintainers to find out if a fix or workaround is available.
  ```
  _Solution:_ Upgrade the `pip` package running the following command from the terminal: `python3 -m pip install --upgrade pip`.


  The software is provided under the Apache-2.0 license. Contributions to this project are accepted under the same license.
  This project contains code from other projects. The original license text is included in those source files.



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



  - CYW20829 `encrypt` command for pure data encryption without signing
  - `bin-dump` command to create binary file from hex string


  - Extended CYW20829 `sign-image` command with options `--nonce` and `--nonce-output` used for encryption



  - Support for Python 3.12


  - Extended package installation instructions
  - Extended CYW20829/CYW89829 readme with usage examples
  - Drop support for Python versions 3.6 and 3.7



  - Support for CYW89829 devices



  - Support for XMC7100, XMC7200 devices


  - Removed pyOCD support. OpenOCD is used as a default On-Chip debugger for all platforms
  - High-level API module refactoring



  - Support for CYW20829 B0 silicon revision
  - Multi-image NV counter for CYW20829
  - Transition PSoC 64 devices to RMA LCS
  - Open PSoC 64 devices in RMA LCS for debugging
  - OpenOCD autodiscovery in ModusToolbox directory
  - Add SW/HW compatibility table to the readme


  - Target `cyw20829` is used for the latest silicon revision. For the previous silicon revision (A0) add _--rev_ option in the command line (`-t cyw20829 --rev a0`)



  - OpenOCD support for PSoC 64 devices
  - Creating update package in the unsigned image (_extend-image_ command)


  - Fixed installation failure using pip 22.1
  - CyBootloader 2.0.2.8102 for PSoC 64 2M:
    - Improved performance of SWAP algorithm
    - Image certificate signed with the Infineon key (id=3)
    - Use Infineon key (id=3) for bootloader in the policy files



  - Support of CYW20829 devices
  - Support Python 3.10
  - Signing images with HSM


  - Separated PSoC 64 and CYW20829 devices CLI
  - Updated PSoC 64 CyBootloader for 512k and 2M:
    - added "reset_after_failure" feature
    - decreased boot time
  - Protect PSA API from NSPE in PSoC 64 2M-S0 policy
  - Prevent signing of already signed images
  - Change MCUboot image header padding to erase value
  - Use CyBootloader from the project directory if the project exists
  - Updated dependencies packages to the latest versions
  - Use pyocd 0.32.3



  - Fixed installation failure on macOS Big Sur and Apple M1 chip
  - Fixed installation failure in Python 3.9



  - SCRATCH with Status Partition swap mode
  - Small image slots support in the external memory



  - Image SWAP using Status Partition


  - CyBootloader 2.0
  - Secure Flash Boot 4.0.2 support



  - Support PSoC64 1M
  - New command to read device die ID
  - Optionally add boot record to the signed image
  - New policy validators (address overlaps between images and bootloader, slots address alignment with the SMPU address limits, DAP closure, monotonic counter)
  - Log the device response JWT during the provisioning process


  - Fixed issue with using group private key
  - Use pyocd 0.27.3




  - Support PSoC64 2M, PSoC64 512K
  - Command line interface
  - Encrypted programming
  - Single-image and multi-image policy


  - Update provisioning according to new Secure Flash Boot functionality (update system calls, reprovisioning, encrypted image support)
  - New CyBootloaders (CY8CKIT-064B0S2-4343W, CY8CKIT-064S0S2-4343W, CY8CPROTO-064B0S3)
  - Use pyocd 0.27.0


pkgId: 3b941e9f8a99c7362c35d02637e35fc6c8382f49a067016a9b4f6ec96c69824d
name: python-cyte
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Measurements (System International, US Customary, etc.)
url: https://pypi.org/project/cyte/
rpm_license: the health license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cyte-1.0.3-1.src.rpm
checksum_type: sha256
description:
  <body style="padding: 1in;">
  	<header style="text-align: center">
  		<address style="font-size: 2em">cyte</address>
  		<p>measurement tools (System International, US Customary, etc.)</p>
  	</header>

  	<article 1 style="background: #eee; padding: 1in; border-radius: .1in; ">
  		<section>
  			<address>the health license</address>
  		</section>

  		<section>
  			<p>
  				May you metaphorically recognize this as
  				a reservoir of pure water molecules:
  			</p>

  			<code id="water-molecule" python3 style="white-space: pre-wrap;"></code>

  			<p>
  				You discovered it in a
  				place where you have
  				undisputable claim to the
  				entire span of every dimension
  				(including time).

  				<br/>
  				<br/>

  				However, this pure water, may only
  				be used to promote veganism.
  			</p>
  		</section>
  	</article>

  	<article>
  		<p>The documentation is can be read by installing and running "revenue"</p>
  		<code>
  			pip install revenue
  		</code>
  		<code>
  			

  			[tcsh] revenue
  		</code>
  	</article>

  	<script>
  		var water = JSON.stringify ({
  			"structures": {
  				"1": "hydrogen",
  				"2": "hydrogen",
  				"3": "oxygen"
  			},
  			"links": [
  				[ 1, 3 ],
  				[ 2, 3 ]
  			]
  		}, null, 4)
  		document.getElementById ("water-molecule").textContent = water;
  	</script>
  </body>


pkgId: 71130398bd7057391f55d6e69e798cd7ec6c63351b22662b3bbb7b7cb0b7750b
name: python-cython-fortran-file
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: An efficient package to read fortran-record files in Python.
url: https://github.com/cphyc/cython_fortran_file
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cython-fortran-file-0.2.7-1.src.rpm
checksum_type: sha256
description:
  `d`      | `real(8)`    | `double`   | `np.float64`
  `f`      | `real(4)`    | `float`    | `np.float32`
  `i`      | `integer`    | `int`      | `np.int32`
  `l`      | `integer(8)` | `long`     | `np.int64`


pkgId: 57c27516c2df4cb5f8d3b860146a945ba8c3123567647c05683991fbb0c8c9cd
name: python-cython-lint
arch: src
version: 0.16.2
epoch: 0
release: 1
summary: Lint Cython files
url: https://github.com/MarcoGorelli/cython-lint
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cython-lint-0.16.2-1.src.rpm
checksum_type: sha256
description:
  Everything ``flake8`` used to do (by accident), plus much more.
  A tool and pre-commit hook to lint Cython files.

  Here's some major projects using ``cython-lint`` - is yours missing? Feel free to open a pull request!
  - [ansible-pylibssh](https://github.com/ansible/pylibssh)
  - [arrow](https://github.com/apache/arrow)
  - [CuPy](https://github.com/cupy/cupy)
  - [frozenlist](https://github.com/aio-libs/frozenlist)
  - [open library](https://github.com/internetarchive/openlibrary)
  - [pandas](https://github.com/pandas-dev/pandas)
  - [pymatgen](https://github.com/materialsproject/pymatgen)
  - [PyRFC](https://github.com/SAP/PyRFC)
  - [RAPIDS cuspatial](https://github.com/rapidsai/cuspatial)
  - [RAPIDS cudf](https://github.com/rapidsai/cudf)
  - [RAPIDS Memory Manager](https://github.com/rapidsai/rmm)
  - [sagemath/sage](https://github.com/sagemath/sage/issues)
  - [scikit-image](https://github.com/scikit-image/scikit-image)
  - [scikit-learn](https://github.com/scikit-learn/scikit-learn)
  - [scipy](https://github.com/scipy/scipy)
  - [spaCy](https://github.com/explosion/spaCy)
  - [yarl](https://github.com/aio-libs/yarl)
  - [yt](https://github.com/yt-project/yt)

  ```console
  $ pip install cython-lint
  ```

  See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
  Sample `.pre-commit-config.yaml`:
  ```yaml
  -   repo: https://github.com/MarcoGorelli/cython-lint
      rev: v0.16.2
      hooks:
      -   id: cython-lint
      -   id: double-quote-cython-strings
  ```

  ```console
  $ cython-lint my_file_1.pyx my_file_2.pyx
  my_file_1.pyx:54:5: 'get_conversion_factor' imported but unused
  my_file_2.pyx:1112:38: 'mod' defined but unused (try prefixing with underscore?)
  my_file_3.pyx:4:9: dangerous default value!
  my_file_3.pyx:5:9: comma after base type in definition
  ```

  The following configuration options are available:
  - exclude lines by including a ``# no-cython-lint`` comment (analogous to ``# noqa`` in ``flake8``);
  as well as the following command-line arguments:
  - ``--max-line-length`` to control the maximum line length used by pycodestyle;
  - ``--no-pycodestyle`` if you don't want the pycodestyle checks;
  - ``--ignore`` if you want to ignore some specific pycodestyle checks;
  - ``--files`` to pass a Regex pattern with which to match files to include;
  - ``--exclude`` to pass a Regex pattern with which to match files to exclude.
  Configuration can be set project-wise in a `pyproject.toml` file at the root of the project.
  Here's an example `pyproject.toml`:
  ```
  [tool.cython-lint]
  max-line-length = 88
  ignore = ['E503', 'E504']
  exclude = 'my_project/excluded_cython_file.pyx'
  ```

  - assert statement with tuple condition (always true...)
  - comma after base type definition (e.g. ``cdef ndarray, arr``)
  - comparison between constants
  - dangerous default value
  - dict key repeated
  - dict key variable repeated
  - f-string without placeholders
  - if-statement with tuple condition (always true...)
  - late-binding closures https://docs.python-guide.org/writing/gotchas/#late-binding-closures
  - pointless string statement
  - ``pycodestyle`` nitpicks (which you can turn off with ``--no-pycodestyle``)
  - repeated element in set
  - ``.strip``, ``.rstrip``, or ``.lstrip`` used with repeated characters
  - unnecessary list index lookup
  - unnecessary import alias
  - variable defined but unused
  - variable imported but unused
  In addition, the following automated fixers are implemented:
  - double-quote-cython-strings (replace single quotes with double quotes, like the ``black`` formatter does)
  More to come! Requests welcome!


pkgId: 43a0e57d4019fed939e8df735fc955cff8a03ced73c1a276177e1482ab71c74c
name: python-cython-lint
arch: src
version: 0.16.6
epoch: 0
release: 1
summary: Lint Cython files
url: https://github.com/MarcoGorelli/cython-lint
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cython-lint-0.16.6-1.src.rpm
checksum_type: sha256
description:
  Everything ``flake8`` used to do (by accident), plus much more.
  A tool and pre-commit hook to lint Cython files.

  Here's some major projects using ``cython-lint`` - is yours missing? Feel free to open a pull request!
  - [arrow-adbc](https://github.com/apache/arrow-adbc)
  - [ansible-pylibssh](https://github.com/ansible/pylibssh)
  - [arrow](https://github.com/apache/arrow)
  - [CuPy](https://github.com/cupy/cupy)
  - [frozenlist](https://github.com/aio-libs/frozenlist)
  - [open library](https://github.com/internetarchive/openlibrary)
  - [pandas](https://github.com/pandas-dev/pandas)
  - [pymatgen](https://github.com/materialsproject/pymatgen)
  - [PyRFC](https://github.com/SAP/PyRFC)
  - [RAPIDS cuspatial](https://github.com/rapidsai/cuspatial)
  - [RAPIDS cudf](https://github.com/rapidsai/cudf)
  - [RAPIDS Memory Manager](https://github.com/rapidsai/rmm)
  - [sagemath/sage](https://github.com/sagemath/sage/issues)
  - [scikit-image](https://github.com/scikit-image/scikit-image)
  - [scikit-learn](https://github.com/scikit-learn/scikit-learn)
  - [scipy](https://github.com/scipy/scipy)
  - [spaCy](https://github.com/explosion/spaCy)
  - [yarl](https://github.com/aio-libs/yarl)
  - [yt](https://github.com/yt-project/yt)

  ```console
  $ pip install cython-lint
  ```

  See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
  Sample `.pre-commit-config.yaml`:
  ```yaml
  -   repo: https://github.com/MarcoGorelli/cython-lint
      rev: v0.16.6
      hooks:
      -   id: cython-lint
      -   id: double-quote-cython-strings
  ```

  ```console
  $ cython-lint my_file_1.pyx my_file_2.pyx
  my_file_1.pyx:54:5: 'get_conversion_factor' imported but unused
  my_file_2.pyx:1112:38: 'mod' defined but unused (try prefixing with underscore?)
  my_file_3.pyx:4:9: dangerous default value!
  my_file_3.pyx:5:9: comma after base type in definition
  ```

  The following configuration options are available:
  - exclude lines by including a ``# no-cython-lint`` comment (analogous to ``# noqa`` in ``flake8``);
  as well as the following command-line arguments:
  - ``--max-line-length`` to control the maximum line length used by pycodestyle;
  - ``--no-pycodestyle`` if you don't want the pycodestyle checks;
  - ``--ignore`` if you want to ignore some specific pycodestyle checks;
  - ``--files`` to pass a Regex pattern with which to match files to include;
  - ``--exclude`` to pass a Regex pattern with which to match files to exclude.
  Configuration can be set project-wise in a `pyproject.toml` file at the root of the project.
  Here's an example `pyproject.toml`:
  ```
  [tool.cython-lint]
  max-line-length = 88
  ignore = ['E503', 'E504']
  exclude = 'my_project/excluded_cython_file.pyx'
  ```

  - assert statement with tuple condition (always true...)
  - comma after base type definition (e.g. ``cdef ndarray, arr``)
  - comparison between constants
  - dangerous default value
  - dict key repeated
  - dict key variable repeated
  - f-string without placeholders
  - if-statement with tuple condition (always true...)
  - late-binding closures https://docs.python-guide.org/writing/gotchas/#late-binding-closures
  - pointless string statement
  - ``pycodestyle`` nitpicks (which you can turn off with ``--no-pycodestyle``)
  - repeated element in set
  - ``.strip``, ``.rstrip``, or ``.lstrip`` used with repeated characters
  - unnecessary list index lookup
  - unnecessary import alias
  - variable defined but unused
  - variable imported but unused
  In addition, the following automated fixers are implemented:
  - double-quote-cython-strings (replace single quotes with double quotes, like the ``black`` formatter does)
  More to come! Requests welcome!


pkgId: d10d7b05939ed4e426cc310c7bc8a65e4a8552281c9bb314f7a1098ba1a9cb28
name: python-cython-setuptools
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Cython setuptools integration
url: https://github.com/flupke/cython-setuptools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cython-setuptools-0.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/flupke/cython-setuptools.svg?branch=master)](https://travis-ci.org/flupke/cython-setuptools)

  Easier distribution and development of Cython modules.

  Features:

  * Two distribution models: with C/C++ files included in the package, and
    without
  * Cython modules are defined in `setup.cfg`
  * Install directly from Cython sources, without installing Cython in the target
    environment (Cython is only included in `install_requires`)



  ```shell
  $ pip install cython-setuptools
  ```



  Here is an example Python package using the default distribution model (only
  Cython files are included in the source package).

  First install the `cython-setuptools` vendor module in the package, next to
  `setup.py`.

  ```shell
  $ cd your-python-project/
  $ cython-setuptools install
  ```

  Then use `cython-setuptools`' `setup()` in your `setup.py`:

  ```python
  from cysetuptools import setup

  setup()
  ```

  Note that we keep the default `cythonize=True` argument of `setup()` here,
  meaning that C files are compiled from Cython files automatically.
  `setup(cythonize=False)` would mean we would need to distribute the C/C++ files
  compiled from Cython in the source package.

  Define your Cython modules in `setup.cfg`.

  ```ini
  [metadata]
  name = your-python-project
  version = 1.0

  [options]
  packages = find:
  install_requires = cython

  [options.extras_require]
  dev = cython

  [cython-defaults]
  include_dirs = include/

  [cython-module: foo.bar]
  sources = foo.pyx
            bar.cpp
  include_dirs = eval(__import__('numpy').get_include())
  language = c++
  pkg_config_packages = opencv
  ```

  Then your Cython modules can be compiled and tested in-place with:

  ```shell
  $ python setup.py build_ext --inplace
  ```

  This automatically compile outdated Cython files. If `setup(cythonize=False)`
  is used, you have to specifically tell the setup to recompile outdated Cython
  files:

  ```shell
  $ CYTHONIZE=1 python setup.py build_ext --inplace
  ```


pkgId: e41a0ed4bde724119cad468bde51b1751f9c2ab372f01bf554e3d146e66e3214
name: python-cythonbuilder
arch: src
version: 0.1.24
epoch: 0
release: 1
summary: CythonBuilder; automated compiling and packaging of Cython code
url: https://github.com/mike-huls/cythonbuilder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cythonbuilder-0.1.24-1.src.rpm
checksum_type: sha256
description:
  ![coverage](https://img.shields.io/codecov/c/github/mike-huls/cythonbuilder)
  ![Tests](https://github.com/mike-huls/cythonbuilder/actions/workflows/tests.yml/badge.svg)
  ![version](https://img.shields.io/pypi/v/cythonbuilder?color=%2334D058&label=pypi%20package)
  ![dependencies](https://img.shields.io/librariesio/release/pypi/cythonbuilder)
  ![PyPI Downloads](https://img.shields.io/pypi/dm/cythonbuilder.svg?label=PyPI%20downloads)
  ![versions](https://img.shields.io/pypi/pyversions/cythonbuilder.svg?color=%2334D058)
  <br>
  ![tweet](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fmike-huls%2Fcythonbuilder) ![xfollow](https://img.shields.io/twitter/follow/mike_huls?style=social)


  CythonBuilder makes it easy to use Cython in your Python project by automating the building process.
  You can use CythonBuilder from the commandline or import it as a package in Python.
  Generated files can be imported in Python directly

  ```sh
  pip install cythonbuilder
  ```



  Add `-v` (verbose) for more information
  1. Listing files with and without filter
  ```commandline
  cybuilder list
  cybuilder list --files file1 file2.pyx
  ```

  2. Build with and without optional build arguments
  ```commandline
  cybuilder build
  cybuilder build --include-numpy --no-annotation --no-cleanup
  ```

  3. Clean
  ```commandline
  cybuilder clean
  cybuilder clean --no-cleanup
  ```

  <hr>


  1. Listing files with and without filter

  ```python
  import cythonbuilder

  print(cythonbuilder.cy_list())  # without a filter
  print(cythonbuilder.cy_list(target_files=['some_name.pyx']))  # with a filter
  ```

  2. Build with and without optional build arguments  (cleans automatically afterwards)

  ```python
  import cythonbuilder

  cythonbuilder.cy_build()

  found_files = cythonbuilder.cy_build(target_files=['some_name'])
  cythonbuilder.cy_build(target_files=found_files, include_numpy=False, create_annotations=False)
  ```

  3. Clean

  ```python
  import cythonbuilder

  cythonbuilder.cy_clean()

  found_files = cythonbuilder.cy_build(target_files=['some_name'])
  cythonbuilder.cy_clean(target_files=['some_name'])
  ```

  4. Setting debug level for verbose logging

  ```python
  import logging
  from . import logger

  logger.setLevel(logging.DEBUG)
  ```


  I've written a few articles that explain why Python is slow, why Cython can be a solution and how CythonBuilder helps us develop fast code easily:
  - [Why Python is so slow and how to speed it up](https://mikehuls.com/why-is-python-so-slow-and-how-to-speed-it-up-6720e14a1ca260001b1c0cba)
  - [Getting started with Cython; how to perform >1.7 billion calculations per second with Python](https://mikehuls.com/getting-started-with-cython-how-to-perform-1-7-billion-calculations-per-second-in-python-6720e14a1ca260001b1c0ccf)
  - [Cython for data science: 6 steps to make this Pandas dataframe operation over 100x faster](https://mikehuls.com/cython-for-data-science-6-steps-to-make-this-pandas-dataframe-operation-over-100x-faster-6720e14a1ca260001b1c0d07/)


pkgId: 3c44f0194190c3b072b5615c2d10adfcd8e1d4aaae48fdb9b8dc29e1be07f05d
name: python-cythonevparser
arch: src
version: 0.15
epoch: 0
release: 1
summary: eventparser parser for Android
url: https://github.com/hansalemaos/cythonevparser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cythonevparser-0.15-1.src.rpm
checksum_type: sha256
description:
  ```PY
  import time
  import re as regexpython
  import regex as re
  from cythonevparser import clean_cache, create_temp_memdisk, EvParse
  from cythondfprint import add_printer
  import pandas as pd
  from exceptdrucker import errwrite
  import shutil
  import os

  import subprocess

  add_printer(1)



  def sendcmd(openshell, inputcmd, shell=True, timeout=10):
      try:
          p = subprocess.run(
              openshell,
              input=inputcmd if isinstance(inputcmd, bytes) else inputcmd.encode(),
              shell=shell,
              env=os.environ,
              cwd=os.getcwd(),
              capture_output=True,
              timeout=10,
          )
          return p.stdout, p.stderr, p.returncode
      except Exception as e:
          print(e)
      return None, None, None


  def iskeyboardshown():
      try:
          stdout, stderr, returncode = sendcmd(
              openshell, keyboard_shown, shell=False, timeout=10
          )
          print(stdout, stderr, returncode)
          if b"mVisibleBound=true" in stdout and b"mInputShown=true" in stdout:
              return True
          return False
      except Exception as fe:
          errwrite()
      return False



  clean_cache()
  adb_exe = shutil.which("adb")
  device_serial = "127.0.0.1:5560"
  elements2check_regex = regexpython.compile(
      r"(?:(?:StateListAnimatorButton)|(?:p\.ral)|(?:android\.widget\.NumberPicker\$CustomEditText)|(?:AppCompatCheckBox))"
  )
  elements2check_min_area = 0.0001
  elements2check_max_area = 50
  sleep_after_each_dataframe = 0.1
  screen_width = 720
  screen_height = 1280

  keyboard_shown = b'dumpsys input_method | grep -E "mInputShown|mVisibleBound"'
  openshell = [
      adb_exe,
      "-s",
      device_serial,
      "shell",
  ]
  create_temp_memdisk(
      memdisk_path="/media/ramdisk",
      adb_path=adb_exe,
      device_serial=device_serial,
      memdisk_size="128M",
      shell=False,
      su_exe="su",
  )
  evp = EvParse(
      adb_exe=adb_exe,
      device_serial=device_serial,
      field_size=50,
      record_count=50,
      sleep_between_each_scan=0.001,
      regex_nogil=True,
      device_shell="shell",
      uiautomator_cmd=b"uiautomator events",
      sleep_after_starting_thread=5,
      thread_daemon=True,
      uiautomator_kill_cmd=b"pkill uiautomator",
      timeout_scan=0.1,
      screen_width=screen_width,
      screen_height=screen_height,
      subproc_shell=False,
      with_children=False,
      add_screenshot=False,
      screenshot_kwargs=None,
      input_tap_center_x="aa_center_x",
      input_tap_center_y="aa_center_y",
      input_tap_input_cmd="input touchscreen tap",
      input_tap_kwargs=None,
      sendevent_mouse_move_start_x="aa_start_x",
      sendevent_mouse_move_start_y="aa_start_y",
      sendevent_mouse_move_end_x="aa_end_x",
      sendevent_mouse_move_end_y="aa_end_y",
      sendevent_mouse_move_y_max=65535,
      sendevent_mouse_move_x_max=65535,
      sendevent_mouse_move_inputdev="/dev/input/event5",
      sendevent_mouse_move_add=True,
      sendevent_mouse_move_kwargs=None,
      sendevent_mouse_move_su_exe="su",
      sendevent_mouse_move_sh_device="sh",
      sendevent_mouse_move_cwd_on_device="/media/ramdisk",
      sendevent_mouse_move_qty_blocks=4 * 24,
      debug=True,
      limited_mouse_move=True,
      scroll_x_begin_center_offset=30,
      scroll_y_begin_center_offset=30,
      scroll_x_end_center_offset=30,
      scroll_y_end_center_offset=30,
      add_move_and_tap=True,
  )
  callback_function_kwargs = {}
  callback_function_kwargs["regex_to_check"] = rb"\bcom\..*"
  callback_function_kwargs["regex_flags"] = re.IGNORECASE
  evp.kill_ui_automator(["sh"])
  time.sleep(5)
  allresultdata = []


  foundall = False
  goodresults = []
  result = evp.start_event_parser(
      callback_function=evp.callback_function,
      max_timeout=0.1,
      callback_function_kwargs=callback_function_kwargs,
      sleep_between_each_scan=0.01,
      print_elements=False,
  )
  myemail = "mariadanada@maya.com"
  mypassword = "bonadnxa!Dx71"
  evp.data_array[:] = b""
  screenshotfolder = r"C:\savedshots"
  df = pd.DataFrame()
  rotcount = 0
  emailput = False
  killfirst = False
  F = set()


  while not foundall:
      try:
          time.sleep(2)
          dfx = evp.parse_elements_dataframe(with_children=True, with_windows=True)
          
          evp.last_results.clear()
          for name, group in (
              dfx.loc[
                  (dfx.aa_area > 0)
                  & (dfx.aa_area_percentage < 50)
                  & (dfx.aa_all_my_children.str.len() < 2)
                  & (~dfx.aa_pflag_invalidated.str.contains("I", regex=False, na=False))
                  & dfx.aa_enabled.str.contains("E", regex=False, na=False)
                  & (~dfx.aa_visibility.str.contains("I", regex=False, na=False))
                  & (dfx.aa_pflag_dirty_mask.str.contains(".", regex=False, na=False))
                  & (
                      dfx.aa_clickable.str.contains("C", regex=False, na=False)
                      | (dfx.bb_misc_clickable.fillna(False))
                  )
                  & (dfx.aa_start_y > 0)
                  & (dfx.aa_end_y < screen_height)
                  & (
                      ~dfx.aa_classname.str.contains(
                          "StateListAnimatorImageButton", regex=False, na=False
                      )
                  )
              ]
              .sort_values(by=["aa_end_x"], ascending=True)
              .groupby(
                  [
                      "aa_original_string",
                      "aa_start_x",
                      "aa_start_y",
                      "aa_center_x",
                      "aa_center_y",
                  ]
              )
          ):
              item = group.iloc[0]
              goodresults.clear()
              evp.starttime.clear()
              item.aa_mouse_move()
              evp.starttime.append(time.time())
              result = evp.start_event_parser(
                  callback_function=evp.callback_function,
                  max_timeout=0.1,
                  callback_function_kwargs=callback_function_kwargs,
                  sleep_between_each_scan=0.05,
                  print_elements=False,
              )
              if evp.last_results:
                  
                  fra = item.to_frame().T
                  dfi = pd.DataFrame(evp.last_results, dtype="object")
                  goodresults.append(
                      pd.concat(
                          [
                              fra.loc[fra.index.repeat(len(dfi))].reset_index(drop=True),
                              dfi.rename(
                                  columns={k: f"cc_{k}" for k in dfi.columns}
                              ).reset_index(drop=True),
                          ],
                          axis=1,
                      ).assign(dd_routcounter=rotcount, dd_matchcounter=range(len(dfi)))
                  )
                  rotcount += 1
                  evp.last_results.clear()
              else:
                  continue
              df = pd.concat(goodresults, ignore_index=True)
              df.ds_color_print_all()
              goodresults.clear()
              if F == {0, 1, 2, 3, 4, 5, 6, 7, 8}:
                  F.clear()
                  foundall = True
                  break
              if F == {0, 1, 2, 3, 4, 5, 6, 7}:
                  try:
                      agreee = dfx.loc[
                          dfx.aa_element_id.str.contains("agree")
                      ].drop_duplicates(subset="aa_center_y")
                      if not agreee.empty:
                          for k, i in agreee.iterrows():
                              i.aa_move_and_tap(0.001)
                          F.add(8)
                          break
                  except Exception:
                      errwrite()
              if F == {0, 1, 2, 3, 4, 5, 6}:
                  try:
                      gender_button = df.loc[
                          ((df.cc_Text == b"[Masculino]") | (df.cc_Text == b"[Feminino]"))
                          & df.aa_element_id.str.contains("gender_button")
                      ]
                      if not gender_button.empty:
                          gender_button.iloc[0].aa_mouse_move()
                          gender_button.iloc[0].aa_input_tap()
                          F.add(7)
                          break
                  except Exception:
                      errwrite()
              if F == {0, 1, 2, 3, 4, 5}:
                  try:
                      avancarbutton1 = df.loc[
                          (df.aa_element_id.str.contains("next", regex=False, na=False))
                          & (df.cc_Text == b"[Avan\xc3\xa7ar]")
                          & (df.cc_ClassName == b"android.widget.Button")
                      ]
                      if not avancarbutton1.empty:
                          avancarbutton2 = avancarbutton1.sort_values(
                              by=["dd_matchcounter", "aa_start_y"],
                          )
                          avancarbutton2.iloc[0].aa_move_and_tap(0.001)
                          F.add(6)
                          break
                  except Exception:
                      errwrite()
              if F == {0, 1, 2, 3, 4}:
                  try:
                      numpick = (
                          dfx.loc[
                              (
                                  dfx.aa_element_id.str.contains(
                                      r"id/(?:(?:year)|(?:month)|(?:day))\s*$",
                                      regex=True,
                                      na=False,
                                  )
                              )
                          ]
                          .drop_duplicates(
                              subset=[
                                  "aa_element_id",
                              ]
                          )
                          .sort_values(by=["aa_element_id"], ascending=False)
                      )
                      if not numpick.empty:
                          dada = ["01", "m", "1987"][::-1]
                          indi = 0

                          for k, i in numpick.iterrows():
                              try:
                                  i.aa_move_and_tap(0.001)
                                  texttosend = dada[indi]
                                  time.sleep(0.2)
                                  sendcmd(
                                      openshell,
                                      inputcmd=f"input text '{texttosend}'",
                                      shell=False,
                                      timeout=10,
                                  )
                                  time.sleep(0.2)
                                  indi += 1
                              except Exception:
                                  errwrite()
                          evp.last_results.clear()
                          time.sleep(0.5)
                          for k, i in numpick.iterrows():
                              i.aa_move_and_tap(0.001)
                              break
                          evp.starttime.append(time.time())
                          result = evp.start_event_parser(
                              callback_function=evp.callback_function,
                              max_timeout=0.1,
                              callback_function_kwargs=callback_function_kwargs,
                              sleep_between_each_scan=0.05,
                              print_elements=True,
                          )
                          yearbin = dada[0].encode()
                          for r in evp.last_results:
                              try:
                                  if yearbin in r["Text"]:
                                      break
                              except Exception:
                                  errwrite()
                          else:
                              break
                          F.add(5)
                          break
                  except Exception:
                      errwrite()
              if F == {0, 1, 2, 3}:
                  try:
                      avancarbutton1 = df.loc[
                          (df.cc_Text == b"[Avan\xc3\xa7ar]")
                          & (df.cc_ClassName == b"android.widget.Button")
                          & (df.aa_element_id.str.contains("next", regex=False, na=False))
                      ]
                      if not avancarbutton1.empty:
                          avancarbutton2 = avancarbutton1.sort_values(
                              by=["dd_matchcounter", "aa_start_y"],
                          )
                          avancarbutton2.iloc[0].aa_move_and_tap(0.001)
                          F.add(4)
                          break
                  except Exception:
                      errwrite()
              if F == {0, 1, 2}:
                  try:
                      textfield1 = df.loc[
                          (df.cc_Text == b"[]")
                          & (df.cc_ClassName == b"android.widget.EditText")
                          & (df.aa_element_id.str.contains("aid=", regex=False, na=False))
                      ]
                      if not textfield1.empty:
                          textfield2 = textfield1.sort_values(
                              by=["dd_matchcounter", "aa_start_y"],
                          )
                          textfield2.iloc[0].aa_move_and_tap(0.001)
                          sendcmd(
                              openshell,
                              inputcmd=f"input text '{mypassword}'",
                              shell=False,
                              timeout=10,
                          )
                          F.add(3)
                          break
                  except Exception:
                      errwrite()
              if F == {0, 1}:
                  try:
                      avancarbutton1 = df.loc[
                          (df.cc_Text == b"[Avan\xc3\xa7ar]")
                          & (df.cc_ClassName == b"android.widget.Button")
                          & (df.aa_element_id.str.contains("next", regex=False, na=False))
                      ]
                      if not avancarbutton1.empty:
                          avancarbutton2 = avancarbutton1.sort_values(
                              by=["dd_matchcounter", "aa_start_y"],
                          )
                          avancarbutton2.iloc[0].aa_move_and_tap(0.001)
                          F.add(2)
                          break
                  except Exception:
                      errwrite()
              if F == {0}:
                  try:
                      textfield1 = df.loc[
                          (df.cc_Text == b"[]")
                          & (df.cc_ClassName == b"android.widget.EditText")
                          & (df.aa_element_id.str.contains("aid=", regex=False, na=False))
                      ]
                      if not textfield1.empty:
                          textfield2 = textfield1.sort_values(
                              by=["dd_matchcounter", "aa_start_y"],
                          )
                          textfield2.iloc[0].aa_move_and_tap()
                          sendcmd(
                              openshell,
                              inputcmd=f"input text '{myemail}'",
                              shell=False,
                              timeout=10,
                          )
                          F.add(1)
                          break
                  except Exception:
                      errwrite()
              if F == set():
                  try:
                      withrighttext = df.loc[
                          (
                              df.cc_Text.apply(
                                  lambda x: b"[Inscreva-se gr\xc3\xa1tis]" in x
                              )
                          )
                          & df.aa_classname.str.contains(
                              "StateListAnimatorButton", regex=False, na=False
                          )
                          & df.cc_ClassName.apply(lambda x: b"android.widget.Button" in x)
                          & (
                              df.aa_element_id.str.contains(
                                  r"^\s*$", regex=True, na=False
                              )
                          )
                      ]
                      if not withrighttext.empty:
                          withrighttext2 = withrighttext.sort_values(
                              by=["aa_start_y", "dd_matchcounter"],
                          )
                          withrighttext2.iloc[0].aa_move_and_tap(0.001)
                          F.add(0)
                          break
                  except Exception:
                      errwrite()
      except Exception as fe:
          errwrite()
      except KeyboardInterrupt:
          break

  ```


pkgId: 7932d5e1b00b438abe7ece438e76a27d8f6038ce1aeca09105da7532ac4c9da4
name: python-cytocraft
arch: src
version: 0.1.12
epoch: 0
release: 1
url: https://github.com/YifeiSheng/Cytocraft
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cytocraft-0.1.12-1.src.rpm
checksum_type: sha256
summary:
  The Cytocraft package provides prediction of chromosome configuration based on subcellular resolution spatial transcriptomics.

description:
  <p align="center">
    <img src=https://github.com/YifeiSheng/Cytocraft/raw/main/figure/Figure1.Overview.png>
  </p>



  The Cytocraft package generates a 3D reconstruction of transcription centers based on subcellular resolution spatial transcriptomics.



  - **Operating Systems**:
    - Ubuntu 20.04
    - macOS 11.2
    - Windows 10
  - **Software Dependencies**:
    - Python 3.8 or higher
    - Required Python packages: numpy, pandas, scanpy, matplotlib, shapely
  - **Tested Versions**:
    - Python 3.8, 3.9, 3.12
  - **Hardware Requirements**:
    - No specific non-standard hardware required



  ```
  pip install cytocraft
  ```



  1. Ensure Python 3.8 or higher is installed.
  2. Run the command above to install Cytocraft and its dependencies.
  3. Typical install time on a "normal" desktop computer is approximately 1-5 minutes.




  ```
  import cytocraft.craft as cc
  ```


  ```
  gem_path = 'path_to_your_data.csv'
  gem = cc.read_gem_as_csv(gem_path, sep=',')
  adata = cc.read_gem_as_adata(gem_path, sep=',')
  ```



  ```
  adata = cc.craft(
    gem=gem,
    adata=adata,
    species='YourSpecies',
    seed=your_seed,
    samplename='your_sample_name'
    )
  ```


  ```
  python craft.py [-h] [-p/-n PERCENT/NUMBER] [-t GENE_FILTER_THRESH] [-r RMSD_THRESH] [--sep \t] [-c CELLTYPE] [--ctkey CTKEY] [--cikey CIKEY] [--csep \t] [--seed SEED] -i gem_path -o out_path --species {Human,Mouse,Axolotls,Monkey}
  ```


    -i,--gem_path  `Input: Path of input gene expression matrix file`

    -o,--out_path  `Output: Directory to save results`

    --species  `Species of the input data, e.g. {Human,Mouse,Axolotls,Monkey} `



    -h, --help  `Show this help message and exit`

    -p/-n, --percent/--number  `Percent/Number of anchor gene for rotation derivation, default: 0.001/10`

    -t, --gene_filter_thresh  `The maximum allowable proportion of np.nan values in a column (representing a gene) of the observed transcription centers (Z), default: 0.90`

    -r, --rmsd_thresh  `RMSD threshold. If the computed RMSD value is less than or equal to this threshold, it means the process has reached an acceptable level of similarity or convergence, and the loop is exited. default: 0.01`

    --sep  `Separator of the input gene expression matrix file`

    -c, --celltype  `Path of the annotation file containing cell types, multi-celltype mode only`

    --ctkey  `Key of celltype column in the cell type file, multi-celltype mode only`

    --cikey  `Key of cell id column in the cell type file, multi-celltype mode only`

    --csep  `Separator of the annotation file, multi-celltype mode only, default: \t`

    --seed  `Random seed, default: random int between 0 to 1000`


  ```
  python craft.py -i ./data/SS200000108BR_A3A4_scgem.Spinal_cord_neuron.csv -o ./results/ --species Mouse
  ```


  ```
  python craft.py -i ./data/SSSS200000108BR_A3A4_scgem.csv -o ./results/ --species Mouse --celltype ./data/cell_feature.csv --ctkey cell_type --cikey cell_id
  ```




  1. Download the example data from the repository.
  2. Open and run the [tutorial](https://github.com/YifeiSheng/Cytocraft/blob/main/tutorial.ipynb) notebook provided in the repository to process the demo data step-by-step.



  - A h5ad format adata file containing the 3D reconstruction, rotation matrices of cells, and all other input information.
  - A log file containing the following information:
    - Species
    - Sample Name
    - Seed
    - Cell Number
    - Gene Number
    - Arguments
    - Task ID
    - RMSD values in each loop
    - Number of transcription centers in the configuration.


  - Approximately 5-20 hours.


pkgId: 9baf77d64b57b287a03cfb91c420ce12443edbf2329cf8b898ee9c2c457897e4
name: python-cytomat-tests
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cytomat-tests/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cytomat-tests-0.4.2-1.src.rpm
checksum_type: sha256
description:
  1. Install Package:

  	- bash
  	- pip install cytomat-tests

  2. Setup Package

  	- python -m cytomat.scripts.setup_cytomat_


  Find the documentation [here](https://umg-pharma-lab-automation.pages.gwdg.de/cytomat-python).


pkgId: bc651241f1ef41017e6fa766717b48824ca50d2906221dd7f04f095a906801b2
name: python-cytoolz
arch: src
version: 0.12.3
epoch: 0
release: 1
summary: Cython implementation of Toolz: High performance functional utilities
url: https://github.com/pytoolz/cytoolz
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cytoolz-0.12.3-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Version Status|
  Cython implementation of the
  |literal toolz|_ `package, <https://pypi.python.org/pypi/toolz/>`__ which
  provides high performance utility functions for iterables, functions,
  and dictionaries.
  ``toolz`` is a pure Python package that borrows heavily from contemporary
  functional languanges.  It is designed to interoperate seamlessly with other
  libraries including ``itertools``, ``functools``, and third party libraries.
  High performance functional data analysis is possible with builtin types
  like ``list`` and ``dict``, and user-defined data structures; and low memory
  usage is achieved by using the iterator protocol and returning iterators
  whenever possible.
  ``cytoolz`` implements the same API as ``toolz``.  The main differences are
  that ``cytoolz`` is faster (typically 2-5x faster with a few spectacular
  exceptions) and ``cytoolz`` offers a C API that is accessible to other
  projects developed in Cython.  Since ``toolz`` is able to process very
  large (potentially infinite) data sets, the performance increase gained by
  using ``cytoolz`` can be significant.
  See the PyToolz documentation at https://toolz.readthedocs.io and the full
  `API Documentation <https://toolz.readthedocs.io/en/latest/api.html>`__
  for more details.


pkgId: c110b42532e88dc52c4d91e7a6a6cff55870d8c9e52aa1732aa27139c5d45164
name: python-cytopast
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Visualisation of PastML trees.
url: https://github.com/evolbioinfo/cytopast
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cytopast-1.1.1-1.src.rpm
checksum_type: sha256
description:
  98CMAJ6932 | Africa
  98CMAJ6933 | Africa
  96CMAJ6134 | Africa
  00SEAY5240 | WestEurope
  02GRAY0303 | Greece
  97YUAF9960 | EastEurope

  Try it at [pastml.pasteur.fr](https://pastml.pasteur.fr)

  There are 2 alternative ways to run cytopast on your computer: with [docker](https://www.docker.com/community-edition), or in python3.


  Once [docker](https://www.docker.com/community-edition) is installed, run the following command:
  ```bash
  docker run -v <path_to_the_folder_containing_the_tree_and_the_annotations>:/data:rw -t evolbioinfo/pastml --tree /data/<tree_file> --data /data/<annotation_file> --data_sep <separator_eg_comma> --columns <one_or_more_column_names> --html_compressed /data/<map_name>
  ```
  For example, to reconstruct and visualise the ancestral Country states for Albanian data,
  one needs to run the following command:
  ```bash
  docker run -v ~/Downloads:/data:rw -t evolbioinfo/pastml --tree /data/Albanian.tree.152tax.tre --data /data/data.txt --data_sep , --columns Country --html_compressed /data/Albanian_map.html
  ```
  This will produce a file Albanian_map.html in the Downloads folder,
  that can be viewed with a browser.

  To see advanced options, run
  ```bash
  docker run -t evolbioinfo/pastml -h
  ```


  For **Windows** users, we recommend installing cytopast via [Cygwin environment](https://www.cygwin.com/).
  First instal gcc, gsl, python3 and pip3 from the Cygwin packages. Then install cytopast:
  ```bash
  pip3 install cytopast
  ```

  We strongly recommend installing cytopast for python via [conda](https://conda.io/docs/), following the procedure described below:

  Once you have conda installed create an environment for cytopast with python3, gcc and gsl:
  ```bash
  conda create --name cytopast python=3 gcc gsl
  ```
  Then activate it:
  ```bash
  source activate cytopast
  ```
  Then install cytopast in it:
  ```bash
  pip install cytopast
  ```

  Install [GNU GSL](https://www.gnu.org/software/gsl/), following the instructions provided on GSL website.
  Then install cytopast:
  ```bash
  pip3 install cytopast
  ```

  If you installed cytopast via conda, do not forget to first activate the dedicated environment, e.g.
  ```bash
  source activate cytopast
  ```
  To run cytopast:
  ```bash
  cytopast --tree <path/to/tree_file.nwk> --data <path/to/annotation_file.tab> --columns <one_or_more_column_names> --html_compressed <path/to/output/map.html> --data_sep <separator_eg_comma>
  ```
  For example, to reconstruct and visualise the ancestral Country states for Albanian data,
  one needs to run the following command:
  ```bash
  cytopast --tree ~/Downloads/Albanian.tree.152tax.tre --data ~/Downloads/data.txt --data_sep , --columns Country --html_compressed ~/Downloads/Albanian_map.html
  ```
  This will produce a file Albanian_map.html in the Downloads folder,
  that can be viewed with a browser.

  To see advanced options, run:
  ```bash
  cytopast -h
  ```

  ```python
  from cytopast.pastml_analyser import pastml_pipeline

  data = "~/Downloads/data.txt"

  tree = "~/Downloads/Albanian.tree.152tax.tre"



  columns = ['Country']

  html_compressed = "~/Downloads/Albanian_map.html"

  html = "~/Downloads/Albanian_tree.html"
  pastml_pipeline(data=data, data_sep=',', columns=columns, name_column='Country',
                  tree=tree,
                  html_compressed=html_compressed, html=html,
                  verbose=True)
  ```

  See the [examples folder](https://github.com/evolbioinfo/cytopast/tree/master/examples) for ideas :)


pkgId: ba56c166091c569c6d5c3669951a2ab1647c80642559bfa10b701bc195d2c3af
name: python-cz-changeup
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Commitizen plugin for better changelog generation
url: https://pypi.org/project/cz-changeup/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cz-changeup-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cz-changeup)](https://pypi.org/project/cz-changeup)
  [![PyPI - Version](https://img.shields.io/pypi/v/cz-changeup)](https://pypi.org/project/cz-changeup)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/cz-changeup)](https://anaconda.org/conda-forge/cz-changeup)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

  This plugin is a version of
  [Commitizen](https://commitizen-tools.github.io/commitizen/)'s default conventional
  style that provides more flexibility in the changelog format.



  With pip:

  ```bash
  pip install cz-changeup
  ```

  With conda:

  ```bash
  conda install -c conda-forge cz-changeup
  ```



  Add to your `pyproject.toml`:

  ```toml
  [tool.commitizen]
  name = "cz_changeup"
  ```

  The behavior of the plugin can be customized by providing the following options under `tool.commitizen`:

  | Option                        | Description                                                                                                                                      | Default |
  | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ------- |
  | `changeup_repo_base_url`      | The base URL for the repository, for instance `"https://github.com/my/repo"`.                                                                    | `""`    |
  | `changeup_show_hash`          | Whether to add a link to the commit for each entry in the changelog. If `changeup_repo_base_url` is provided, the hash are linked to the commit. | `true`  |
  | `changeup_show_hash_breaking` | Whether to add a link to the commit also for descriptions in the breaking changes section.                                                       | `true`  |
  | `changeup_show_body`          | Whether to include the commit body in the changelog.                                                                                             | `true`  |
  | `changeup_hide_breaking`      | Whether to include the breaking changes section also in the the commit body if `changeup_show_body` is true. This prevents duplicate entries.    | `true`  |
  | `changeup_body_indent`        | The number of spaces to indent the commit body if `changeup_show_body` is set to `true`.                                                         | `2`     |
  | `changeup_link_issues`        | If `true`, tries to convert issue numbers in phrases like `closes #21` to links. Only works if `changeup_repo_base_url` is provided.             | `true`  |
  | `changeup_scope_prefix`       | Prefix for the scope of the change.                                                                                                              | `"**"`  |
  | `changeup_scope_suffix`       | Suffix for the scope of the change.                                                                                                              | `"**"`  |
  | `changeup_scope_separator`    | Separator between the scope and the message.                                                                                                     | `": "`  |


pkgId: ee346d49dd80c3f9a2000f119ae043b0e059138f3498ccf1961472fe094b7fde
name: python-cz-conventional-gitmoji
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: A commitizen plugin that combines gitmoji and conventional.
url: https://pypi.org/project/cz-conventional-gitmoji/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cz-conventional-gitmoji-0.6.1-1.src.rpm
checksum_type: sha256
description:
  A [commitizen](https://github.com/commitizen-tools/commitizen) plugin that combines [gitmoji](https://gitmoji.dev/) and [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/).



  With `pip` or any other package manager of your choice, the usual way:

  ```bash
  pip install cz-conventional-gitmoji
  ```



  This package can be used as a normal `commitizen` plugin, either by specifying the name on the command line

  ```bash
  cz --name cz_gitmoji commit
  ```

  or by setting it in your **pyproject.toml**

  ```toml
  [tool.commitizen]
  name = "cz_gitmoji"
  ```

  This will make `commitizen` use the commit message parsing rules defined by this plugin, which are 100% compatible with [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/). As such, the gitmojis are completely optional and all commands will continue to validate commit messages in conventional format just fine. This is useful if you're transitioning an existing repo to `cz-conventional-gitmoji` or you work in a team in which some colleagues don't like gitmojis.



  Apart from the conventional-gitmoji rules, this package provides the `gitmojify` command which is also available as a pre-commit hook. The command reads a commit message either from cli or a commit message file and prepends the correct gitmoji based on the type. If the message already has a gitmoji, it is returned as is.

  ```bash
  $ gitmojify -m "init: initial version"
  🎉 init: initial version
  ```

  To use it as a pre-commit hook, install this packages as well as `commitizen` and put the following into your **.pre-commit-config.yaml**

  ```yaml
  repos:
    - repo: https://github.com/ljnsn/cz-conventional-gitmoji
      rev: 0.2.4
      hooks:
        - id: conventional-gitmoji
  ```

  Make sure to install the relevant pre-commit hooks with

  To use `commitizen` hooks with `conventional-gitmoji`, you need to add the package as an extra dependency.

  ```yaml
    - repo: https://github.com/commitizen-tools/commitizen
      rev: v3.29.0
      hooks:
        - id: commitizen
          additional_dependencies: [cz-conventional-gitmoji]
  ```

  ```bash
  pre-commit install --install-hooks
  ```

  Commit with a message in conventional format that contains a valid type mapped by conventional gitmoji and the gitmoji will automagically be added.



  <details>
  <summary>Types to gitmojis</summary>

  | Type | Emoji |
  |------|-------|
  | `fix` | 🐛 |
  | `feat` | ✨ |
  | `docs` | 📝 |
  | `style` | 🎨 |
  | `refactor` | ♻️ |
  | `perf` | ⚡️ |
  | `test` | ✅ |
  | `build` | 👷 |
  | `ci` | 💚 |
  | `revert` | ⏪️ |
  | `dump` | 🔥 |
  | `hotfix` | 🚑️ |
  | `deploy` | 🚀 |
  | `ui` | 💄 |
  | `init` | 🎉 |
  | `security` | 🔒️ |
  | `secret` | 🔐 |
  | `bump` | 🔖 |
  | `fix`-lint | 🚨 |
  | `wip` | 🚧 |
  | `dep-drop` | ⬇️ |
  | `dep-bump` | ⬆️ |
  | `pin` | 📌 |
  | `analytics` | 📈 |
  | `dep-add` | ➕ |
  | `dep-rm` | ➖ |
  | `config` | 🔧 |
  | `script` | 🔨 |
  | `lang` | 🌐 |
  | `typo` | ✏️ |
  | `poop` | 💩 |
  | `merge` | 🔀 |
  | `package` | 📦️ |
  | `external` | 👽️ |
  | `resource` | 🚚 |
  | `license` | 📄 |
  | `boom` | 💥 |
  | `asset` | 🍱 |
  | `accessibility` | ♿️ |
  | `source-docs` | 💡 |
  | `beer` | 🍻 |
  | `text` | 💬 |
  | `db` | 🗃️ |
  | `logs-add` | 🔊 |
  | `logs-rm` | 🔇 |
  | `people` | 👥 |
  | `ux` | 🚸 |
  | `arch` | 🏗️ |
  | `design` | 📱 |
  | `mock` | 🤡 |
  | `egg` | 🥚 |
  | `ignore` | 🙈 |
  | `snap` | 📸 |
  | `experiment` | ⚗️ |
  | `seo` | 🔍️ |
  | `types` | 🏷️ |
  | `seed` | 🌱 |
  | `flag` | 🚩 |
  | `catch` | 🥅 |
  | `animation` | 💫 |
  | `deprecation` | 🗑️ |
  | `auth` | 🛂 |
  | `fix-simple` | 🩹 |
  | `exploration` | 🧐 |
  | `dead` | ⚰️ |
  | `test-fail` | 🧪 |
  | `logic` | 👔 |
  | `health` | 🩺 |
  | `infra` | 🧱 |
  | `devxp` | 🧑‍💻 |
  | `money` | 💸 |
  | `threading` | 🧵 |
  | `validation` | 🦺 |
  | `chore` | 🧹 |

  </details>



  - [x] Enable conventional gitmoji commit messages via `cz commit`.
  - [x] Add hook to automatically prepend the appropriate gitmoji for the commit's type.
  - [ ] Add `--simple-emojis` option to use only the emojis relating to `cz_conventional_commits` types.
  - [ ] Add `--simple-types` option to use only the types used by `cz_conventional_commits`.
  - [ ] Add `--conventional` option to put the emoji in the commit message, making it compatible with `cz_conventional_commits`.



  - [`commitizen-emoji`](https://github.com/marcelomaia/commitizen-emoji)


pkgId: 81e45f270b77ecc2df4b5397fc399420e78155f508ea79b2479639db79ea69fa
name: python-cz-github-jira-conventional
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Extend the commitizen tools to create conventional commits and README that link to Jira and GitHub.
url: https://github.com/apheris/cz-github-jira-conventional
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cz-github-jira-conventional-3.0.0-1.src.rpm
checksum_type: sha256
description:
  **cz-github-jira-conventional** is a plugin for the [**commitizen tools**](https://github.com/commitizen-tools/commitizen), a toolset that helps you to create [**conventional commit messages**](https://www.conventionalcommits.org/en/v1.0.0/). Since the structure of conventional commits messages is standardized they are machine readable and allow commitizen to automaticially calculate and tag [**semantic version numbers**](https://semver.org/) as well as create **CHANGELOG.md** files for your releases.

  This plugin extends the commitizen tools by:
  - **require a Jira issue id** in the commit message
  - **create links to GitHub** commits in the CHANGELOG.md
  - **create links to Jira** issues in the CHANGELOG.md

  When you call commitizen `commit` you will be required you to enter the scope of your commit as a Jira issue id (or multiple issue ids, prefixed or without prefix, see config below).
  ```
  > cz commit
  ? Select the type of change you are committing fix: A bug fix. Correlates with PATCH in SemVer
  ? JIRA issue number (multiple "42, 123"). XX-
  ...
  ```

  The changelog created by cz (`cz bump --changelog`)will contain links to the commits in Github and the Jira issues.
  ```markdown




  - **[XX-123](https://myproject.atlassian.net/browse/XX-123)**: create changelogs with links to issues and commits [a374b](https://github.com/apheris/cz-github-jira-conventional/commit/a374b93f39327964f5ab5290252b795647906008)
  - **[XX-42](https://myproject.atlassian.net/browse/XX-42),[XX-13](https://myproject.atlassian.net/browse/XX-13)**: allow multiple issue to be referenced in the commit [07ab0](https://github.com/apheris/cz-github-jira-conventional/commit/07ab0e09de36712ab1db93fff0c821ecd80b5849)
  ```




  Install with pip
  `python -m pip install cz-github-jira-conventional`

  You need to use a cz config file that has the **required** additional values `jira_base_url` and `github_repo` and may contain the **optional** value `jira_prefix`.

  Example `.cz.yaml` config for this repository
  ```yaml
  commitizen:
    name: cz_github_jira_conventional
    tag_format: v$version
    version: 1.0.0
    jira_prefix: XX-
    jira_base_url: https://myproject.atlassian.net
    github_repo: apheris/cz-github-jira-conventional
  ```

  The `jira_prefix` can be either
  - empty (the user must write the prefix for each issue)
  - a string (the prefix will be added automatically)
  - a list (for multiple projects, the user will be asked to choose a prefix)

  ```yaml
    jira_prefix:
      - XX-
      - XY-
      - YY-
  ```


  Add this plugin to the dependencies of your commit message linting with `pre-commit`.

  Example `.pre-commit-config.yaml` file.
  ```yaml
  repos:
    - repo: https://github.com/commitizen-tools/commitizen
      rev: v2.17.13
      hooks:
        - id: commitizen
          stages: [commit-msg]
          additional_dependencies: [cz-github-jira-conventional]
  ```
  Install the hook with
  ```bash
  pre-commit install --hook-type commit-msg
  ```

  <!-- LICENSE -->


  Distributed under the MIT License. See `LICENSE` for more information.

  <!-- ACKNOWLEDGEMENTS -->

  This plugin would not have been possible without the fantastic work from:
  * [commitizen tools](https://github.com/commitizen-tools/commitizen)
  * [conventional_JIRA](https://github.com/Crystalix007/conventional_jira)


pkgId: 1f76854b9bd81daff277413ffaea551b55ab82a1ba80d092a5e4d9e13de25d72
name: python-cz-light-conventional-gitmoji
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A commitizen plugin that combines gitmoji and conventional commits in a lightweight way.
url: https://github.com/sasirven/cz-light-conventional-gitmoji
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cz-light-conventional-gitmoji-0.3.1-1.src.rpm
checksum_type: sha256
description:
  A [commitizen](https://github.com/commitizen-tools/commitizen) plugin that combines [gitmoji](https://gitmoji.dev/) and [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) in a lightweight way.
  This fork of [cz-conventional-gitmoji](https://github.com/ljnsn/cz-conventional-gitmoji) adds a `simple-types` and `conventional` option to the template.
  We will only have the emojis that are related to the `cz_conventional_commits` types and they will be added to `<subject>` section of the commit message.

  ```
  init: 🎉 initial version
  ```



  With `pip` or any other package manager of your choice, the usual way:

  ```bash
  pip install cz-light-conventional-gitmoji
  ```



  This package can be used as a normal `commitizen` plugin, either by specifying the name on the command line

  ```bash
  cz --name cz_light_gitmoji commit
  ```

  or by setting it in your **pyproject.toml**

  ```toml
  [tool.commitizen]
  name = "cz_light_gitmoji"
  ```

  This will make `commitizen` use the commit message parsing rules defined by this plugin, which are 100% compatible with [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/). As such, the gitmojis are completely optional and all commands will continue to validate commit messages in conventional format just fine. This is useful if you're transitioning an existing repo to `cz-light-conventional-gitmoji` or you work in a team in which some colleagues don't like gitmojis.



  Apart from the conventional-gitmoji rules, this package provides the `gitmojify` command which is also available as a pre-commit hook. The command reads a commit message either from cli or a commit message file and prepends the correct gitmoji based on the type. If the message already has a gitmoji, it is returned as is.

  ```bash
  $ gitmojify -m "init: initial version"
  🎉 init: initial version
  ```

  To use it as a pre-commit hook, install this packages as well as `commitizen` and put the following into your **.pre-commit-config.yaml**

  ```yaml
  repos:
    - repo: https://github.com/sasirven/cz-light-conventional-gitmoji
      rev: 0.2.4
      hooks:
        - id: conventional-gitmoji
  ```

  Make sure to install the relevant pre-commit hooks with

  ```bash
  pre-commit install --install-hooks
  ```

  Commit with a message in conventional format that contains a valid type mapped by conventional gitmoji and the gitmoji will automagically be added.



  - [x] Enable conventional gitmoji commit messages via `cz commit`.
  - [x] Add hook to automatically prepend the appropriate gitmoji for the commit's type.



  - [`cz-conventional-gitmoji`](https://github.com/ljnsn/cz-conventional-gitmoji) (Forked from)


  - ljnsn (Original Author)
  - Samuel Sirven
      - [![Samuel Sirven](https://img.shields.io/badge/-sasirven-181717?style=flat-square&logo=github&logoColor=white)](https://github.com/sasirven)
      - [![Samuel Sirven](https://img.shields.io/badge/-Samuel%20Sirven-0077B5?style=flat-square&logo=Linkedin&logoColor=white)](https://www.linkedin.com/in/samuel-sirven-b49b53211/)


pkgId: 1df747deca23b1a90997354c5b967578c6fbe45f172ef49aa688281c763b455a
name: python-czapi
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: CurlingZone scraper API.
url: https://github.com/calicorob/czapi/tree/master/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czapi-0.2.0-1.src.rpm
checksum_type: sha256
description:
  > A basic API for scraping curling boxscores off of the popular <a href='https://www.curlingzone.com'>CurlingZone</a> website.




  ```
  pip install czapi
  ```



  ```python
  import czapi.api as api
  ```


  czapi is based around the `LinescorePage` object which represents a linescore page on the CurlingZone website.

  Click [here](https://curlingzone.com/event.php?view=Scores&eventid=7795#1) to see an example linescore page.

  Creating an instance of the `LinescorePage` class gives access to every boxscore on that linescore page.

  ```python
  linescore_page = api.LinescorePage(cz_event_id = 6400, cz_draw_id = 2)
  ```

  The `cz_event_id` and `cz_draw_id` arguments are found in the CurlingZone URL.

  Here's an example:
  > ht<span>t</span>ps://curlingzone.com/event.php?**eventid=7795**&view=Scores&show**drawid=21**#1

  The boxscores on the linescore page can be accessed through the `boxscores` property which returns a list of boxscores.

  ```python
  linescore_page.boxscores
  ```




      [{'Wayne Tuck Jr.': {'draw': 'Draw: 2',
         'draw_num': 2,
         'href': 'event.php?view=Team&eventid=6400&teamid=144353&profileid=12486#1',
         'score': ['0', '2', '0', '0', '0', '0', '1', '1', '1', '0'],
         'hammer': True,
         'finalscore': '5'},
        'Matthew Hall': {'draw': 'Draw: 2',
         'draw_num': 2,
         'href': 'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
         'score': ['0', '0', '4', '0', '0', '1', '0', '0', '0', '2'],
         'hammer': False,
         'finalscore': '7'}},
       {'Dayna Deruelle': {'draw': 'Draw: 2',
         'draw_num': 2,
         'href': 'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144346&profileid=26636#1',
         'score': ['0', '0', '1', '0', '0', '0', '0', 'X'],
         'hammer': False,
         'finalscore': '1'},
        'Tyler Stewart': {'draw': 'Draw: 2',
         'draw_num': 2,
         'href': 'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144352&profileid=12477#1',
         'score': ['0', '2', '0', '2', '1', '1', '4', 'X'],
         'hammer': True,
         'finalscore': '10'}},
       {'Mark Kean': {'draw': 'Draw: 2',
         'draw_num': 2,
         'href': 'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144348&profileid=25961#1',
         'score': ['2', '0', '1', '0', '0', '0', '1', '3', 'X'],
         'hammer': True,
         'finalscore': '7'},
        'Jason March': {'draw': 'Draw: 2',
         'draw_num': 2,
         'href': 'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144350#1',
         'score': ['0', '0', '0', '0', '2', '1', '0', '0', 'X'],
         'hammer': False,
         'finalscore': '3'}},
       {'Richard Krell': {'draw': 'Draw: 2',
         'draw_num': 2,
         'href': 'event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144349&profileid=25962#1',
         'score': ['2', '0', '1', '0', '2', '1', '1', 'X'],
         'hammer': True,
         'finalscore': '7'},
        'Rob Ainsley': {'draw': 'Draw: 2',
         'draw_num': 2,
         'href': 'event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144345&profileid=15779#1',
         'score': ['0', '0', '0', '1', '0', '0', '0', 'X'],
         'hammer': False,
         'finalscore': '1'}}]



  A boxscore is returned as a dictionary of team names, game information dictionary key, value pairs.

  Each game information dictionary contains:

  * 'href' key with a corresponding string value of CurlingZone IDs identifying the team.
  * 'hammer' key with corresponding boolean value of whether or not that team started the game with hammer.
  * 'score' key with corresponding list of string value of end-by-end results for that team.
  * 'finalscore' key with corresponding final score for the team.
  * 'draw_num' key with corresponding draw number for the game.
  * 'draw' key with corresponding draw.

  Individual boxscores can be accessed through the `get_boxscore_from` method.

  ```python
  boxscore = linescore_page.get_boxscore_from(cz_game_id = 1)
  boxscore
  ```




      {'Wayne Tuck Jr.': {'draw': 'Draw: 2',
        'draw_num': 2,
        'href': 'event.php?view=Team&eventid=6400&teamid=144353&profileid=12486#1',
        'score': ['0', '2', '0', '0', '0', '0', '1', '1', '1', '0'],
        'hammer': True,
        'finalscore': '5'},
       'Matthew Hall': {'draw': 'Draw: 2',
        'draw_num': 2,
        'href': 'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
        'score': ['0', '0', '4', '0', '0', '1', '0', '0', '0', '2'],
        'hammer': False,
        'finalscore': '7'}}



  `cz_game_id` argument corresponds to the number the boxscore appears in on the linescore page.

  The LinescorePage object contains these properties which details information on the boxscores:

  * event_name
  * event_date
  * draw
  * draw number

  ```python
  print(linescore_page.event_name,',',linescore_page.event_date)
  ```

      Ontario Tankard - Open Qualifier , Jan 17 - 19, 2020


  For convenience, upon instantiation of a `LinescorePage` object, a `NormalizedBoxscore` instance for each boxscore is created. A `NormalizedBoxscore` holds the same information as a boxscore dictionary with two new pieces of information added:
  1. The hammer progression for both teams throughout the game, i.e. who had hammer in what end.
  2. Each team's relative score, i.e. who was up/down X after end Y.

  ```python
  normalized_boxscore = linescore_page.get_normalized_boxscore_from(cz_game_id = 1)
  normalized_boxscore
  ```




      NormalizedBoxscore(boxscore={'Wayne Tuck Jr.': {'draw': 'Draw: 2', 'draw_num': 2, 'href': 'event.php?view=Team&eventid=6400&teamid=144353&profileid=12486#1', 'score': ['0', '2', '0', '0', '0', '0', '1', '1', '1', '0'], 'hammer': True, 'finalscore': '5'}, 'Matthew Hall': {'draw': 'Draw: 2', 'draw_num': 2, 'href': 'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1', 'score': ['0', '0', '4', '0', '0', '1', '0', '0', '0', '2'], 'hammer': False, 'finalscore': '7'}})



  A `NormalizedBoxscore` object holds two `NormalizedHalfBoxscore` instances.

  ```python
  normalized_boxscore.normalized_half_boxscore_pair[0]
  ```




      NormalizedHalfBoxscore(team_name='Wayne Tuck Jr.', href='event.php?view=Team&eventid=6400&teamid=144353&profileid=12486#1', hammer=True, score=['0', '2', '0', '0', '0', '0', '1', '1', '1', '0'], finalscore='5', draw_num=2, draw='Draw: 2', hammer_progression=[True, True, False, True, True, True, True, False, False, False], normalized_score=[0, 0, 2, -2, -2, -2, -3, -2, -1, 0])



  For Wayne Tuck Jr. the `hammer_progression` attribute can be interpreted as follows:

  * End 1: Wayne had hammer
  * End 2: Wayne had hammer
  * End 3: Wayne didn't have hammer
  * And so on and so forth..

  ```python
  normalized_boxscore.normalized_half_boxscore_pair[-1]
  ```




      NormalizedHalfBoxscore(team_name='Matthew Hall', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1', hammer=False, score=['0', '0', '4', '0', '0', '1', '0', '0', '0', '2'], finalscore='7', draw_num=2, draw='Draw: 2', hammer_progression=[False, False, True, False, False, False, False, True, True, True], normalized_score=[0, 0, -2, 2, 2, 2, 3, 2, 1, 0])



  For Matthew Hall, the `normalized_score` attribute can be interpreted as follows:

  * The score was tied in the first end (obviously).
  * The score was tied in the second end.
  * In the 3rd end, Matthew was down 2.
  * In the 4th end, Matthew was up 2 after taking 4.
  * And so on and so forth..

  You'll also notice the `NormalizedBoxscore` object has a guid property which identifies that two `NormalizedHalfBoxscore` belong to the same game.

  ```python
  normalized_boxscore.guid
  ```




      129690655252279755696295239689104705205



  czapi's `get_flat_boxscores_from` function takes a `cz_event_id` and `cz_draw_id` as an arguments and returns a (flat) nested list object of all the boxscore information on the linescore page. This nested list object can be ingested into a pandas DataFrame or pushed to a SQL database.

  ```python
  api.get_flat_boxscores_from(cz_event_id = 6400, cz_draw_id = 2)
  ```




      [('Wayne Tuck Jr.',
        'event.php?view=Team&eventid=6400&teamid=144353&profileid=12486#1',
        True,
        ['0', '2', '0', '0', '0', '0', '1', '1', '1', '0'],
        '5',
        2,
        'Draw: 2',
        [True, True, False, True, True, True, True, False, False, False],
        [0, 0, 2, -2, -2, -2, -3, -2, -1, 0],
        296656328202528204780428618855733007061),
       ('Matthew Hall',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
        False,
        ['0', '0', '4', '0', '0', '1', '0', '0', '0', '2'],
        '7',
        2,
        'Draw: 2',
        [False, False, True, False, False, False, False, True, True, True],
        [0, 0, -2, 2, 2, 2, 3, 2, 1, 0],
        296656328202528204780428618855733007061),
       ('Dayna Deruelle',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144346&profileid=26636#1',
        False,
        ['0', '0', '1', '0', '0', '0', '0', 'X'],
        '1',
        2,
        'Draw: 2',
        [False, False, True, False, True, True, True, True],
        [0, 0, -2, -1, -3, -4, -5, -9],
        105249071225393527432485074456849437076),
       ('Tyler Stewart',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144352&profileid=12477#1',
        True,
        ['0', '2', '0', '2', '1', '1', '4', 'X'],
        '10',
        2,
        'Draw: 2',
        [True, True, False, True, False, False, False, False],
        [0, 0, 2, 1, 3, 4, 5, 9],
        105249071225393527432485074456849437076),
       ('Mark Kean',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144348&profileid=25961#1',
        True,
        ['2', '0', '1', '0', '0', '0', '1', '3', 'X'],
        '7',
        2,
        'Draw: 2',
        [True, False, False, False, False, True, True, False, False],
        [0, 2, 2, 3, 3, 1, 0, 1, 4],
        17103980631020054974876512539607901632),
       ('Jason March',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144350#1',
        False,
        ['0', '0', '0', '0', '2', '1', '0', '0', 'X'],
        '3',
        2,
        'Draw: 2',
        [False, True, True, True, True, False, False, True, True],
        [0, -2, -2, -3, -3, -1, 0, -1, -4],
        17103980631020054974876512539607901632),
       ('Richard Krell',
        'event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144349&profileid=25962#1',
        True,
        ['2', '0', '1', '0', '2', '1', '1', 'X'],
        '7',
        2,
        'Draw: 2',
        [True, False, False, False, True, False, False, False],
        [0, 2, 2, 3, 2, 4, 5, 6],
        215489388707487834967933616755032135426),
       ('Rob Ainsley',
        'event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144345&profileid=15779#1',
        False,
        ['0', '0', '0', '1', '0', '0', '0', 'X'],
        '1',
        2,
        'Draw: 2',
        [False, True, True, True, False, True, True, True],
        [0, -2, -2, -3, -2, -4, -5, -6],
        215489388707487834967933616755032135426)]





  The `Event` object is a data structure which holds all of the `LinescorePage` objects which make up an entire event.

  An `Event` instance is created by passing a `cz_event_id`.

  ```python
  event = api.Event(cz_event_id = 6400,delay=3,verbose=True)
  event
  ```

      Scraping draw 1.
      Scraping draw 2.
      Scraping draw 3.
      Scraping draw 4.
      Scraping draw 5.
      Scraping draw 6.
      Scraping draw 7.





      Event(cz_event_id=6400, delay=3, verbose=True)



  The created `Event` objects holds all the `LinescorePage` objects in it's `pages` property.

  ```python
  event.pages
  ```




      [LinescorePage(cz_event_id=6400, cz_draw_id=1),
       LinescorePage(cz_event_id=6400, cz_draw_id=2),
       LinescorePage(cz_event_id=6400, cz_draw_id=3),
       LinescorePage(cz_event_id=6400, cz_draw_id=4),
       LinescorePage(cz_event_id=6400, cz_draw_id=5),
       LinescorePage(cz_event_id=6400, cz_draw_id=6),
       LinescorePage(cz_event_id=6400, cz_draw_id=7)]



  Details about specific draws can be accessed by grabbing the correct LinescorePage.

  ```python
  event.pages[2]
  ```




      LinescorePage(cz_event_id=6400, cz_draw_id=3)



  ```python
  event.pages[2].boxscores
  ```




      [{'Matthew Hall': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
         'score': ['0', '0', '2', '1', '2', '1', '0', '2', 'X'],
         'hammer': True,
         'finalscore': '8'},
        'Tyler Stewart': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477#1',
         'score': ['0', '1', '0', '0', '0', '0', '2', '0', 'X'],
         'hammer': False,
         'finalscore': '3'}},
       {'Mark Kean': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144348&profileid=25961#1',
         'score': ['0', '5', '0', '1', '1', '1', 'X'],
         'hammer': True,
         'finalscore': '8'},
        'Richard Krell': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144349&profileid=25962#1',
         'score': ['1', '0', '1', '0', '0', '0', 'X'],
         'hammer': False,
         'finalscore': '2'}},
       {'Damien Villard': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144354&profileid=27373#1',
         'score': ['2', '1', '0', '1', '0', '0', '1', '0', '0', '0'],
         'hammer': True,
         'finalscore': '5'},
        'Sam Steep': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144351&profileid=25978#1',
         'score': ['0', '0', '1', '0', '2', '0', '0', '1', '1', '1'],
         'hammer': False,
         'finalscore': '6'}},
       {'Jason March': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144351&profileid=25978&eventid=6400&teamid=144350#1',
         'score': ['1', '1', '0', '0', '0', '0', '2', '1', '2', 'X'],
         'hammer': True,
         'finalscore': '7'},
        'Matthew Mepstead': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144351&profileid=25978&eventid=6400&teamid=144356#1',
         'score': ['0', '0', '1', '1', '0', '0', '0', '0', '0', 'X'],
         'hammer': False,
         'finalscore': '2'}},
       {'Wayne Tuck Jr.': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144356&profileid=0&eventid=6400&teamid=144353&profileid=12486#1',
         'score': ['0', '0', '0', '2', '0', '0', '0', '0', 'X'],
         'hammer': False,
         'finalscore': '2'},
        'Rob Ainsley': {'draw': 'Draw: 3',
         'draw_num': 3,
         'href': 'event.php?view=Team&eventid=6400&teamid=144356&profileid=0&eventid=6400&teamid=144345&profileid=15779#1',
         'score': ['2', '1', '0', '0', '1', '2', '1', '1', 'X'],
         'hammer': True,
         'finalscore': '8'}}]



  The `get_flat_boxscores` method can be used to return a list of tuples of all the boxscore information on all the linescore pages.

  ```python
  event.get_flat_boxscores(flat=True)
  ```




      [('Damien Villard',
        'event.php?view=Team&eventid=6400&teamid=144354&profileid=27373#1',
        True,
        ['0', '0', '0', '0', 'X'],
        '0',
        1,
        'Draw: 1',
        [True, True, True, True, True],
        [0, -1, -4, -6, -8],
        209707243860236114112314247393927711356),
       ('Matthew Hall',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
        False,
        ['1', '3', '2', '2', 'X'],
        '8',
        1,
        'Draw: 1',
        [False, False, False, False, False],
        [0, 1, 4, 6, 8],
        209707243860236114112314247393927711356),
       ('Matthew Mepstead',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144356#1',
        False,
        ['0', '0', '1', '1', '0', '1', '0', '0', '0', '1', '0'],
        '4',
        1,
        'Draw: 1',
        [False, False, True, False, False, True, False, False, False, True, False],
        [0, 0, -2, -1, 0, -1, 0, 0, 0, -1, 0],
        38537103347544582345141893615297919005),
       ('Tyler Stewart',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144352&profileid=12477#1',
        True,
        ['0', '2', '0', '0', '1', '0', '0', '0', '1', '0', '1'],
        '5',
        1,
        'Draw: 1',
        [True, True, False, True, True, False, True, True, True, False, True],
        [0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0],
        38537103347544582345141893615297919005),
       ('Jason March',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144350#1',
        False,
        ['0', '2', '0', '1', '0', '2', '2', '0', '2', 'X'],
        '9',
        1,
        'Draw: 1',
        [False, False, False, False, False, True, False, False, True, False],
        [0, 0, 2, 2, 3, 2, 4, 6, 3, 5],
        272348649831484335603593027216985821953),
       ('Sam Steep',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144351&profileid=25978#1',
        True,
        ['0', '0', '0', '0', '1', '0', '0', '3', '0', 'X'],
        '4',
        1,
        'Draw: 1',
        [True, True, True, True, True, False, True, True, False, True],
        [0, 0, -2, -2, -3, -2, -4, -6, -3, -5],
        272348649831484335603593027216985821953),
       ('Wayne Tuck Jr.',
        'event.php?view=Team&eventid=6400&teamid=144353&profileid=12486#1',
        True,
        ['0', '2', '0', '0', '0', '0', '1', '1', '1', '0'],
        '5',
        2,
        'Draw: 2',
        [True, True, False, True, True, True, True, False, False, False],
        [0, 0, 2, -2, -2, -2, -3, -2, -1, 0],
        95112284881200216258215191883153462659),
       ('Matthew Hall',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
        False,
        ['0', '0', '4', '0', '0', '1', '0', '0', '0', '2'],
        '7',
        2,
        'Draw: 2',
        [False, False, True, False, False, False, False, True, True, True],
        [0, 0, -2, 2, 2, 2, 3, 2, 1, 0],
        95112284881200216258215191883153462659),
       ('Dayna Deruelle',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144346&profileid=26636#1',
        False,
        ['0', '0', '1', '0', '0', '0', '0', 'X'],
        '1',
        2,
        'Draw: 2',
        [False, False, True, False, True, True, True, True],
        [0, 0, -2, -1, -3, -4, -5, -9],
        59643628877953807377369574857821892232),
       ('Tyler Stewart',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144352&profileid=12477#1',
        True,
        ['0', '2', '0', '2', '1', '1', '4', 'X'],
        '10',
        2,
        'Draw: 2',
        [True, True, False, True, False, False, False, False],
        [0, 0, 2, 1, 3, 4, 5, 9],
        59643628877953807377369574857821892232),
       ('Mark Kean',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144348&profileid=25961#1',
        True,
        ['2', '0', '1', '0', '0', '0', '1', '3', 'X'],
        '7',
        2,
        'Draw: 2',
        [True, False, False, False, False, True, True, False, False],
        [0, 2, 2, 3, 3, 1, 0, 1, 4],
        122217858840490332010920244446431255640),
       ('Jason March',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144350#1',
        False,
        ['0', '0', '0', '0', '2', '1', '0', '0', 'X'],
        '3',
        2,
        'Draw: 2',
        [False, True, True, True, True, False, False, True, True],
        [0, -2, -2, -3, -3, -1, 0, -1, -4],
        122217858840490332010920244446431255640),
       ('Richard Krell',
        'event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144349&profileid=25962#1',
        True,
        ['2', '0', '1', '0', '2', '1', '1', 'X'],
        '7',
        2,
        'Draw: 2',
        [True, False, False, False, True, False, False, False],
        [0, 2, 2, 3, 2, 4, 5, 6],
        335702133606077232579627915311442373664),
       ('Rob Ainsley',
        'event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144345&profileid=15779#1',
        False,
        ['0', '0', '0', '1', '0', '0', '0', 'X'],
        '1',
        2,
        'Draw: 2',
        [False, True, True, True, False, True, True, True],
        [0, -2, -2, -3, -2, -4, -5, -6],
        335702133606077232579627915311442373664),
       ('Matthew Hall',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
        True,
        ['0', '0', '2', '1', '2', '1', '0', '2', 'X'],
        '8',
        3,
        'Draw: 3',
        [True, True, True, False, False, False, False, True, False],
        [0, 0, -1, 1, 2, 4, 5, 3, 5],
        53772503334370441085334378293107653659),
       ('Tyler Stewart',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477#1',
        False,
        ['0', '1', '0', '0', '0', '0', '2', '0', 'X'],
        '3',
        3,
        'Draw: 3',
        [False, False, False, True, True, True, True, False, True],
        [0, 0, 1, -1, -2, -4, -5, -3, -5],
        53772503334370441085334378293107653659),
       ('Mark Kean',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144348&profileid=25961#1',
        True,
        ['0', '5', '0', '1', '1', '1', 'X'],
        '8',
        3,
        'Draw: 3',
        [True, True, False, True, False, False, False],
        [0, -1, 4, 3, 4, 5, 6],
        310456475955908017873561887016699672637),
       ('Richard Krell',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144349&profileid=25962#1',
        False,
        ['1', '0', '1', '0', '0', '0', 'X'],
        '2',
        3,
        'Draw: 3',
        [False, False, True, False, True, True, True],
        [0, 1, -4, -3, -4, -5, -6],
        310456475955908017873561887016699672637),
       ('Damien Villard',
        'event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144354&profileid=27373#1',
        True,
        ['2', '1', '0', '1', '0', '0', '1', '0', '0', '0'],
        '5',
        3,
        'Draw: 3',
        [True, False, False, True, False, True, True, False, True, True],
        [0, 2, 3, 2, 3, 1, 1, 2, 1, 0],
        303047434632680540438656592556261333287),
       ('Sam Steep',
        'event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144351&profileid=25978#1',
        False,
        ['0', '0', '1', '0', '2', '0', '0', '1', '1', '1'],
        '6',
        3,
        'Draw: 3',
        [False, True, True, False, True, False, False, True, False, False],
        [0, -2, -3, -2, -3, -1, -1, -2, -1, 0],
        303047434632680540438656592556261333287),
       ('Jason March',
        'event.php?view=Team&eventid=6400&teamid=144351&profileid=25978&eventid=6400&teamid=144350#1',
        True,
        ['1', '1', '0', '0', '0', '0', '2', '1', '2', 'X'],
        '7',
        3,
        'Draw: 3',
        [True, False, False, True, True, True, True, False, False, False],
        [0, 1, 2, 1, 0, 0, 0, 2, 3, 5],
        229699058183107339172217417532449914369),
       ('Matthew Mepstead',
        'event.php?view=Team&eventid=6400&teamid=144351&profileid=25978&eventid=6400&teamid=144356#1',
        False,
        ['0', '0', '1', '1', '0', '0', '0', '0', '0', 'X'],
        '2',
        3,
        'Draw: 3',
        [False, True, True, False, False, False, False, True, True, True],
        [0, -1, -2, -1, 0, 0, 0, -2, -3, -5],
        229699058183107339172217417532449914369),
       ('Wayne Tuck Jr.',
        'event.php?view=Team&eventid=6400&teamid=144356&profileid=0&eventid=6400&teamid=144353&profileid=12486#1',
        False,
        ['0', '0', '0', '2', '0', '0', '0', '0', 'X'],
        '2',
        3,
        'Draw: 3',
        [False, True, True, True, False, True, True, True, True],
        [0, -2, -3, -3, -1, -2, -4, -5, -6],
        195399470224611539512163135746754073908),
       ('Rob Ainsley',
        'event.php?view=Team&eventid=6400&teamid=144356&profileid=0&eventid=6400&teamid=144345&profileid=15779#1',
        True,
        ['2', '1', '0', '0', '1', '2', '1', '1', 'X'],
        '8',
        3,
        'Draw: 3',
        [True, False, False, False, True, False, False, False, False],
        [0, 2, 3, 3, 1, 2, 4, 5, 6],
        195399470224611539512163135746754073908),
       ('Matthew Hall',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
        True,
        ['1', '0', '1', '0', '1', '0', '2', '0', '1', '0'],
        '6',
        4,
        'Draw: 4',
        [True, False, True, False, True, False, True, False, True, False],
        [0, 1, -1, 0, -2, -1, -2, 0, -1, 0],
        63653233024470732271264476184228625543),
       ('Mark Kean',
        'event.php?view=Team&eventid=6400&teamid=144348&profileid=25961#1',
        False,
        ['0', '2', '0', '2', '0', '1', '0', '1', '0', '1'],
        '7',
        4,
        'Draw: 4',
        [False, True, False, True, False, True, False, True, False, True],
        [0, -1, 1, 0, 2, 1, 2, 0, 1, 0],
        63653233024470732271264476184228625543),
       ('Sam Steep',
        'event.php?view=Team&eventid=6400&teamid=144348&profileid=25961&eventid=6400&teamid=144351&profileid=25978#1',
        False,
        ['1', '0', '0', '2', '0', '1', '1', '0', '1', '1'],
        '7',
        4,
        'Draw: 4',
        [False, False, True, True, False, True, False, False, True, False],
        [0, 1, 0, -2, 0, -2, -1, 0, -1, 0],
        279469483516704960424550934244064693031),
       ('Jason March',
        'event.php?view=Team&eventid=6400&teamid=144348&profileid=25961&eventid=6400&teamid=144350#1',
        True,
        ['0', '1', '2', '0', '2', '0', '0', '1', '0', '0'],
        '6',
        4,
        'Draw: 4',
        [True, True, False, False, True, False, True, True, False, True],
        [0, -1, 0, 2, 0, 2, 1, 0, 1, 0],
        279469483516704960424550934244064693031),
       ('Dayna Deruelle',
        'event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144346&profileid=26636#1',
        False,
        ['0', '2', '1', '1', '1', '0', '3', 'X'],
        '8',
        4,
        'Draw: 4',
        [False, True, False, False, False, False, True, False],
        [0, -1, 1, 2, 3, 4, 3, 6],
        291113397726148010907174443006816563924),
       ('Rob Ainsley',
        'event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144345&profileid=15779#1',
        True,
        ['1', '0', '0', '0', '0', '1', '0', 'X'],
        '2',
        4,
        'Draw: 4',
        [True, False, True, True, True, True, False, True],
        [0, 1, -1, -2, -3, -4, -3, -6],
        291113397726148010907174443006816563924),
       ('Sam Steep',
        'event.php?view=Team&eventid=6400&teamid=144351&profileid=25978#1',
        False,
        ['0', '1', '0', '0', '0', '2', '0', '2', '0', '0'],
        '5',
        5,
        'Draw: 5',
        [False, False, False, True, True, True, False, True, False, False],
        [0, 0, 1, 0, -1, -3, -1, -3, -1, -1],
        95866945533461342246819997703085723055),
       ('Richard Krell',
        'event.php?view=Team&eventid=6400&teamid=144349&profileid=25962#1',
        True,
        ['0', '0', '1', '1', '2', '0', '2', '0', '0', '1'],
        '7',
        5,
        'Draw: 5',
        [True, True, True, False, False, False, True, False, True, True],
        [0, 0, -1, 0, 1, 3, 1, 3, 1, 1],
        95866945533461342246819997703085723055),
       ('Dayna Deruelle',
        'event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144346&profileid=26636#1',
        False,
        ['0', '0', '1', '0', '0', '0', '1', '0', '3', '1', '0'],
        '6',
        5,
        'Draw: 5',
        [False, True, True, False, True, True, True, False, True, False, False],
        [0, -1, -1, 0, -1, -1, -3, -2, -4, -1, 0],
        233581897033627594667237538445333000951),
       ('Tyler Stewart',
        'event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144352&profileid=12477#1',
        True,
        ['1', '0', '0', '1', '0', '2', '0', '2', '0', '0', '1'],
        '7',
        5,
        'Draw: 5',
        [True, False, False, True, False, False, False, True, False, True, True],
        [0, 1, 1, 0, 1, 1, 3, 2, 4, 1, 0],
        233581897033627594667237538445333000951),
       ('Richard Krell',
        'event.php?view=Team&eventid=6400&teamid=144349&profileid=25962#1',
        False,
        ['0', '0', '1', '1', '0', '0', '1', '0', 'X'],
        '3',
        6,
        'Draw: 6',
        [False, False, True, False, False, True, True, False, True],
        [0, 0, -2, -1, 0, -2, -5, -4, -5],
        61203104491141348409761697458039616615),
       ('Tyler Stewart',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477#1',
        True,
        ['0', '2', '0', '0', '2', '3', '0', '1', 'X'],
        '8',
        6,
        'Draw: 6',
        [True, True, False, True, True, False, False, True, False],
        [0, 0, 2, 1, 0, 2, 5, 4, 5],
        61203104491141348409761697458039616615),
       ('Tyler Stewart',
        'event.php?view=Team&eventid=6400&teamid=144352&profileid=12477#1',
        False,
        ['0', '0', '1', '1', '0', '3', '0', '0', '1', '0'],
        '6',
        7,
        'Draw: 7',
        [False, False, True, False, False, True, False, False, True, False],
        [0, 0, -1, 0, 1, -2, 1, 1, 0, 1],
        4915701019265174384644466584441738333),
       ('Matthew Hall',
        'event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1',
        True,
        ['0', '1', '0', '0', '3', '0', '0', '1', '0', '2'],
        '7',
        7,
        'Draw: 7',
        [True, True, False, True, True, False, True, True, False, True],
        [0, 0, 1, 0, -1, 2, -1, -1, 0, -1],
        4915701019265174384644466584441738333)]



  The `get_flat_boxscores` method can also be used to return a list of `Boxscore` objects for convenience.

  ```python
  event.get_flat_boxscores(flat=False)
  ```




      [Boxscore(team_name='Damien Villard', href='event.php?view=Team&eventid=6400&teamid=144354&profileid=27373#1', hammer_start=True, score=['0', '0', '0', '0', 'X'], final_score='0', draw_num=1, draw='Draw: 1', hammer_progression=[True, True, True, True, True], relative_score=[0, -1, -4, -6, -8], guid=209707243860236114112314247393927711356),
       Boxscore(team_name='Matthew Hall', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1', hammer_start=False, score=['1', '3', '2', '2', 'X'], final_score='8', draw_num=1, draw='Draw: 1', hammer_progression=[False, False, False, False, False], relative_score=[0, 1, 4, 6, 8], guid=209707243860236114112314247393927711356),
       Boxscore(team_name='Matthew Mepstead', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144356#1', hammer_start=False, score=['0', '0', '1', '1', '0', '1', '0', '0', '0', '1', '0'], final_score='4', draw_num=1, draw='Draw: 1', hammer_progression=[False, False, True, False, False, True, False, False, False, True, False], relative_score=[0, 0, -2, -1, 0, -1, 0, 0, 0, -1, 0], guid=38537103347544582345141893615297919005),
       Boxscore(team_name='Tyler Stewart', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144352&profileid=12477#1', hammer_start=True, score=['0', '2', '0', '0', '1', '0', '0', '0', '1', '0', '1'], final_score='5', draw_num=1, draw='Draw: 1', hammer_progression=[True, True, False, True, True, False, True, True, True, False, True], relative_score=[0, 0, 2, 1, 0, 1, 0, 0, 0, 1, 0], guid=38537103347544582345141893615297919005),
       Boxscore(team_name='Jason March', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144350#1', hammer_start=False, score=['0', '2', '0', '1', '0', '2', '2', '0', '2', 'X'], final_score='9', draw_num=1, draw='Draw: 1', hammer_progression=[False, False, False, False, False, True, False, False, True, False], relative_score=[0, 0, 2, 2, 3, 2, 4, 6, 3, 5], guid=272348649831484335603593027216985821953),
       Boxscore(team_name='Sam Steep', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144351&profileid=25978#1', hammer_start=True, score=['0', '0', '0', '0', '1', '0', '0', '3', '0', 'X'], final_score='4', draw_num=1, draw='Draw: 1', hammer_progression=[True, True, True, True, True, False, True, True, False, True], relative_score=[0, 0, -2, -2, -3, -2, -4, -6, -3, -5], guid=272348649831484335603593027216985821953),
       Boxscore(team_name='Wayne Tuck Jr.', href='event.php?view=Team&eventid=6400&teamid=144353&profileid=12486#1', hammer_start=True, score=['0', '2', '0', '0', '0', '0', '1', '1', '1', '0'], final_score='5', draw_num=2, draw='Draw: 2', hammer_progression=[True, True, False, True, True, True, True, False, False, False], relative_score=[0, 0, 2, -2, -2, -2, -3, -2, -1, 0], guid=95112284881200216258215191883153462659),
       Boxscore(team_name='Matthew Hall', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1', hammer_start=False, score=['0', '0', '4', '0', '0', '1', '0', '0', '0', '2'], final_score='7', draw_num=2, draw='Draw: 2', hammer_progression=[False, False, True, False, False, False, False, True, True, True], relative_score=[0, 0, -2, 2, 2, 2, 3, 2, 1, 0], guid=95112284881200216258215191883153462659),
       Boxscore(team_name='Dayna Deruelle', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144346&profileid=26636#1', hammer_start=False, score=['0', '0', '1', '0', '0', '0', '0', 'X'], final_score='1', draw_num=2, draw='Draw: 2', hammer_progression=[False, False, True, False, True, True, True, True], relative_score=[0, 0, -2, -1, -3, -4, -5, -9], guid=59643628877953807377369574857821892232),
       Boxscore(team_name='Tyler Stewart', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435&eventid=6400&teamid=144352&profileid=12477#1', hammer_start=True, score=['0', '2', '0', '2', '1', '1', '4', 'X'], final_score='10', draw_num=2, draw='Draw: 2', hammer_progression=[True, True, False, True, False, False, False, False], relative_score=[0, 0, 2, 1, 3, 4, 5, 9], guid=59643628877953807377369574857821892232),
       Boxscore(team_name='Mark Kean', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144348&profileid=25961#1', hammer_start=True, score=['2', '0', '1', '0', '0', '0', '1', '3', 'X'], final_score='7', draw_num=2, draw='Draw: 2', hammer_progression=[True, False, False, False, False, True, True, False, False], relative_score=[0, 2, 2, 3, 3, 1, 0, 1, 4], guid=122217858840490332010920244446431255640),
       Boxscore(team_name='Jason March', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144350#1', hammer_start=False, score=['0', '0', '0', '0', '2', '1', '0', '0', 'X'], final_score='3', draw_num=2, draw='Draw: 2', hammer_progression=[False, True, True, True, True, False, False, True, True], relative_score=[0, -2, -2, -3, -3, -1, 0, -1, -4], guid=122217858840490332010920244446431255640),
       Boxscore(team_name='Richard Krell', href='event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144349&profileid=25962#1', hammer_start=True, score=['2', '0', '1', '0', '2', '1', '1', 'X'], final_score='7', draw_num=2, draw='Draw: 2', hammer_progression=[True, False, False, False, True, False, False, False], relative_score=[0, 2, 2, 3, 2, 4, 5, 6], guid=335702133606077232579627915311442373664),
       Boxscore(team_name='Rob Ainsley', href='event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144345&profileid=15779#1', hammer_start=False, score=['0', '0', '0', '1', '0', '0', '0', 'X'], final_score='1', draw_num=2, draw='Draw: 2', hammer_progression=[False, True, True, True, False, True, True, True], relative_score=[0, -2, -2, -3, -2, -4, -5, -6], guid=335702133606077232579627915311442373664),
       Boxscore(team_name='Matthew Hall', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1', hammer_start=True, score=['0', '0', '2', '1', '2', '1', '0', '2', 'X'], final_score='8', draw_num=3, draw='Draw: 3', hammer_progression=[True, True, True, False, False, False, False, True, False], relative_score=[0, 0, -1, 1, 2, 4, 5, 3, 5], guid=53772503334370441085334378293107653659),
       Boxscore(team_name='Tyler Stewart', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477#1', hammer_start=False, score=['0', '1', '0', '0', '0', '0', '2', '0', 'X'], final_score='3', draw_num=3, draw='Draw: 3', hammer_progression=[False, False, False, True, True, True, True, False, True], relative_score=[0, 0, 1, -1, -2, -4, -5, -3, -5], guid=53772503334370441085334378293107653659),
       Boxscore(team_name='Mark Kean', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144348&profileid=25961#1', hammer_start=True, score=['0', '5', '0', '1', '1', '1', 'X'], final_score='8', draw_num=3, draw='Draw: 3', hammer_progression=[True, True, False, True, False, False, False], relative_score=[0, -1, 4, 3, 4, 5, 6], guid=310456475955908017873561887016699672637),
       Boxscore(team_name='Richard Krell', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477&eventid=6400&teamid=144349&profileid=25962#1', hammer_start=False, score=['1', '0', '1', '0', '0', '0', 'X'], final_score='2', draw_num=3, draw='Draw: 3', hammer_progression=[False, False, True, False, True, True, True], relative_score=[0, 1, -4, -3, -4, -5, -6], guid=310456475955908017873561887016699672637),
       Boxscore(team_name='Damien Villard', href='event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144354&profileid=27373#1', hammer_start=True, score=['2', '1', '0', '1', '0', '0', '1', '0', '0', '0'], final_score='5', draw_num=3, draw='Draw: 3', hammer_progression=[True, False, False, True, False, True, True, False, True, True], relative_score=[0, 2, 3, 2, 3, 1, 1, 2, 1, 0], guid=303047434632680540438656592556261333287),
       Boxscore(team_name='Sam Steep', href='event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144351&profileid=25978#1', hammer_start=False, score=['0', '0', '1', '0', '2', '0', '0', '1', '1', '1'], final_score='6', draw_num=3, draw='Draw: 3', hammer_progression=[False, True, True, False, True, False, False, True, False, False], relative_score=[0, -2, -3, -2, -3, -1, -1, -2, -1, 0], guid=303047434632680540438656592556261333287),
       Boxscore(team_name='Jason March', href='event.php?view=Team&eventid=6400&teamid=144351&profileid=25978&eventid=6400&teamid=144350#1', hammer_start=True, score=['1', '1', '0', '0', '0', '0', '2', '1', '2', 'X'], final_score='7', draw_num=3, draw='Draw: 3', hammer_progression=[True, False, False, True, True, True, True, False, False, False], relative_score=[0, 1, 2, 1, 0, 0, 0, 2, 3, 5], guid=229699058183107339172217417532449914369),
       Boxscore(team_name='Matthew Mepstead', href='event.php?view=Team&eventid=6400&teamid=144351&profileid=25978&eventid=6400&teamid=144356#1', hammer_start=False, score=['0', '0', '1', '1', '0', '0', '0', '0', '0', 'X'], final_score='2', draw_num=3, draw='Draw: 3', hammer_progression=[False, True, True, False, False, False, False, True, True, True], relative_score=[0, -1, -2, -1, 0, 0, 0, -2, -3, -5], guid=229699058183107339172217417532449914369),
       Boxscore(team_name='Wayne Tuck Jr.', href='event.php?view=Team&eventid=6400&teamid=144356&profileid=0&eventid=6400&teamid=144353&profileid=12486#1', hammer_start=False, score=['0', '0', '0', '2', '0', '0', '0', '0', 'X'], final_score='2', draw_num=3, draw='Draw: 3', hammer_progression=[False, True, True, True, False, True, True, True, True], relative_score=[0, -2, -3, -3, -1, -2, -4, -5, -6], guid=195399470224611539512163135746754073908),
       Boxscore(team_name='Rob Ainsley', href='event.php?view=Team&eventid=6400&teamid=144356&profileid=0&eventid=6400&teamid=144345&profileid=15779#1', hammer_start=True, score=['2', '1', '0', '0', '1', '2', '1', '1', 'X'], final_score='8', draw_num=3, draw='Draw: 3', hammer_progression=[True, False, False, False, True, False, False, False, False], relative_score=[0, 2, 3, 3, 1, 2, 4, 5, 6], guid=195399470224611539512163135746754073908),
       Boxscore(team_name='Matthew Hall', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1', hammer_start=True, score=['1', '0', '1', '0', '1', '0', '2', '0', '1', '0'], final_score='6', draw_num=4, draw='Draw: 4', hammer_progression=[True, False, True, False, True, False, True, False, True, False], relative_score=[0, 1, -1, 0, -2, -1, -2, 0, -1, 0], guid=63653233024470732271264476184228625543),
       Boxscore(team_name='Mark Kean', href='event.php?view=Team&eventid=6400&teamid=144348&profileid=25961#1', hammer_start=False, score=['0', '2', '0', '2', '0', '1', '0', '1', '0', '1'], final_score='7', draw_num=4, draw='Draw: 4', hammer_progression=[False, True, False, True, False, True, False, True, False, True], relative_score=[0, -1, 1, 0, 2, 1, 2, 0, 1, 0], guid=63653233024470732271264476184228625543),
       Boxscore(team_name='Sam Steep', href='event.php?view=Team&eventid=6400&teamid=144348&profileid=25961&eventid=6400&teamid=144351&profileid=25978#1', hammer_start=False, score=['1', '0', '0', '2', '0', '1', '1', '0', '1', '1'], final_score='7', draw_num=4, draw='Draw: 4', hammer_progression=[False, False, True, True, False, True, False, False, True, False], relative_score=[0, 1, 0, -2, 0, -2, -1, 0, -1, 0], guid=279469483516704960424550934244064693031),
       Boxscore(team_name='Jason March', href='event.php?view=Team&eventid=6400&teamid=144348&profileid=25961&eventid=6400&teamid=144350#1', hammer_start=True, score=['0', '1', '2', '0', '2', '0', '0', '1', '0', '0'], final_score='6', draw_num=4, draw='Draw: 4', hammer_progression=[True, True, False, False, True, False, True, True, False, True], relative_score=[0, -1, 0, 2, 0, 2, 1, 0, 1, 0], guid=279469483516704960424550934244064693031),
       Boxscore(team_name='Dayna Deruelle', href='event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144346&profileid=26636#1', hammer_start=False, score=['0', '2', '1', '1', '1', '0', '3', 'X'], final_score='8', draw_num=4, draw='Draw: 4', hammer_progression=[False, True, False, False, False, False, True, False], relative_score=[0, -1, 1, 2, 3, 4, 3, 6], guid=291113397726148010907174443006816563924),
       Boxscore(team_name='Rob Ainsley', href='event.php?view=Team&eventid=6400&teamid=144350&profileid=0&eventid=6400&teamid=144345&profileid=15779#1', hammer_start=True, score=['1', '0', '0', '0', '0', '1', '0', 'X'], final_score='2', draw_num=4, draw='Draw: 4', hammer_progression=[True, False, True, True, True, True, False, True], relative_score=[0, 1, -1, -2, -3, -4, -3, -6], guid=291113397726148010907174443006816563924),
       Boxscore(team_name='Sam Steep', href='event.php?view=Team&eventid=6400&teamid=144351&profileid=25978#1', hammer_start=False, score=['0', '1', '0', '0', '0', '2', '0', '2', '0', '0'], final_score='5', draw_num=5, draw='Draw: 5', hammer_progression=[False, False, False, True, True, True, False, True, False, False], relative_score=[0, 0, 1, 0, -1, -3, -1, -3, -1, -1], guid=95866945533461342246819997703085723055),
       Boxscore(team_name='Richard Krell', href='event.php?view=Team&eventid=6400&teamid=144349&profileid=25962#1', hammer_start=True, score=['0', '0', '1', '1', '2', '0', '2', '0', '0', '1'], final_score='7', draw_num=5, draw='Draw: 5', hammer_progression=[True, True, True, False, False, False, True, False, True, True], relative_score=[0, 0, -1, 0, 1, 3, 1, 3, 1, 1], guid=95866945533461342246819997703085723055),
       Boxscore(team_name='Dayna Deruelle', href='event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144346&profileid=26636#1', hammer_start=False, score=['0', '0', '1', '0', '0', '0', '1', '0', '3', '1', '0'], final_score='6', draw_num=5, draw='Draw: 5', hammer_progression=[False, True, True, False, True, True, True, False, True, False, False], relative_score=[0, -1, -1, 0, -1, -1, -3, -2, -4, -1, 0], guid=233581897033627594667237538445333000951),
       Boxscore(team_name='Tyler Stewart', href='event.php?view=Team&eventid=6400&teamid=144349&profileid=25962&eventid=6400&teamid=144352&profileid=12477#1', hammer_start=True, score=['1', '0', '0', '1', '0', '2', '0', '2', '0', '0', '1'], final_score='7', draw_num=5, draw='Draw: 5', hammer_progression=[True, False, False, True, False, False, False, True, False, True, True], relative_score=[0, 1, 1, 0, 1, 1, 3, 2, 4, 1, 0], guid=233581897033627594667237538445333000951),
       Boxscore(team_name='Richard Krell', href='event.php?view=Team&eventid=6400&teamid=144349&profileid=25962#1', hammer_start=False, score=['0', '0', '1', '1', '0', '0', '1', '0', 'X'], final_score='3', draw_num=6, draw='Draw: 6', hammer_progression=[False, False, True, False, False, True, True, False, True], relative_score=[0, 0, -2, -1, 0, -2, -5, -4, -5], guid=61203104491141348409761697458039616615),
       Boxscore(team_name='Tyler Stewart', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477#1', hammer_start=True, score=['0', '2', '0', '0', '2', '3', '0', '1', 'X'], final_score='8', draw_num=6, draw='Draw: 6', hammer_progression=[True, True, False, True, True, False, False, True, False], relative_score=[0, 0, 2, 1, 0, 2, 5, 4, 5], guid=61203104491141348409761697458039616615),
       Boxscore(team_name='Tyler Stewart', href='event.php?view=Team&eventid=6400&teamid=144352&profileid=12477#1', hammer_start=False, score=['0', '0', '1', '1', '0', '3', '0', '0', '1', '0'], final_score='6', draw_num=7, draw='Draw: 7', hammer_progression=[False, False, True, False, False, True, False, False, True, False], relative_score=[0, 0, -1, 0, 1, -2, 1, 1, 0, 1], guid=4915701019265174384644466584441738333),
       Boxscore(team_name='Matthew Hall', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1', hammer_start=True, score=['0', '1', '0', '0', '3', '0', '0', '1', '0', '2'], final_score='7', draw_num=7, draw='Draw: 7', hammer_progression=[True, True, False, True, True, False, True, True, False, True], relative_score=[0, 0, 1, 0, -1, 2, -1, -1, 0, -1], guid=4915701019265174384644466584441738333)]



  ```python
  event.get_flat_boxscores()[0]
  ```




      Boxscore(team_name='Damien Villard', href='event.php?view=Team&eventid=6400&teamid=144354&profileid=27373#1', hammer_start=True, score=['0', '0', '0', '0', 'X'], final_score='0', draw_num=1, draw='Draw: 1', hammer_progression=[True, True, True, True, True], relative_score=[0, -1, -4, -6, -8], guid=209707243860236114112314247393927711356)



  ```python
  event.get_flat_boxscores()[-1]
  ```




      Boxscore(team_name='Matthew Hall', href='event.php?view=Team&eventid=6400&teamid=144347&profileid=12435#1', hammer_start=True, score=['0', '1', '0', '0', '3', '0', '0', '1', '0', '2'], final_score='7', draw_num=7, draw='Draw: 7', hammer_progression=[True, True, False, True, True, False, True, True, False, True], relative_score=[0, 0, 1, 0, -1, 2, -1, -1, 0, -1], guid=4915701019265174384644466584441738333)




  czapi is a Python library for scraping curling linescores.


pkgId: bb753b787fb227261f53dfa6bd744511146cafb2b841eaa7dd9e148e5a05e1c2
name: python-czech-holidays
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Python package with Czech public holidays
url: https://github.com/honzajavorek/czech-holidays
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czech-holidays-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Python package with `Czech public holidays <https://en.wikipedia.org/wiki/Public_holidays_in_the_Czech_Republic>`_.


pkgId: a2e55f5d6d8ada5dd706cdabb8ce05aeecf0f3d42288b39fce758a3e065bae88
name: python-czech-number-utils
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Convert numbers to Czech text representations
url: https://github.com/zbyso23/czech-number-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czech-number-utils-1.0.2-1.src.rpm
checksum_type: sha256
description:
  Czech Number Utilities is a Python module for converting numbers into their textual representations in Czech, both cardinal and ordinal forms. It supports grammatical cases and handles large numbers up to billions.



  - Convert numbers to Czech cardinal and ordinal forms.
  - Handles complex numbers like millions and billions.
  - Supports grammatical rules specific to Czech.



  You can install the package directly from PyPI:

  ```bash
  pip install czech-number-utils
  ```



  ```python
  from czech_number_utils import number_to_czech_word, number_to_czech_ordinal


  print(number_to_czech_word(1379))  # Output: "tisíc tři sta sedmdesát devět"


  print(number_to_czech_ordinal(23))  # Output: "dvacátý třetí"
  ```



  Contributions are welcome! Please submit issues or pull requests on the [GitHub repository](https://github.com/zbyso23/czech-number-utils).



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


pkgId: 1ffcc0d4d739d07bbc40c98f6b3f2720304872a8ca3cff4b7c6d38ce0d830bf6
name: python-czech-workdays-holidays
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Czech Workdays, Holidays and Shopping Days
url: https://github.com/david-gamba/Czech-Working-Days
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czech-workdays-holidays-0.1.11-1.src.rpm
checksum_type: sha256
description:
   This package includes Czech public and other holidays which are not working days,
   working days calculator for selected year, the possibility to get public holidays that are during the weekend
   and shopping days.

  Working with holidays, you always have to select year. Additionally, you can choose to get only dates, dates with
  English or Czech names of holidays or holidays that are working restricted.

  Working with workdays, you always have to select year. Additionally, you can choose to include Saturday and Sunday
  as workday. Combinations of these parameters
  are possible.

  Working with workdays, you always have to select year.Additionally, you can choose to exclude Saturdays and Sundays
  and/or include shopping restricted days.

  Data are valid since 2001. If selected year before 2001, exception is raised.


  [Czech holidays in English](https://en.wikipedia.org/wiki/Public_holidays_in_the_Czech_Republic)
  [Czech holidys in Czech](https://cs.wikipedia.org/wiki/%C4%8Cesk%C3%BD_st%C3%A1tn%C3%AD_sv%C3%A1tek)


  [Czech Holidays](https://www.zakonyprolidi.cz/cs/2000-245?text=245%2F2000)
  [Restricted shopping days](https://www.zakonyprolidi.cz/cs/2016-223)


  `pip install czech-workdays-holidays`


  `import czech_workdays_holidays`




  This function generates holidays (public and other) when working is usually restricted according to labor law. It offers options to filter dates only, Czech or English names, and shopping-restricted days.

  Raises exception if year entered is 2000 and earlier.


  Calling function `get_holidays()` with argument `dates_only=True` will return unsorted list

  ```Python
  >>> from czech_workdays_holidays import get_holidays
  >>> get_holidays(2023, dates_only=True)

  [datetime.date(2023, 5, 1), datetime.date(2023, 4, 7), datetime.date(2023, 10, 28), datetime.date(2023, 12, 25), datetime.date(2023, 12, 26), datetime.date(2023, 4, 10), datetime.date(2023, 7, 5), datetime.date(2023, 11, 17), datetime.date(2023, 12, 24), datetime.date(2023, 5, 8), datetime.date(2023, 7, 6), datetime.date(2023, 9, 28), datetime.date(2023, 1, 1)]
  ```



  This function calculates the number of workdays in a given year, taking into account optional parameters for including or excluding weekend days and holidays

  By default, function return workdays in a given year. If parameters are set to False, it will return Monday to Friday days.

  In case you set `include_saturday=True`, it will return Monday to Saturday days but Saturdays that are also holidays would be excluded.
  In case you set `include_holidays=True` and including weekend days would remain False then holidays during weekend would not be returned.

  Raises exception if year entered is 2000 and earlier



  Calling function `get_workdays()` with argument `include_holidays=True` and with argument `include_sunday` will return sorted list of `datetime.date(YYYY/MM//DD)` workdays

  Notice that 2023/1/1 was a Sunday and Holiday and it is in the output. If one of those arguments were False, it would not appear

  ```Python
  >>> from czech_workdays_holidays import get_workdays
  >>> get_workdays(2023, include_sunday=True, include_holidays=True)

  [datetime.date(2023, 1, 1), datetime.date(2023, 1, 2), datetime.date(2023, 1, 3), ... , datetime.date(2023, 12, 31)]
  ```



  Gets all shopping days in a given year. Full year returned if all parameters are True. Possibility to combine
  parameters

  In the output, 2023/1/1 is excluded as it is Sunday and shopping restricted day then 2023/30/12 is included
  as it is Saturday which has set default value to true: `include_saturday=True`. Then 2023/31/12 is excluded
  as it is Sunday.

  Raises exception if year entered is 2000 and earlier.



  ```Python
  >>> from czech_workdays_holidays import get_shopping_days
  >>> get_shopping_days(2023, include_sunday=False, exclude_shopping_restricted_days=False)

  [datetime.date(2023, 1, 2), datetime.date(2023, 1, 3), ... , datetime.date(2023, 12, 29), datetime.date(2023, 12, 30)]
  ```



  Returns all holidays in given year that are during weekend

  Raises exception if year entered is 2000 and earlier.



  ```Python
  >>> from czech_workdays_holidays import get_holidays_during_weekend
  >>> get_holidays_during_weekend(2023)

  [datetime.date(2023, 1, 1), datetime.date(2023, 10, 28), datetime.date(2023, 12, 24)]
  ```



  Returns all workdays in given year that are during weekend with possibility to exclude Sunday/Saturday
  and include holidays. If weekend parameters set to True and `include_holidays=False` the function would
  not return workdays that are during weekend and are holidays.

  Raises exception if year entered is 2000 and earlier.

  In example below, 1/1/2023 and 24/12/2023 are excluded as it is Sunday and holiday.



  ```Python
  >>> from czech_workdays_holidays import get_workdays_during_weekend
  >>> get_workdays_during_weekend(2023)

  [datetime.date(2023, 1, 7), datetime.date(2023, 1, 8), datetime.date(2023, 1, 14), ... , datetime.date(2023, 12, 23), datetime.date(2023, 12, 30), datetime.date(2023, 12, 31)]
  ```


pkgId: 8daec3cb6f7f88fa40d5239ab89fa74967dda51957ba5c989b96dfb7986fee6e
name: python-czespressif
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Commitizen plugin with Espressif code style
url: https://github.com/espressif/cz-plugin-espressif/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czespressif-1.3.0-1.src.rpm
checksum_type: sha256
description:
  - Can be almost zero-config but offers many customization options if your project needs it.
  - Predefined **CHANGELOG template** with default categories _Breaking changes / New features / Bug fixes / Documentation / Code refactoring / Removals_.
  - The CHANGELOG automatically displays commits and the authors of those commits.
  - The default order in the changelog categories lists commits with a scope first, followed by the rest, both groups sorted alphabetically.
  - Predefined **Release Notes template** that can be used in an automated release workflow.
  - `cz commit` command with default Espressif commit types, aligned with the Espressif pre-commit linter.


pkgId: b83d789b945b226ff088ed7b7fdb6f8f8a0665c2c578dd97bd4c4fda904fd885
name: python-czifile
arch: src
version: 2019.7.2
epoch: 0
release: 1
summary: Read Carl Zeiss(r) Image (CZI) files
url: https://www.lfd.uci.edu/~gohlke/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czifile-2019.7.2-1.src.rpm
checksum_type: sha256
description:
  Czifile is a Python library to read Carl Zeiss Image (CZI) files, the native
  file format of the ZEN(r) software by Carl Zeiss Microscopy GmbH. CZI files
  contain multidimensional images and metadata from microscopy experiments.
    `Christoph Gohlke <https://www.lfd.uci.edu/~gohlke/>`_
    Laboratory for Fluorescence Dynamics. University of California, Irvine


pkgId: 654b4b1f47ee3f0e905aef128adb20d8c130b1112fe3e8ace30438b2b56042a8
name: python-czitools
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: Tools to simplify reading CZI (Carl Zeiss Image) meta and pixel data
url: https://github.com/sebi06/czitools
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czitools-0.7.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/czitools.svg?color=green)](https://pypi.org/project/czitools)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/czitools)](https://pypistats.org/packages/czitools)
  [![License](https://img.shields.io/pypi/l/czitools.svg?color=green)](https://github.com/sebi06/czitools/raw/master/LICENSE)
  [![Python Version](https://img.shields.io/pypi/pyversions/czitools.svg?color=green)](https://python.org)
  [![Development Status](https://img.shields.io/pypi/status/czitools.svg)](https://en.wikipedia.org/wiki/Software_release_life_cycle#Alpha)

  This repository provides a collection of tools to simplify reading CZI (Carl Zeiss Image) pixel and metadata in Python. In addition, it also contains other useful utilities to visualize CZI images inside Napari (needs to be installed). It is also available as a [Python Package on PyPi](https://pypi.org/project/czitools/)



  To install the basic functionality (will not install Napari und plotting functionality) use:

  ```text
  pip install czitools
  ```

  To install the package with all optional dependencies use:

  ```text
  pip install czitools[all]
  ```



  Please check [use_metadata_tools.py](https://github.com/sebi06/czitools/blob/main/demo/scripts/use_metadata_tools.py) for some examples.

  ```python
  from czitools.metadata_tools.czi_metadata import CziMetadata, writexml
  from czitools.metadata_tools.dimension import CziDimensions
  from czitools.metadata_tools.boundingbox import CziBoundingBox
  from czitools.metadata_tools.channel import CziChannelInfo
  from czitools.metadata_tools.scaling import CziScaling
  from czitools.metadata_tools.sample import CziSampleInfo
  from czitools.metadata_tools.objective import CziObjectives
  from czitools.metadata_tools.microscope import CziMicroscope
  from czitools.metadata_tools.add_metadata import CziAddMetaData
  from czitools.metadata_tools.detector import CziDetector
  from czitools.read_tools import read_tools
  from czitools.napari_tools import napari_tools
  import napari


  mdata = CziMetadata(filepath)


  czi_dimensions = CziDimensions(filepath)
  print("SizeS: ", czi_dimensions.SizeS)
  print("SizeT: ", czi_dimensions.SizeT)
  print("SizeZ: ", czi_dimensions.SizeZ)
  print("SizeC: ", czi_dimensions.SizeC)
  print("SizeY: ", czi_dimensions.SizeY)
  print("SizeX: ", czi_dimensions.SizeX)


  xmlfile = writexml(filepath)


  czi_channels = CziChannelInfo(filepath)


  czimd_complete = get_metadata_as_object(filepath)


  czi_dimensions = CziDimensions(filepath)


  czi_scale = CziScaling(filepath)


  czi_sample = CziSampleInfo(filepath)


  czi_objectives = CziObjectives(filepath)
  czi_detectors = CziDetector(filepath)
  czi_microscope = CziMicroscope(filepath)


  czi_sample = CziSampleInfo(filepath)


  czi_addmd = CziAddMetaData(filepath)


  czi_bbox = CziBoundingBox(filepath)
  ```



  While the [pylibCZIrw](https://pypi.org/project/pylibCZIrw/) is focussing on reading individual planes it is also helpful to read CZI pixel data as a STCZYX(A) stack. Please check [use_read_tools.py](https://github.com/sebi06/czitools/blob/main/demo/scripts/use_read_tools.py) for some examples.

  ```python

  array6d, mdata = read_tools.read_6darray(filepath,
                                           use_dask=True,
                                           chunk_zyx=False,
                                           
                                           
                                           
                                           
                                          )

  if array6d is None:
      print("Empty array6d. Nothing to display in Napari")
  else:

      
      viewer = napari.Viewer()
      layers = napari_tools.show(viewer, array6d, mdata,
                                 blending="additive",
                                 contrast='from_czi',
                                 gamma=0.85,
                                 show_metadata="tree",
                                 name_sliders=True)

      napari.run()
  ```

  ![5D CZI inside Napari](https://github.com/sebi06/czitools/raw/main/images/czi_napari1.png)





  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/read_czi_metadata.ipynb)



  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/read_czi_pixeldata.ipynb)



  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/omezarr_from_czi_5d.ipynb)




  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/save_with_ZSTD_compression.ipynb)



  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/show_czi_surface.ipynb)



  The basic usage can be inferred from this sample notebook:&nbsp;
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/sebi06/czitools/blob/main/demo/notebooks/read_czi_segment_voroni_otsu.ipynb)



  The code to read multi-dimensional with delayed reading using Dask array was heavily inspired by input from: [Pradeep Rajasekhar](https://github.com/pr4deepr).

  Local installation (base functionality only):

  ```text
  pip install -e .
  ```



  Local installation (full functionality):

  ```text
  pip install -e ".[all]"
  ```


pkgId: 20975e3a19e866c00b0c21f0c0a56402adddd78eb0a836361f178b9a965d6779
name: python-czlai
arch: src
version: 0.1.0a4
epoch: 0
release: 1
summary: The official Python library for the czlai API
url: https://github.com/CZL-AI/czlai-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czlai-0.1.0a4-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/czlai.svg)](https://pypi.org/project/czlai/)

  The Czlai Python library provides convenient access to the Czlai REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).


  The REST API documentation can be found on [docs.gjpet.com](https://docs.gjpet.com). The full API of this library can be found in [api.md](https://github.com/CZL-AI/czlai-python/tree/main/api.md).



  ```sh

  pip install --pre czlai
  ```



  The full API of this library can be found in [api.md](https://github.com/CZL-AI/czlai-python/tree/main/api.md).

  ```python
  from czlai import Czlai

  client = Czlai()

  response = client.ai_checkup.session_start()
  print(response.data)
  ```

  While you can provide a `bearer_token` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `BEARER_TOKEN="My Bearer Token"` to your `.env` file
  so that your Bearer Token is not stored in source control.



  Simply import `AsyncCzlai` instead of `Czlai` and use `await` with each API call:

  ```python
  import asyncio
  from czlai import AsyncCzlai

  client = AsyncCzlai()


  async def main() -> None:
      response = await client.ai_checkup.session_start()
      print(response.data)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `czlai.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `czlai.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `czlai.APIError`.

  ```python
  import czlai
  from czlai import Czlai

  client = Czlai()

  try:
      client.ai_checkup.session_start()
  except czlai.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except czlai.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except czlai.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from czlai import Czlai


  client = Czlai(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).ai_checkup.session_start()
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from czlai import Czlai


  client = Czlai(
      
      timeout=20.0,
  )


  client = Czlai(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).ai_checkup.session_start()
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/CZL-AI/czlai-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `CZLAI_LOG` to `info`.

  ```shell
  $ export CZLAI_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from czlai import Czlai

  client = Czlai()
  response = client.ai_checkup.with_raw_response.session_start()
  print(response.headers.get('X-My-Header'))

  ai_checkup = response.parse()  # get the object that `ai_checkup.session_start()` would have returned
  print(ai_checkup.data)
  ```

  These methods return an [`APIResponse`](https://github.com/CZL-AI/czlai-python/tree/main/src/czlai/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/CZL-AI/czlai-python/tree/main/src/czlai/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.ai_checkup.with_streaming_response.session_start() as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for proxies
  - Custom transports
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  from czlai import Czlai, DefaultHttpxClient

  client = Czlai(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/CZL-AI/czlai-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import czlai
  print(czlai.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/CZL-AI/czlai-python/tree/main/./CONTRIBUTING.md).


pkgId: 06bf7127da291c67d34667bf8947597317f1775f18d2fa020f785e7c379673fa
name: python-czml3
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Python 3 library to write CZML
url: https://github.com/poliastro/czml3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czml3-1.0.2-1.src.rpm
checksum_type: sha256
description:
  From the official
  `CZML Guide <https://github.com/AnalyticalGraphicsInc/czml-writer/wiki/CZML-Guide>`_:
    CZML is a JSON format for describing a time-dynamic graphical scene,
    primarily for display in a web browser running Cesium.
    It describes lines, points, billboards, models, and other graphical primitives,
    and specifies how they change with time.
    While Cesium has a rich client-side API,
    CZML allows it to be data-driven
    so that a generic Cesium viewer can display a rich scene
    without the need for any custom code.


pkgId: d381b3adec82a54ef4b578db8a6bb99b6d87dfdcf6fa1abccea5338663e8b305
name: python-czpubtran
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Calling CHAPS REST API to get information about public transit in CZ
url: https://github.com/bruxy70/CzPubTran
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czpubtran-0.2.1-1.src.rpm
checksum_type: sha256
description:
  A Python package to rertrieve realtime information about public transit in CZ by calling CHAPS REST API.

  Main purpose at the moment is to feed a sensor in Home-Assistant



  pip install czpubtran



  ```
  import asyncio
  import logging
  import aiohttp
  from datetime import datetime, time
  from czpubtran.api import czpubtran

  logging.basicConfig(level=logging.ERROR)

  async def test():
      session = aiohttp.ClientSession(raise_for_status=True)
      bus = czpubtran(session, '')

      timetables = await bus.async_list_combination_ids()
      print("Listing available timetables (Combination IDs)")
      print(timetables)

      print('------------------------------------------------')

      await bus.async_find_connection('Namesti Republiky', 'Chodov', 'ABCz')
      print(f'First connection from {bus.origin} to {bus.destination} using timetable {bus.combination_id}:')
      print(f'Departure: {bus.departure} line {bus.line}')
      print(f'Duration: {bus.duration}')
      print('Connections:')
      for i, description in [(0, '1st connection'), (1, '2nd connection')]:
          print(f'{description}:')
          for detail in bus.connection_detail[i]:
              print(
                  f"line {detail['line']} "
                  f"at {detail['depTime']} "
                  f"from {detail['depStation']} "
                  f"-> {detail['arrStation']} "
                  f"{detail['arrTime']} "
                  f"(delay: {detail['delay']} min)")

      print('------------------------------------------------')

      await bus.async_find_connection('Namesti Republiky', 'Chodov', 'ABCz', '23:20')
      print(f'Scheduled connection from {bus.origin} to {bus.destination} at {bus.start_time}:')
      print(f'Departure: {bus.departure} line {bus.line}')
      print(f'Duration: {bus.duration}')
      print('Connections:')
      for i, description in [(0, '1st connection'), (1, '2nd connection')]:
          print(f'{description}:')
          for detail in bus.connection_detail[i]:
              print(
                  f"line {detail['line']} "
                  f"at {detail['depTime']} "
                  f"from {detail['depStation']} "
                  f"-> {detail['arrStation']} "
                  f"{detail['arrTime']} "
                  f"(delay: {detail['delay']} min)")

      await session.close()

  asyncio.run(test())

  ```


pkgId: 4314ceabef37d5250aefb036bf2518aa55b75906d2d553a394155b9aff2c9a62
name: python-czzOpenAi
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: The czczz Python library for the openai API base on openAI v1.43.0
url: https://github.com/czczz/openai-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-czzOpenAi-1.0.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/openai.svg)](https://pypi.org/project/openai/)

  The OpenAI Python library provides convenient access to the OpenAI REST API from any Python 3.7+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated from our [OpenAPI specification](https://github.com/openai/openai-openapi) with [Stainless](https://stainlessapi.com/).



  The REST API documentation can be found on [platform.openai.com](https://platform.openai.com/docs). The full API of this library can be found in [api.md](https://github.com/openai/openai-python/tree/main/api.md).



  > [!IMPORTANT]
  > The SDK was rewritten in v1, which was released November 6th 2023. See the [v1 migration guide](https://github.com/openai/openai-python/discussions/742), which includes scripts to automatically update your code.

  ```sh

  pip install openai
  ```



  The full API of this library can be found in [api.md](https://github.com/openai/openai-python/tree/main/api.md).

  ```python
  import os
  from openai import OpenAI

  client = OpenAI(
      
      api_key=os.environ.get("OPENAI_API_KEY"),
  )

  chat_completion = client.chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "Say this is a test",
          }
      ],
      model="gpt-3.5-turbo",
  )
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `OPENAI_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  When interacting with the API some actions such as starting a Run and adding files to vector stores are asynchronous and take time to complete. The SDK includes
  helper functions which will poll the status until it reaches a terminal state and then return the resulting object.
  If an API method results in an action that could benefit from polling there will be a corresponding version of the
  method ending in '\_and_poll'.

  For instance to create a Run and poll until it reaches a terminal state you can run:

  ```python
  run = client.beta.threads.runs.create_and_poll(
      thread_id=thread.id,
      assistant_id=assistant.id,
  )
  ```

  More information on the lifecycle of a Run can be found in the [Run Lifecycle Documentation](https://platform.openai.com/docs/assistants/how-it-works/run-lifecycle)



  When creating and interacting with vector stores, you can use polling helpers to monitor the status of operations.
  For convenience, we also provide a bulk upload helper to allow you to simultaneously upload several files at once.

  ```python
  sample_files = [Path("sample-paper.pdf"), ...]

  batch = await client.vector_stores.file_batches.upload_and_poll(
      store.id,
      files=sample_files,
  )
  ```



  The SDK also includes helpers to process streams and handle incoming events.

  ```python
  with client.beta.threads.runs.stream(
      thread_id=thread.id,
      assistant_id=assistant.id,
      instructions="Please address the user as Jane Doe. The user has a premium account.",
  ) as stream:
      for event in stream:
          
          if event.type == "thread.message.delta" and event.data.delta.content:
              print(event.data.delta.content[0].text)
  ```

  More information on streaming helpers can be found in the dedicated documentation: [helpers.md](https://github.com/openai/openai-python/tree/main/helpers.md)



  Simply import `AsyncOpenAI` instead of `OpenAI` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from openai import AsyncOpenAI

  client = AsyncOpenAI(
      
      api_key=os.environ.get("OPENAI_API_KEY"),
  )


  async def main() -> None:
      chat_completion = await client.chat.completions.create(
          messages=[
              {
                  "role": "user",
                  "content": "Say this is a test",
              }
          ],
          model="gpt-3.5-turbo",
      )


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  We provide support for streaming responses using Server Side Events (SSE).

  ```python
  from openai import OpenAI

  client = OpenAI()

  stream = client.chat.completions.create(
      model="gpt-4",
      messages=[{"role": "user", "content": "Say this is a test"}],
      stream=True,
  )
  for chunk in stream:
      print(chunk.choices[0].delta.content or "", end="")
  ```

  The async client uses the exact same interface.

  ```python
  from openai import AsyncOpenAI

  client = AsyncOpenAI()


  async def main():
      stream = await client.chat.completions.create(
          model="gpt-4",
          messages=[{"role": "user", "content": "Say this is a test"}],
          stream=True,
      )
      async for chunk in stream:
          print(chunk.choices[0].delta.content or "", end="")


  asyncio.run(main())
  ```



  > [!IMPORTANT]
  > We highly recommend instantiating client instances instead of relying on the global client.

  We also expose a global client instance that is accessible in a similar fashion to versions prior to v1.

  ```py
  import openai


  openai.api_key = '...'


  openai.base_url = "https://..."
  openai.default_headers = {"x-foo": "true"}

  completion = openai.chat.completions.create(
      model="gpt-4",
      messages=[
          {
              "role": "user",
              "content": "How do I output all files in a directory using Python?",
          },
      ],
  )
  print(completion.choices[0].message.content)
  ```

  The API is the exact same as the standard client instance-based API.

  This is intended to be used within REPLs or notebooks for faster iteration, **not** in application code.

  We recommend that you always instantiate a client (e.g., with `client = OpenAI()`) in application code because:

  - It can be difficult to reason about where client options are configured
  - It's not possible to change certain client options without potentially causing race conditions
  - It's harder to mock for testing purposes
  - It's not possible to control cleanup of network connections



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  List methods in the OpenAI API are paginated.

  This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:

  ```python
  from openai import OpenAI

  client = OpenAI()

  all_jobs = []

  for job in client.fine_tuning.jobs.list(
      limit=20,
  ):
      
      all_jobs.append(job)
  print(all_jobs)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from openai import AsyncOpenAI

  client = AsyncOpenAI()


  async def main() -> None:
      all_jobs = []
      
      async for job in client.fine_tuning.jobs.list(
          limit=20,
      ):
          all_jobs.append(job)
      print(all_jobs)


  asyncio.run(main())
  ```

  Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:

  ```python
  first_page = await client.fine_tuning.jobs.list(
      limit=20,
  )
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.data)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.fine_tuning.jobs.list(
      limit=20,
  )

  print(f"next page cursor: {first_page.after}")  # => "next page cursor: ..."
  for job in first_page.data:
      print(job.id)


  ```



  Nested parameters are dictionaries, typed using `TypedDict`, for example:

  ```python
  from openai import OpenAI

  client = OpenAI()

  completion = client.chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "Can you generate an example json object describing a fruit?",
          }
      ],
      model="gpt-3.5-turbo-1106",
      response_format={"type": "json_object"},
  )
  ```



  Request parameters that correspond to file uploads can be passed as `bytes`, a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance or a tuple of `(filename, contents, media type)`.

  ```python
  from pathlib import Path
  from openai import OpenAI

  client = OpenAI()

  client.files.create(
      file=Path("input.jsonl"),
      purpose="fine-tune",
  )
  ```

  The async client uses the exact same interface. If you pass a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance, the file contents will be read asynchronously automatically.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `openai.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `openai.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `openai.APIError`.

  ```python
  import openai
  from openai import OpenAI

  client = OpenAI()

  try:
      client.fine_tuning.jobs.create(
          model="gpt-3.5-turbo",
          training_file="file-abc123",
      )
  except openai.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except openai.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except openai.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from openai import OpenAI


  client = OpenAI(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "How can I get the name of the current day in Node.js?",
          }
      ],
      model="gpt-3.5-turbo",
  )
  ```



  By default requests time out after 10 minutes. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from openai import OpenAI


  client = OpenAI(
      
      timeout=20.0,
  )


  client = OpenAI(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "How can I list all files in a directory using Python?",
          }
      ],
      model="gpt-3.5-turbo",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/openai/openai-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `OPENAI_LOG` to `debug`.

  ```shell
  $ export OPENAI_LOG=debug
  ```



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from openai import OpenAI

  client = OpenAI()
  response = client.chat.completions.with_raw_response.create(
      messages=[{
          "role": "user",
          "content": "Say this is a test",
      }],
      model="gpt-3.5-turbo",
  )
  print(response.headers.get('X-My-Header'))

  completion = response.parse()  # get the object that `chat.completions.create()` would have returned
  print(completion)
  ```

  These methods return an [`LegacyAPIResponse`](https://github.com/openai/openai-python/tree/main/src/openai/_legacy_response.py) object. This is a legacy class as we're changing it slightly in the next major version.

  For the sync client this will mostly be the same with the exception
  of `content` & `text` will be methods instead of properties. In the
  async client, all methods will be async.

  A migration script will be provided & the migration in general should
  be smooth.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  As such, `.with_streaming_response` methods return a different [`APIResponse`](https://github.com/openai/openai-python/tree/main/src/openai/_response.py) object, and the async client returns an [`AsyncAPIResponse`](https://github.com/openai/openai-python/tree/main/src/openai/_response.py) object.

  ```python
  with client.chat.completions.with_streaming_response.create(
      messages=[
          {
              "role": "user",
              "content": "Say this is a test",
          }
      ],
      model="gpt-3.5-turbo",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for proxies
  - Custom transports
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  from openai import OpenAI, DefaultHttpxClient

  client = OpenAI(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  To use this library with [Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/overview), use the `AzureOpenAI`
  class instead of the `OpenAI` class.

  > [!IMPORTANT]
  > The Azure API shape differs from the core API shape which means that the static types for responses / params
  > won't always be correct.

  ```py
  from openai import AzureOpenAI


  client = AzureOpenAI(
      
      api_version="2023-07-01-preview",
      
      azure_endpoint="https://example-endpoint.openai.azure.com",
  )

  completion = client.chat.completions.create(
      model="deployment-name",  # e.g. gpt-35-instant
      messages=[
          {
              "role": "user",
              "content": "How do I output all files in a directory using Python?",
          },
      ],
  )
  print(completion.to_json())
  ```

  In addition to the options provided in the base `OpenAI` client, the following options are provided:

  - `azure_endpoint` (or the `AZURE_OPENAI_ENDPOINT` environment variable)
  - `azure_deployment`
  - `api_version` (or the `OPENAI_API_VERSION` environment variable)
  - `azure_ad_token` (or the `AZURE_OPENAI_AD_TOKEN` environment variable)
  - `azure_ad_token_provider`

  An example of using the client with Microsoft Entra ID (formerly known as Azure Active Directory) can be found [here](https://github.com/openai/openai-python/blob/main/examples/azure_ad.py).



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/openai/openai-python/issues) with questions, bugs, or suggestions.



  Python 3.7 or higher.


pkgId: 0c6ed7a2f5651083970a933cbe2ec404bfcbc1b60a4e07785a88ebddf94f2810
name: python-d20
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A formal grammar-based dice parser and roller for D&D and other dice systems.
url: https://github.com/avrae/formaldice
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d20-1.1.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version shields.io](https://img.shields.io/pypi/v/d20.svg)](https://pypi.python.org/pypi/d20/)
  [![PyPI license](https://img.shields.io/pypi/l/d20.svg)](https://pypi.python.org/pypi/d20/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/d20.svg)](https://pypi.python.org/pypi/d20/)
  ![](https://github.com/avrae/d20/workflows/Test%20Package/badge.svg)
  [![codecov](https://codecov.io/gh/avrae/d20/branch/master/graph/badge.svg)](https://codecov.io/gh/avrae/d20)
  [![Documentation Status](https://readthedocs.org/projects/d20/badge/?version=latest)](https://d20.readthedocs.io/en/latest/start.html?badge=latest)




  A fast, powerful, and extensible dice engine for D&D, d20 systems, and any other system that needs dice!


  - Quick to start - just use `d20.roll()`!
  - Optimized for speed and memory efficiency
  - Highly extensible API for custom behaviour and dice stringification
  - Built-in execution limits against malicious dice expressions
  - Tree-based dice representation for easy traversal


  **Requires Python 3.6+**.

  ```bash
  python3 -m pip install -U d20
  ```



  ```python
  >>> import d20
  >>> result = d20.roll("1d20+5")
  >>> str(result)
  '1d20 (10) + 5 = `15`'
  >>> result.total
  15
  >>> result.crit
  <CritType.NORMAL: 0>
  >>> str(result.ast)
  '1d20 + 5'
  ```



  Check out the docs on [Read the Docs](https://d20.readthedocs.io/en/latest/start.html)!


  This is the grammar supported by the dice parser, roughly ordered in how tightly the grammar binds.


  These are the atoms used at the base of the syntax tree.

  | Name    | Syntax                            | Description           | Examples                       |
  |---------|-----------------------------------|-----------------------|--------------------------------|
  | literal | `INT`, `DECIMAL`                  | A literal number.     | `1`, `0.5`, `3.14`             |
  | dice    | `INT? "d" (INT \| "%")`           | A set of die.         | `d20`, `3d6`                   |
  | set     | `"(" (num ("," num)* ","?)? ")"`  | A set of expressions. | `()`, `(2,)`, `(1, 3+3, 1d20)` |

  Note that `(3d6)` is equivalent to `3d6`, but `(3d6,)` is the set containing the one element `3d6`.


  These operations can be performed on dice and sets.


  | Name    | Syntax            | Description       | Examples           |
  |---------|-------------------|-------------------|--------------------|
  | set_op  | `operation selector` | An operation on a set (see below). | `kh3`, `ro<3` |
  | selector | `seltype INT` | A selection on a set (see below). | `3`, `h1`, `>2` |


  Operators are always followed by a selector, and operate on the items in the set that match the selector.

  | Syntax | Name | Description |
  |---|---|---|
  | k | keep | Keeps all matched values. |
  | p | drop | Drops all matched values. |
  | rr | reroll | Rerolls all matched values until none match. (Dice only) |
  | ro | reroll once | Rerolls all matched values once. (Dice only) |
  | ra | reroll and add | Rerolls up to one matched value once, keeping the original roll. (Dice only) |
  | e | explode on | Rolls another die for each matched value. (Dice only) |
  | mi | minimum | Sets the minimum value of each die. (Dice only) |
  | ma | maximum | Sets the maximum value of each die. (Dice only) |


  Selectors select from the remaining kept values in a set.

  | Syntax | Name | Description |
  |---|---|---|
  | X | literal | All values in this set that are literally this value. |
  | hX | highest X | The highest X values in the set. |
  | lX | lowest X | The lowest X values in the set. |
  | \>X | greater than X | All values in this set greater than X. |
  | <X | less than X | All values in this set less than X. |


  | Syntax | Name | Description |
  |---|---|---|
  | +X | positive | Does nothing. |
  | -X | negative | The negative value of X. |


  | Syntax | Name |
  |---|---|
  | X * Y | multiplication |
  | X / Y | division |
  | X // Y | int division |
  | X % Y | modulo |
  | X + Y | addition |
  | X - Y | subtraction |
  | X == Y | equality |
  | X >= Y | greater/equal |
  | X <= Y | less/equal |
  | X > Y | greater than |
  | X < Y | less than |
  | X != Y | inequality |


  ```python
  >>> from d20 import roll
  >>> r = roll("4d6kh3")  # highest 3 of 4 6-sided dice
  >>> r.total
  14
  >>> str(r)
  '4d6kh3 (4, 4, **6**, ~~3~~) = `14`'

  >>> r = roll("2d6ro<3")  # roll 2d6s, then reroll any 1s or 2s once
  >>> r.total
  9
  >>> str(r)
  '2d6ro<3 (**~~1~~**, 3, **6**) = `9`'

  >>> r = roll("8d6mi2")  # roll 8d6s, with each die having a minimum roll of 2
  >>> r.total
  33
  >>> str(r)
  '8d6mi2 (1 -> 2, **6**, 4, 2, **6**, 2, 5, **6**) = `33`'

  >>> r = roll("(1d4 + 1, 3, 2d6kl1)kh1")  # the highest of 1d4+1, 3, and the lower of 2 d6s
  >>> r.total
  3
  >>> str(r)
  '(1d4 (2) + 1, ~~3~~, ~~2d6kl1 (2, 5)~~)kh1 = `3`'
  ```


  By default, d20 stringifies the result of each dice roll formatted in Markdown, which may not be useful in your application.
  To change this behaviour, you can create a subclass of [`d20.Stringifier`](https://github.com/avrae/d20/blob/master/d20/stringifiers.py)
  (or `d20.SimpleStringifier` as a starting point), and implement the `_str_*` methods to customize how your dice tree is stringified.

  Then, simply pass an instance of your stringifier into the `roll()` function!
  ```python
  >>> import d20
  >>> class MyStringifier(d20.SimpleStringifier):
  ...     def _stringify(self, node):
  ...         if not node.kept:
  ...             return 'X'
  ...         return super()._stringify(node)
  ...
  ...     def _str_expression(self, node):
  ...         return f"The result of the roll {self._stringify(node.roll)} was {int(node.total)}"

  >>> result = d20.roll("4d6e6kh3", stringifier=MyStringifier())
  >>> str(result)
  'The result of the roll 4d6e6kh3 (X, 5, 6!, 6!, X, X) was 17'
  ```


  Each dice node supports value annotations - i.e., a method to "tag" parts of a roll with some indicator. For example,
  ```python
  >>> from d20 import roll
  >>> str(roll("3d6 [fire] + 1d4 [piercing]"))
  '3d6 (3, 2, 2) [fire] + 1d4 (3) [piercing] = `10`'

  >>> str(roll("-(1d8 + 3) [healing]"))
  '-(1d8 (7) + 3) [healing] = `-10`'

  >>> str(roll("(1 [one], 2 [two], 3 [three])"))
  '(1 [one], 2 [two], 3 [three]) = `6`'
  ```
  are all examples of valid annotations. Annotations are purely visual and do not affect the evaluation of the roll by default.

  Additionally, when `allow_comments=True` is passed to `roll()`, the result of the roll may have a comment:
  ```python
  >>> from d20 import roll
  >>> result = roll("1d20 I rolled a d20", allow_comments=True)
  >>> str(result)
  '1d20 (13) = `13`'
  >>> result.comment
  'I rolled a d20'
  ```
  Note that while `allow_comments` is enabled, AST caching is disabled, which may lead to slightly worse performance.


  The raw results of dice rolls are returned in [`Expression`](https://github.com/avrae/d20/blob/master/d20/models.py#L76)
  objects, which can be accessed as such:
  ```python
  >>> from d20 import roll
  >>> result = roll("3d6 + 1d4 + 3")
  >>> str(result)
  '3d6 (4, **6**, **6**) + 1d4 (**1**) + 3 = `20`'
  >>> result.expr
  <Expression roll=<BinOp left=<BinOp left=<Dice num=3 size=6 values=[<Die size=6 values=[<Literal 4>]>, <Die size=6 values=[<Literal 6>]>, <Die size=6 values=[<Literal 6>]>] operations=[]> op=+ right=<Dice num=1 size=4 values=[<Die size=4 values=[<Literal 1>]>] operations=[]>> op=+ right=<Literal 3>> comment=None>
  ```
  or, in a easier-to-read format,
  ```text
  <Expression
      roll=<BinOp
          left=<BinOp
              left=<Dice
                  num=3
                  size=6
                  values=[
                      <Die size=6 values=[<Literal 4>]>,
                      <Die size=6 values=[<Literal 6>]>,
                      <Die size=6 values=[<Literal 6>]>
                  ]
                  operations=[]
              >
              op=+
              right=<Dice
                  num=1
                  size=4
                  values=[
                      <Die size=4 values=[<Literal 1>]>
                  ]
                  operations=[]
              >
          >
          op=+
          right=<Literal 3>
      >
      comment=None
  >
  ```
  From here, `Expression.children` returns a tree of nodes representing the expression from left to right, each of which
  may have children of their own. This can be used to easily search for specific dice, look for the left-most operand,
  or modify the result by adding in resistances or other modifications.


  Finding the left and right-most operands:
  ```python
  >>> from d20 import roll

  >>> binop = roll("1 + 2 + 3 + 4")
  >>> left = binop.expr
  >>> while left.children:
  ...     left = left.children[0]
  >>> left
  <Literal 1>

  >>> right = binop.expr
  >>> while right.children:
  ...     right = right.children[-1]
  >>> right
  <Literal 4>

  >>> from d20 import utils  # these patterns are available in the utils submodule:
  >>> utils.leftmost(binop.expr)
  <Literal 1>
  >>> utils.rightmost(binop.expr)
  <Literal 4>
  ```


  Searching for the d4:
  ```python
  >>> from d20 import roll, Dice, SimpleStringifier, utils

  >>> mixed = roll("-1d8 + 4 - (3, 1d4)kh1")
  >>> str(mixed)
  '-1d8 (**8**) + 4 - (3, ~~1d4 (3)~~)kh1 = `-7`'
  >>> root = mixed.expr
  >>> result = utils.dfs(root, lambda node: isinstance(node, Dice) and node.num == 1 and node.size == 4)
  >>> result
  <Dice num=1 size=4 values=[<Die size=4 values=[<Literal 3>]>] operations=[]>
  >>> SimpleStringifier().stringify(result)
  '1d4 (3)'
  ```
  As a note, even though a `Dice` object is the parent of `Die` objects, `Dice.children` returns an empty list, since it's
  more common to look for the dice, and not each individual component of that dice.


  By default, the parser caches the 256 most frequently used dice expressions in an LFU cache, allowing for a significant
  speedup when rolling many of the same kinds of rolls. This caching is disabled when `allow_comments` is True.

  With caching:
  ```bash
  $ python3 -m timeit -s "from d20 import roll" "roll('1d20')"
  10000 loops, best of 5: 21.6 usec per loop
  $ python3 -m timeit -s "from d20 import roll" "roll('100d20')"
  500 loops, best of 5: 572 usec per loop
  $ python3 -m timeit -s "from d20 import roll; expr='1d20+'*50+'1d20'" "roll(expr)"
  500 loops, best of 5: 732 usec per loop
  $ python3 -m timeit -s "from d20 import roll" "roll('10d20rr<20')"
  1000 loops, best of 5: 1.13 msec per loop
  ```

  Without caching:
  ```bash
  $ python3 -m timeit -s "from d20 import roll" "roll('1d20')"
  5000 loops, best of 5: 61.6 usec per loop
  $ python3 -m timeit -s "from d20 import roll" "roll('100d20')"
  500 loops, best of 5: 620 usec per loop
  $ python3 -m timeit -s "from d20 import roll; expr='1d20+'*50+'1d20'" "roll(expr)"
  500 loops, best of 5: 2.1 msec per loop
  $ python3 -m timeit -s "from d20 import roll" "roll('10d20rr<20')"
  1000 loops, best of 5: 1.26 msec per loop
  ```


pkgId: d4e093e5dd54345ebc6541e0f97e0ade78105092acbbecc0ef95e2c764a49f03
name: python-d20-orm
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A small ORM for multimodel DBs
url: https://github.com/d20services/arangodb_python_orm
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d20-orm-2.0.1-1.src.rpm
checksum_type: sha256
description:
  ORM for datafield based apps on Python and ArangoDB


  Added GraphClassFactory wich allows you to create your DB, collections and graphs with no effort.

  Added support for Metada DB prefix
  Auto-gen Element table if not present
  Search does not get rid of deleted items automatically, new parameter added


pkgId: 150b4cf445914c59471c22504f02de648979672c9baadcb4f50788c85ad00f91
name: python-d2b
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Organize data in the BIDS format
url: https://github.com/d2b-dev/d2b
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d2b-1.4.2-1.src.rpm
checksum_type: sha256
description:
  Organize data in the BIDS format.

  [![PyPI Version](https://img.shields.io/pypi/v/d2b.svg)](https://pypi.org/project/d2b/) [![codecov](https://codecov.io/gh/d2b-dev/d2b/branch/master/graph/badge.svg?token=B83CY7Z0NL)](https://codecov.io/gh/d2b-dev/d2b) [![Tests](https://github.com/d2b-dev/d2b/actions/workflows/test.yaml/badge.svg)](https://github.com/d2b-dev/d2b/actions/workflows/test.yaml) [![Code Style](https://github.com/d2b-dev/d2b/actions/workflows/lint.yaml/badge.svg)](https://github.com/d2b-dev/d2b/actions/workflows/lint.yaml) [![Type Check](https://github.com/d2b-dev/d2b/actions/workflows/type-check.yaml/badge.svg)](https://github.com/d2b-dev/d2b/actions/workflows/type-check.yaml)

  Compatible with `dcm2bids` config files.



  ```bash
  pip install d2b
  ```



  The singular CLI entrypoint:

  ```bash
  $ d2b --help
  usage: d2b [-h] [-v] {run,scaffold} ...

  d2b - Organize data in the BIDS format

  positional arguments:
    {run,scaffold}

  optional arguments:
    -h, --help      show this help message and exit
    -v, --version   show program's version number and exit
  ```

  Scaffold a BIDS dataset:

  ```bash
  $ d2b scaffold --help
  usage: d2b scaffold [-h] out_dir

  Scaffold a BIDS dataset directory structure

  positional arguments:
    out_dir     Output BIDS directory

  optional arguments:
    -h, --help  show this help message and exit
  ```

  Organize nifti data (sidecars required) into a BIDS-compliant structure:

  ```bash
  $ d2b run --help
  usage: d2b run [-h] -c CONFIG_FILE -p PARTICIPANT -o OUT_DIR [-s SESSION] [-l {DEBUG,INFO,WARNING,ERROR,CRITICAL}] in_dir [in_dir ...]

  Organize data in the BIDS format

  positional arguments:
    in_dir                Directory(ies) containing files to organize

  required arguments:
    -c CONFIG_FILE, --config CONFIG_FILE
                          JSON configuration file (see example/config.json)
    -p PARTICIPANT, --participant PARTICIPANT
                          Participant ID
    -o OUT_DIR, --out-dir OUT_DIR
                          Output BIDS directory

  optional arguments:
    -s SESSION, --session SESSION
                          Session ID
    -l {DEBUG,INFO,WARNING,ERROR,CRITICAL}, --log-level {DEBUG,INFO,WARNING,ERROR,CRITICAL}
                          Set logging level
  ```



  This package offers a pluggable BIDS-ification workflow which attempts to mirror parts of the [`dcm2bids`](https://github.com/UNFmontreal/Dcm2Bids) CLI.

  **One of the most important goals of this package is to support existing `dcm2bids` config files.**

  A notable difference between `d2b` and `dcm2bids` is that the default assumption made by `d2b` is that you're **_NOT_** giving it DICOM data as input (although, if this is your use-case, there's a plugin to enable going straight from DICOM -> BIDS).

  Out of the box, `d2b` assumes that you're working with NIfTI + NIfTI sidecar data.

  The general premise of the `dcm2bids` workflow is very nice: _describe the files your interested in (in config) and the software will take the descriptions, find matching files, and organize those files accordingly_.

  `d2b` (together with plugins powered by [`pluggy`](https://github.com/pytest-dev/pluggy)) tries to offer all functionality that `dcm2bids` offers, with an aim toward being _extensible_.

  We wanted `dcm2bids` to do things that it was [never intended to do](https://github.com/UNFmontreal/Dcm2Bids/issues/100#issuecomment-733033859), hence `d2b` was born.



  Similarities:

  - **Config files used with `dcm2bids` are compatible with `d2b`**
  - The `d2b run` command corresponds to `dcm2bids`
  - The `d2b scaffold` command corresponds to `dcm2bids_scaffold`

  Differences:

  - `d2b` has a plugin system so that users can extend the core functionality to fit the needs of their specific use-case.
  - The `d2b` code architecture is meant to make the BIDS dataset generation process less error prone.
  - Out of the box, `d2b` doesn't try to convert DICOM files and in fact `dcm2niix` doesn't even need to be installed. To do DICOM -> BIDS conversions install the [`d2b-dcm2niix`](https://github.com/d2b-dev/d2b-dcm2niix) plugin
  - Out of the box `defaceTpl` is no longer supported.

  <!-- ## Config File Schema -->



  To make writing `d2b` config files easier, we've included a [JSON schema](https://json-schema.org/) specification file ([schema.json](https://github.com/d2b-dev/d2b/blob/master/json-schemas/schema.json)). You can use this file in editors that support JSON Schema definitions to provide autocompletion:

  <!-- markdownlint-disable MD033 -->
  <div style="display: flex; align-items: center; justify-content: space-between;">
    <img src="https://raw.githubusercontent.com/d2b-dev/d2b/master/assets/autocomplete1.png" width="40%"/>
    <img src="https://raw.githubusercontent.com/d2b-dev/d2b/master/assets/autocomplete2.png" width="40%"/>
  </div>
  <!-- markdownlint-enable MD033 -->

  as well as validation while you edit your config files:

  <!-- markdownlint-disable MD033 -->
  <div style="display: flex; align-items: center; justify-content: space-between;">
    <img src="https://raw.githubusercontent.com/d2b-dev/d2b/master/assets/validation.png" width="40%"/>
  </div>
  <!-- markdownlint-enable MD033 -->

  For example, with vscode you might create/add to your `.vscode/settings.json` file in the workspace to include:

  ```text
  {
    // ... other settings ...

    "json.schemas": [
      {
        "fileMatch": ["*d2b-config*.json"],
        "url": "https://raw.githubusercontent.com/d2b-dev/d2b/master/json-schemas/schema.json"
      }
    ]
  }
  ```

  Having this setting enabled would mean that any file matching `*d2b-config*.json` would be validated against the latest JSON schema in the [`d2b` repo](https://github.com/d2b-dev/d2b/blob/master/json-schemas/schema.json)



  `d2b` uses [`pluggy`](https://github.com/pytest-dev/pluggy) to faciliate the discorvery and integration of plugins, as such familiarity with the [pluggy documentation](https://pluggy.readthedocs.io/en/latest/) is helpful.

  That said, here's a small example:

  Let's write a plugin that adds the command `d2b hello <name>` to `d2b`.

  The convention is to name the package implementing the plugin `d2b-[plugin-name]`, so we'll name our package `d2b-hello`.

  Let's add the plugin implementation

  `d2b-hello/d2b_hello.py`:

  ```python
  from __future__ import annotations

  import argparse

  from d2b.hookspecs import hookimpl


  @hookimpl
  def register_commands(subparsers: argparse._SubParsersAction):
      parser = subparsers.add_parser("hello")
      parser.add_argument("name", help="Greet this person")
      parser.add_argument("--shout", action="store_true", help="Shout it!")
      parser.set_defaults(handler=handler)


  def handler(args: argparse.Namespace):
      name: str = args.name
      shout: bool | None = args.shout
      greeting = f"Hello, {name}!"
      print(greeting.upper() if shout else greeting)
  ```

  The script above is tapping into one of the various pluggable locations (hookspecs in pluggy speak) by providing and implementation (hookimpl) of one of the desired hookspecs (`register_commands`) exposed by `d2b`.

  There are many spots in `d2b` which allow for a user to extend or change the core functionality. Check out the module [`hookspecs.py`](https://github.com/d2b-dev/d2b/blob/master/src/d2b/hookspecs.py) to see which hooks are available.

  In the case above `register_commands` is one of the hookspecs defined by `d2b` enabling for plugins to add subcommands to the `d2b` CLI.

  How do we tell `d2b` about our plugin?

  To discover the plugin `d2b` (via `pluggy`) uses [entrypoints](https://pluggy.readthedocs.io/en/latest/#loading-setuptools-entry-points). So we'll add a basic `setup.py` module:

  `d2b-hello/setup.py`:

  ```python
  from setuptools import find_packages
  from setuptools import setup

  setup(
      name="d2b-hello",
      install_requires="d2b>=0.2.3,<1.0",
      entry_points={"d2b": ["d2b-hello=d2b_hello"]},
      packages=find_packages(),
  )
  ```

  And now we can install our plugin:

  ```bash
  pip install -e ./d2b-hello/
  ```

  After which we have:

  ```bash
  $ d2b --help
  usage: d2b [-h] [-v] {run,scaffold,hello} ...

  d2b - Organize data in the BIDS format

  positional arguments:
    {run,scaffold,hello}

  optional arguments:
    -h, --help            show this help message and exit
    -v, --version         show program's version number and exit
  ```

  Our `d2b hello` subcommand is there!

  ```bash
  $ d2b hello --help
  usage: d2b hello [-h] [--shout] name

  positional arguments:
    name        Greet this person

  optional arguments:
    -h, --help  show this help message and exit
    --shout     Shout it!
  ```

  And, trying it out:

  ```bash
  $ d2b hello Andrew --shout
  HELLO, ANDREW!
  ```

  Success! 🏆



  1. Have or install a recent version of `poetry` (version >= 1.1)
  1. Fork the repo
  1. Setup a virtual environment (however you prefer)
  1. Run `poetry install`
  1. Run `pre-commit install`
  1. Add your changes (adding/updating tests is always nice too)
  1. Commit your changes + push to your fork
  1. Open a PR


pkgId: 18b4eab958a5230b39efb85a5242995a7bd56ed308f6becacd3f0e84ec6d92ae
name: python-d2spy
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Python package for interacting with a Data to Science instance.
url: https://pypi.org/project/d2spy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d2spy-0.1.14-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  <p align="center">
    <img
      src="https://py.d2s.org/assets/d2s-logo.png"
      alt="Data to Science logo"
      width="128"
    >
  </p>

  D2spy is a Python package for interacting with Data to Science instances.



  - Sign in to your Data to Science instance
  - Access your projects, flights, and data products
  - Create new projects and flights
  - Upload data products to flights



  - [Homepage](https://py.d2s.org/)
  - [Guides](https://py.d2s.org/guides)
  - [API Reference](https://py.d2s.org/api_client/)


pkgId: 3c65269e028a472658f387a1cd3140c84d5819c46dee382528383c0e026fb28f
name: python-d2to1
arch: src
version: 0.2.12.post1
epoch: 0
release: 1
url: https://github.com/embray/d2to1
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d2to1-0.2.12.post1-1.src.rpm
checksum_type: sha256
summary:
  Allows using distutils2-like setup.cfg files for a package's metadata with a distribute/setuptools setup.py

description:
  d2to1 (the 'd' is for 'distutils') allows using distutils2-like setup.cfg files
  for a package's metadata with a distribute/setuptools setup.py script.  It
  works by providing a distutils2-formatted setup.cfg file containing all of a
  package's metadata, and a very minimal setup.py which will slurp its arguments
  from the setup.cfg.
  Note: distutils2 has been merged into the CPython standard library, where it is
  now known as 'packaging'.  This project was started before that change was
  finalized.  So all references to distutils2 should also be assumed to refer to
  packaging.


pkgId: 4ed7a373fcf39b80eecf487259c9c56e252caef20386ea1cea38ffc749c03f78
name: python-d3-cli
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Utility scripts for ManySecured-D3 claims
url: https://github.com/TechWorksHub/ManySecured-D3DB
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d3-cli-0.2.5-1.src.rpm
checksum_type: sha256
description:
  Utility cli for ManySecured-D3 claims



  This api may be installed using pip like so:

  ```
  pip install d3-cli
  ```

  When developing these scripts, [Python Poetry](https://python-poetry.org/)
  is used to install and manage dependencies as well as publish to [PyPI](https://pypi.org/).

  Poetry will create a python isolated virtual environment in the `./.venv` folder and install dependencies if you run:

  ```bash
  poetry install
  ```

  You cannot run the cli or scripts directly from the `./src/d3-scripts` since we are using [Python relative imports](https://realpython.com/absolute-vs-relative-python-imports/#relative-imports).

  Instead, you must run the d3-cli script defined in the `[tool.poetry.scripts]` field of [`pyproject.toml`](./pyproject.toml): You can run the command line interface locally, directly from source code without building/installing by running `poetry run d3-cli`.




  ```console
  usage: d3-cli [-h] [--version] [--guid] [--output [OUTPUT]] [--mode [{build,lint,export,website}]] [--skip-mal]
                [--build-dir [BUILD_DIR]] [--check_uri_resolves] [--web-address [WEB_ADDRESS]] [--verbose | --quiet]
                [input ...]

  ManySecured D3 CLI for creating, linting and exporting D3 claims

  positional arguments:
    input                 folders containing D3 YAML files.

  optional arguments:
    -h, --help            show this help message and exit
    --version             show the version and exit.
    --guid, --uuid        generate and show guid and exit.
    --output [OUTPUT], -o [OUTPUT]
                          directory in which to output built claims.
    --mode [{build,lint,export,website}], -m [{build,lint,export,website}]
                          mode to run d3-cli in.
                          build creates a directory of D3 claims in json format, with the parent and child types resolved, and CVEvulnerabilities added.
                          lint lints the claims to check they confirm to the yaml syntax and schemas.
                          export creates a directory with the CSVs of the tables of types, behaviours andfirmwares.
                          website creates a directory containing the source for a static website of claims which can be browsed,with unique uris for each type.
    --skip-mal            skip malicious url lookup.
                                  This takes a bit of time, and requires an internet connection
                                  so you may wish to skip this step for local testing.
    --build-dir [BUILD_DIR]
                          build directory with json claims to export to build website with.
                                  Specifying this will skip build step in export mode and website mode.
    --check_uri_resolves  check that URIs/refs resolve.
                                  This can be very slow, so you may want to leave this off normally.
    --web-address [WEB_ADDRESS]
                          web address to use for website build
    --verbose, -v
    --quiet, -q

  Example: d3-cli ./manufacturers
  ```



  Tests can be run via:

  ```bash
  poetry run pytest
  ```



  The d3-cli utility is published [here](https://pypi.org/project/d3-cli/).

  In order to publish you must run:

  ```
  poetry build
  poetry publish
  ```

  And then enter the credentials for the NquiringMinds pypi account.



  This static page is generated from (post-processed) D3 statements and [hosted here](https://techworkshub.github.io/ManySecured-D3DB/). This site relies upon two Github actions in the [D3DB repository](https://github.com/TechWorksHub/ManySecured-D3DB)
  - Run D3 Build of website for github pages - processes all files, exporting html files
  - Publish website (main-branch only) deploys the pelecan site to Github pages

  In order for the pelican graphviz plugin which generates the digraph's in the webpage to work you need to have graphviz installed on your pc. For linux machines this can be done with `sudo apt install graphviz`, for windows graphviz installers may be downloaded [from here](https://graphviz.org/download/).




  To generate the site files inside a defined directory:
  ```
  cd d3-cli
  poetry install
  poetry run d3-cli --mode website "path-to-d3-yaml-files" --output "output-file"

  ```

  serving the static site:
  ```
  cd "output-file"/output
  python -m http.server 8000
  ```


pkgId: 42bc32ff2692d7a4b4d21a549042200734645594b270841fc1b28f2ceb16f606
name: python-d3blocks
arch: src
version: 1.4.11
epoch: 0
release: 1
summary: Python package d3blocks
url: https://github.com/d3blocks/d3blocks
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d3blocks-1.4.11-1.src.rpm
checksum_type: sha256
description:
  D3Blocks builds on the graphics of d3 javascript (d3js) to create the most visually attractive and useful charts with only a few lines of Python code!
  The [documentation pages](https://d3blocks.github.io/d3blocks/) contains detailed information about the working of the blocks with many examples.
  <p align="center">
    <a href="https://d3blocks.github.io/d3blocks/pages/html/index.html">
    <img src="https://github.com/d3blocks/d3blocks/blob/main/docs/figs/summary.png" width="600" />
    </a>


pkgId: 645958d8d082eb0dfb657c7402e6ef17f24a518eb959c58ce03f97b8391901d6
name: python-d3d4.pyavg
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Average value calculation
url: https://github.com/ehles/ehles.pyavg
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d3d4.pyavg-0.1.0-1.src.rpm
checksum_type: sha256
description:
  You can install the library via PyPI:
  ```bash
  pip install ehles.pyavg
  ```

  The library offers classes for different average calculation methods, including:
  1. Basic Moving Average (bi_avg.Stat)
  2. Cumulative Average (cumulative.Stat)
  3. Exponential Smoothing (exp_smooth.Stat)
  4. PID Controller-Based Average (pid.Stat)
  5. Ring Buffer for Averaging (ring_buff.Stat)
  6. Advanced Smoothing Algorithms (smooth.Stat)
  Each class implements a common interface, making it easy to switch between methods as needed.


  ```python
  from pyavg import BiAvgStat

  stat = BiAvgStat(window_size=5)

  stat.add(10)
  stat.add(20)
  stat.add(30)

  print(stat.get_average())  # -> 20.0
  ```

  ```python
  from pyavg import CumulativeStat

  stat = CumulativeStat()

  stat.add(10)
  stat.add(20)
  stat.add(30)

  print(stat.get_average())  # -> 20.0
  ```

  ```python
  from pyavg import ExpSmoothStat

  stat = ExpSmoothStat(alpha=0.5)

  stat.add(10)
  stat.add(20)
  stat.add(30)

  print(stat.get_average())  # -> smoothed value
  ```

  Each class provides the following key methods:
  - `add(value: float):` adds a new value to the calculation.
  - `get_average() -> float:` returns the current average.
  For details on implementation and additional parameters, refer to the source code or library documentation.

  - Python 3.6 or higher.

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

  If you’d like to contribute or add a new average calculation method, feel free to submit a Pull Request or reach out through [GitHub Issues](https://github.com/ehles/ehles.pyAvg/issues).


pkgId: 23f7081e2e5017f16a7e45ea76816407b7c7b1223a7e4bdd891b78fce95d0c3d
name: python-d3dshot
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Extremely Fast and Robust Screen Capture on Windows with the Desktop Duplication API
url: https://github.com/SerpentAI/D3DShot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d3dshot-0.1.5-1.src.rpm
checksum_type: sha256
description:
  _D3DShot_ is a pure Python implementation of the [Windows Desktop Duplication API](https://docs.microsoft.com/en-us/windows/desktop/direct3ddxgi/desktop-dup-api). It leverages DXGI and Direct3D system libraries to enable extremely fast and robust screen capture functionality for your Python scripts and applications on Windows.

  **D3DShot:**

  * Is by far the fastest way to capture the screen with Python on Windows 8.1+
  * Is very easy to use. If you can remember 10-ish methods, you know the entire thing.
  * Covers all common scenarios and use cases:
  	* Screenshot to memory
  	* Screenshot to disk
  	* Screenshot to memory buffer every X seconds (threaded; non-blocking)
  	* Screenshot to disk every X seconds (threaded; non-blocking)
  	* High-speed capture to memory buffer (threaded; non-blocking)
  * Captures to PIL Images out of the box. Gracefully adds output options if NumPy or PyTorch can be found.
  * Detects displays in just about any configuration: Single monitor, multiple monitors on one adapter, multiple monitors on multiple adapters.
  * Handles display rotation and scaling for you
  * Supports capturing specific regions of the screen
  * Is robust and very stable. You can run it for hours / days without performance degradation
  * Is even able to capture DirectX 11 / 12 exclusive fullscreen applications and games!




  **Screenshot to Memory**

  ```python
  import d3dshot

  d = d3dshot.create()
  d.screenshot()
  ```
  ```
  Out[1]: <PIL.Image.Image image mode=RGB size=2560x1440 at 0x1AA7ECB5C88>
  ```

  **Screenshot to Disk**
  ```python
  import d3dshot

  d = d3dshot.create()
  d.screenshot_to_disk()
  ```
  ```
  Out[1]: './1554298682.5632973.png'
  ```

  **Screen Capture for 5 Seconds and Grab the Latest Frame**
  ```python
  import d3dshot
  import time

  d = d3dshot.create()

  d.capture()
  time.sleep(5)  # Capture is non-blocking so we wait explicitely
  d.stop()

  d.get_latest_frame()
  ```
  ```
  Out[1]: <PIL.Image.Image image mode=RGB size=2560x1440 at 0x1AA044BCF60>
  ```

  **Screen Capture the Second Monitor as NumPy Arrays for 3 Seconds and Grab the 4 Latest Frames as a Stack**
  ```python
  import d3dshot
  import time

  d = d3dshot.create(capture_output="numpy")

  d.display = d.displays[1]

  d.capture()
  time.sleep(3)  # Capture is non-blocking so we wait explicitely
  d.stop()

  frame_stack = d.get_frame_stack((0, 1, 2, 3), stack_dimension="last")
  frame_stack.shape
  ```
  ```
  Out[1]: (1080, 1920, 3, 4)
  ```

  This is barely scratching the surface... Keep reading!




  * Windows 8.1+ (64-bit)
  * Python 3.6+ (64-bit)



  ```
  pip install d3dshot
  ```

  _D3DShot_ leverages DLLs that are already available on your system so the dependencies are very light. Namely:

  * [_comtypes_](https://github.com/enthought/comtypes): Internal use. To preserve developer sanity while working with COM interfaces.
  * [_Pillow_](https://github.com/python-pillow/Pillow): Default Capture Output. Also used to save to disk as PNG and JPG.

  These dependencies will automatically be installed alongside _D3DShot_; No need to worry about them!



  Windows has a quirk when using Desktop Duplication on hybrid-GPU systems. Please see the [wiki article](https://github.com/SerpentAI/D3DShot/wiki/Installation-Note:-Laptops) before attempting to use _D3DShot_ on your system.





  The desired _Capture Output_ is defined when creating a _D3DShot_ instance. It defines the type of all captured images. By default, all captures will return PIL.Image objects. This is a good option if you mostly intend to take screenshots.

  ```python

  d = d3dshot.create()
  d = d3dshot.create(capture_output="pil")
  ```

  _D3DShot_ is however quite flexible! As your environment meets certain optional sets of requirements, more options become available.


  **If _NumPy_ is available**

  ```python

  d = d3dshot.create(capture_output="numpy")


  d = d3dshot.create(capture_output="numpy_float")
  ```

  **If _NumPy_ and _PyTorch_ are available**

  ```python

  d = d3dshot.create(capture_output="pytorch")


  d = d3dshot.create(capture_output="pytorch_float")
  ```

  **If _NumPy_ and _PyTorch_ are available + _CUDA_ is installed and _torch.cuda.is_available()_**

  ```python

  d = d3dshot.create(capture_output="pytorch_gpu")


  d = d3dshot.create(capture_output="pytorch_float_gpu")
  ```

  Trying to use a Capture Output for which your environment does not meet the requirements will result in an error.



  Windows only allows 1 instance of Desktop Duplication per process. To make sure we fall in line with that limitation to avoid issues, the _D3DShot_ class acts as a singleton. Any subsequent calls to `d3dshot.create()` will always return the existing instance.

  ```python
  d = d3dshot.create(capture_output="numpy")


  d2 = d3dshot.create(capture_output="pil")



  d2.capture_output.backend


  d == d2

  ```




  When you create a _D3DShot_ instance, a frame buffer is also initialized. It is meant as a thread-safe, first-in, first-out way to hold a certain quantity of captures and is implemented as a `collections.deque`.

  By default, the size of the frame buffer is set to 60. You can customize it when creating your _D3DShot_ object.

  ```python
  d = d3dshot.create(frame_buffer_size=100)
  ```

  Be mindful of RAM usage with larger values; You will be dealing with uncompressed images which use up to 100 MB each depending on the resolution.

  The frame buffer can be accessed directly with `d.frame_buffer` but the usage of the utility methods instead is recommended.

  The buffer is used by the following methods:

  * `d.capture()`
  * `d.screenshot_every()`

  It is always automatically cleared before starting one of these operations.



  When you create a _D3DShot_ instance, your available displays will automatically be detected along with all their relevant properties.

  ```python
  d.displays
  ```
  ```
  Out[1]:
  [<Display name=BenQ XL2730Z (DisplayPort) adapter=NVIDIA GeForce GTX 1080 Ti resolution=2560x1440 rotation=0 scale_factor=1.0 primary=True>,
   <Display name=BenQ XL2430T (HDMI) adapter=Intel(R) UHD Graphics 630 resolution=1920x1080 rotation=0 scale_factor=1.0 primary=False>]
  ```

  By default, your primary display will be selected. At all times you can verify which display is set to be used for capture.

  ```python
  d.display
  ```
  ```
  Out[1]: <Display name=BenQ XL2730Z (DisplayPort) adapter=NVIDIA GeForce GTX 1080 Ti resolution=2560x1440 rotation=0 scale_factor=1.0 primary=True>
  ```

  Selecting another display for capture is as simple as setting `d.display` to another value from `d.displays`
  ```python
  d.display = d.displays[1]
  d.display
  ```
  ```
  Out[1]: <Display name=BenQ XL2430T (HDMI) adapter=Intel(R) UHD Graphics 630 resolution=1080x1920 rotation=90 scale_factor=1.0 primary=False>
  ```

  Display rotation and scaling is detected and handled for you by _D3DShot_:

  * Captures on rotated displays will always be in the correct orientation (i.e. matching what you see on your physical displays)
  * Captures on scaled displays will always be in full, non-scaled resolution (e.g. 1280x720 at 200% scaling will yield 2560x1440 captures)



  All capture methods (screenshots included) accept an optional `region` kwarg. The expected value is a 4-length tuple of integers that is to be structured like this:

  ```
  (left, top, right, bottom)  # values represent pixels
  ```

  For example, if you want to only capture a 200px by 200px region offset by 100px from both the left and top, you would do:

  ```python
  d.screenshot(region=(100, 100, 300, 300))
  ```

  If you are capturing a scaled display, the region will be computed against the full, non-scaled resolution.

  If you go through the source code, you will notice that the region cropping happens after a full display capture. That might seem sub-optimal but testing has revealed that copying a region of the GPU _D3D11Texture2D_ to the destination CPU _D3D11Texture2D_ using _CopySubresourceRegion_ is only faster when the region is very small. In fact, it doesn't take long for larger regions to actually start becoming slower than the full display capture using this method. To make things worse, it adds a lot of complexity by having the surface pitch not match the buffer size and treating rotated displays differently. It was therefore decided that it made more sense to stick to _CopyResource_ in all cases and crop after the fact.



  **Create a D3DShot instance**

  ```python
  import d3dshot

  d = d3dshot.create()
  ```

  `create` accepts 2 optional kwargs:

  * `capture_output`: Which capture output to use. See the _Capture Outputs_ section under _Concepts_
  * `frame_buffer_size`: The maximum size the frame buffer can grow to. See the _Frame Buffer_ section under _Concepts_

  Do NOT import the _D3DShot_ class directly and attempt to initialize it yourself! The `create` helper function initializes and validates a bunch of things for you behind the scenes.

  Once you have a _D3DShot_ instance in scope, we can start doing stuff with it!

  **List the detected displays**

  ```python
  d.displays
  ```

  **Select a display for capture**

  Your primary display is selected by default but if you have a multi-monitor setup, you can select another entry in `d.displays`

  ```python
  d.display = d.displays[1]
  ```

  **Take a screenshot**

  ```python
  d.screenshot()
  ```

  `screenshot` accepts 1 optional kwarg:

  * `region`: A region tuple. See the _Regions_ section under _Concepts_

  _Returns_: A screenshot with a format that matches the capture output you selected when creating your _D3DShot_ object

  **Take a screenshot and save it to disk**

  ```python
  d.screenshot_to_disk()
  ```

  `screenshot_to_disk` accepts 3 optional kwargs:

  * `directory`: The path / directory where to write the file. If omitted, the working directory of the program will be used
  * `file_name`: The file name to use. Permitted extensions are: _.png_, _.jpg_. If omitted, the file name will be `<time.time()>.png`
  * `region`: A region tuple. See the _Regions_ section under _Concepts_

  _Returns_: A string representing the full path to the saved image file

  **Take a screenshot every X seconds**

  ```python
  d.screenshot_every(X)  # Where X is a number representing seconds
  ```

  This operation is threaded and non-blocking. It will keep running until `d.stop()` is called. Captures are pushed to the frame buffer.

  `screenshot_every` accepts 1 optional kwarg:

  * `region`: A region tuple. See the _Regions_ section under _Concepts_

  _Returns_: A boolean indicating whether or not the capture thread was started

  **Take a screenshot every X seconds and save it to disk**

  ```python
  d.screenshot_to_disk_every(X)  # Where X is a number representing seconds
  ```

  This operation is threaded and non-blocking. It will keep running until `d.stop()` is called.

  `screenshot_to_disk_every` accepts 2 optional kwargs:

  * `directory`: The path / directory where to write the file. If omitted, the working directory of the program will be used
  * `region`: A region tuple. See the _Regions_ section under _Concepts_

  _Returns_: A boolean indicating whether or not the capture thread was started

  **Start a high-speed screen capture**

  ```python
  d.capture()
  ```

  This operation is threaded and non-blocking. It will keep running until `d.stop()` is called. Captures are pushed to the frame buffer.

  `capture` accepts 2 optional kwargs:

  * `target_fps`: How many captures per second to aim for. The effective capture rate will go under if the system can't keep up but it will never go over this target. It is recommended to set this to a reasonable value for your use case in order not to waste system resources. Default is set to 60.
  * `region`: A region tuple. See the _Regions_ section under _Concepts_

  _Returns_: A boolean indicating whether or not the capture thread was started

  **Grab the latest frame from the buffer**

  ```python
  d.get_latest_frame()
  ```

  _Returns_: A frame with a format that matches the capture output you selected when creating your _D3DShot_ object

  **Grab a specific frame from the buffer**

  ```python
  d.get_frame(X)  # Where X is the index of the desired frame. Needs to be < len(d.frame_buffer)
  ```

  _Returns_: A frame with a format that matches the capture output you selected when creating your _D3DShot_ object

  **Grab specific frames from the buffer**

  ```python
  d.get_frames([X, Y, Z, ...])  # Where X, Y, Z are valid indices to desired frames
  ```

  _Returns_: A list of frames with a format that matches the capture output you selected when creating your _D3DShot_ object

  **Grab specific frames from the buffer as a stack**

  ```python
  d.get_frame_stack([X, Y, Z, ...], stack_dimension="first|last")  # Where X, Y, Z are valid indices to desired frames
  ```

  Only has an effect on NumPy and PyTorch capture outputs.

  `get_frame_stack` accepts 1 optional kwarg:

  * `stack_dimension`: One of _first_, _last_. Which axis / dimension to perform the stack on

  _Returns_: A single array stacked on the specified dimension with a format that matches the capture output you selected when creating your _D3DShot_ object. If the capture output is not stackable, returns a list of frames.

  **Dump the frame buffer to disk**

  The files will be named according to this convention: `<frame buffer index>.png`

  ```python
  d.frame_buffer_to_disk()
  ```

  `frame_buffer_to_disk` accepts 1 optional kwarg:

  * `directory`: The path / directory where to write the files. If omitted, the working directory of the program will be used

  _Returns_: None



  Measuring the exact performance of the Windows Desktop Duplication API proves to be a little complicated because it will only return new texture data if the contents of the screen has changed. This is optimal for performance but it makes it difficult to express in terms of frames per second, the measurement people tend to expect for benchmarks. Ultimately the solution ended up being to run a high FPS video game on the display to capture to make sure the screen contents is different at all times while benchmarking.

  As always, remember that benchmarks are inherently flawed and highly depend on your individual hardware configuration and other circumstances. Use the numbers below as a relative indication of what to expect from _D3DShot_, not as some sort of absolute truth.

  |                         | 2560x1440 on _NVIDIA GTX 1080 Ti_ | 1920x1080 on _Intel UHD Graphics 630_ | 1080x1920 (vertical) on _Intel UHD Graphics 630_ |
  |-------------------------|-----------------------------------|---------------------------------------|--------------------------------------------------|
  | **"pil"**               | 29.717 FPS                        | 47.75 FPS                             | 35.95 FPS                                        |
  | **"numpy"**             | **57.667 FPS**                    | **58.1 FPS**                          | **58.033 FPS**                                   |
  | **"numpy_float"**       | 18.783 FPS                        | 29.05 FPS                             | 27.517 FPS                                       |
  | **"pytorch"**           | **57.867 FPS**                    | **58.1 FPS**                          | 34.817 FPS                                       |
  | **"pytorch_float"**     | 18.767 FPS                        | 28.367 FPS                            | 27.017 FPS                                       |
  | **"pytorch_gpu"**       | 27.333 FPS                        | 35.767 FPS                            | 34.8 FPS                                         |
  | **"pytorch_float_gpu"** | 27.267 FPS                        | 37.383 FPS                            | 35.033 FPS                                       |

  The absolute fastest capture outputs appear to be _"numpy"_ and unrotated _"pytorch"_; all averaging around 58 FPS. In Python land, this is FAST!



  NumPy arrays have a ctypes interface that can give you their raw memory address (`X.ctypes.data`). If you have the memory address and size of another byte buffer, which is what we end up with by processing what returns from the Desktop Duplication API, you can use `ctypes.memmove` to copy that byte buffer directly to the NumPy structure, effectively bypassing as much Python as possible.

  In practice it ends up looking like this:
  ```python
  ctypes.memmove(np.empty((size,), dtype=np.uint8).ctypes.data, pointer, size)
  ```

  This low-level operation is extremely fast, leaving everything else that would normally compete with NumPy in the dust.



  Don't tell anyone but the reason it can compete with NumPy in the first place is only because... _it is_ generated from a NumPy array built from the method above! If you sniff around the code, you will indeed find `torch.from_numpy()` scattered around. This pretty much matches the speed of the "numpy" capture output 1:1, except when dealing with a rotated display. Display rotation is handled by `np.rot90()` calls which yields negative strides on that array. Negative strides are understood and perform well under NumPy but are still unsupported in PyTorch at the time of writing. To address this, an additional copy operation is needed to bring it back to a contiguous array which imposes a performance penalty.



  PIL has no ctypes interface like NumPy so a bytearray needs to be read into Python first and then fed to `PIL.Image.frombytes()`. This is still fast in Python terms, but it just cannot match the speed of the low-level NumPy method.

  It remains the default capture output because:

  1) PIL Image objects tend to be familiar to Python users
  2) It's a way lighter / simpler dependency for a library compared to NumPy or PyTorch



  The data of the Direct3D textures made accessible by the Desktop Duplication API is formatted as bytes. To represent this data as normalized floats instead, a type cast and element-wise division needs to be performed on the array holding those bytes. This imposes a major performance penalty. Interestingly, you can see this performance penalty mitigated on GPU PyTorch tensors since the element-wise division can be massively parallelized on the device.



  _Crafted with ❤ by Serpent.AI 🐍_
  [Twitter](https://twitter.com/Serpent_AI) - [Twitch](https://www.twitch.tv/serpent_ai)


pkgId: b1f96c7538a61900df074a1d6793b2bbb79fd2318744eaec5a192d9f351b5c41
name: python-d3graph
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Python package to create interactive network based on d3js.
url: https://erdogant.github.io/d3graph
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d3graph-2.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Python](https://img.shields.io/pypi/pyversions/d3graph)](https://img.shields.io/pypi/pyversions/d3graph)
  [![Pypi](https://img.shields.io/pypi/v/d3graph)](https://pypi.org/project/d3graph/)
  [![Docs](https://img.shields.io/badge/Sphinx-Docs-Green)](https://erdogant.github.io/d3graph/)
  [![LOC](https://sloc.xyz/github/erdogant/d3graph/?category=code)](https://github.com/erdogant/d3graph/)
  [![Downloads](https://static.pepy.tech/personalized-badge/d3graph?period=month&units=international_system&left_color=grey&right_color=brightgreen&left_text=PyPI%20downloads/month)](https://pepy.tech/project/d3graph)
  [![Downloads](https://static.pepy.tech/personalized-badge/d3graph?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/d3graph)
  [![License](https://img.shields.io/badge/license-BSD3-green.svg)](https://github.com/erdogant/d3graph/blob/master/LICENSE)
  [![Forks](https://img.shields.io/github/forks/erdogant/d3graph.svg)](https://github.com/erdogant/d3graph/network)
  [![Issues](https://img.shields.io/github/issues/erdogant/d3graph.svg)](https://github.com/erdogant/d3graph/issues)
  [![Project Status](http://www.repostatus.org/badges/latest/active.svg)](http://www.repostatus.org/#active)
  [![DOI](https://zenodo.org/badge/228166657.svg)](https://zenodo.org/badge/latestdoi/228166657)
  [![Medium](https://img.shields.io/badge/Medium-Blog-black)](https://towardsdatascience.com/creating-beautiful-stand-alone-interactive-d3-charts-with-python-804117cb95a7)
  [![Donate](https://img.shields.io/badge/Support%20this%20project-grey.svg?logo=github%20sponsors)](https://erdogant.github.io/d3graph/pages/html/Documentation.html#)
  <!---[![BuyMeCoffee](https://img.shields.io/badge/buymea-coffee-yellow.svg)](https://www.buymeacoffee.com/erdogant)-->
  <!---[![Coffee](https://img.shields.io/badge/coffee-black-grey.svg)](https://erdogant.github.io/donate/?currency=USD&amount=5)-->


  ``d3graph`` is a python package that simplifies the task of creating **interactive** and **stand-alone** networks in **d3 javascript** using **python**.
  For this package I was inspired by d3 javascript examples but there was no python package that could create such interactive networks. Here it is; a library that automatically creates D3 javascript and HTML code based on an input adjacency matrix in python! This library does not require you any additional installation, downloads or setting paths to your systems environments. You just need python and this library. All other is taken care off. Huray!

  This library will create an interactive and stand-alone network that is build on d3 javascript. ``d3graph`` only requirs an adjacency matrix in the form of an pandas dataframe. Each column and index name represents a node whereas values >0 in the matrix represents an edge. Node links are build from rows to columns. Building the edges from row to columns only matters in directed cases. The network nodes and edges can be adjusted in weight, color etc, based on user defined paramters.




  **⭐️ Star this repo if you like it ⭐️**




  Read the blog [Creating beautiful stand-alone interactive D3 charts with Python](https://erdogant.github.io/d3graph/pages/html/Documentation.html#medium-blog) to get a structured overview and usage of ``d3graph``.







  On the [documentation pages](https://erdogant.github.io/d3graph/) you can find detailed information about the working of the ``d3graph`` with many examples.







  ```bash
  pip install d3graph
  ```



  ```python
  from d3graph import d3graph
  ```





  Click on the following image to load the interactive **Titanic** network that is created with ``d3graph``. Note that the relations are determined using [HNet. Click here to go to the page with code to make the network.](https://erdogant.github.io/hnet/pages/html/Use%20Cases.html#titanic-dataset)

  <p align="left">
    <a href="https://erdogant.github.io/docs/d3graph/titanic_example/index.html">
       <img src="https://github.com/erdogant/d3graph/blob/master/docs/titanic_example/d3graph.png" width="600"/>
    </a>
  </p>




  <p align="left">
    <a href="https://erdogant.github.io/d3graph/pages/html/Core%20Functionalities.html#node-label">
       <img src="https://github.com/erdogant/d3graph/blob/master/docs/figs/d3graph_node_properties.png" width="900"/>
    </a>
  </p>










  <p align="left">
    <a href="https://erdogant.github.io/d3graph/pages/html/Examples.html">
      <img src="https://github.com/erdogant/d3graph/blob/master/docs/figs/d3graph example.png" width="600"/>
    </a>
  </p>

  <hr>


  * All kinds of contributions are welcome!


  Please cite d3graph in your publications if this is useful for your research. See column right for citation information.


  * Erdogan Taskesen, github: [erdogant](https://github.com/erdogant)
  * Contributions are welcome.
  * If you wish to buy me a <a href="https://erdogant.github.io/donate/?currency=USD&amount=5">Coffee</a> for this work, it is very appreciated :)


pkgId: de0e6f5404d34d7e9445792c5b34a2dc31ad6cbee28ce44e088820ff331ad7c7
name: python-d3m
arch: src
version: 2022.5.5
epoch: 0
release: 1
summary: project
url: https://gitlab.com/datadrivendiscovery/d3m
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d3m-2022.5.5-1.src.rpm
checksum_type: sha256
description:
  This package provides a core package for D3M project with common code available.
  It contains standard interfaces, reference implementations, and utility implementations.



  This package works with Python 3.6-3.8 and pip 19+.

  You can install latest stable version from [PyPI](https://pypi.org/):

  ```
  $ pip3 install d3m
  ```

  To install the latest development version:

  ```
  $ pip3 install -e git+https://gitlab.com/datadrivendiscovery/d3m.git@devel#egg=d3m
  ```

  When cloning the repository, clone it recursively to get also git submodules:

  ```
  $ git clone --recursive https://gitlab.com/datadrivendiscovery/d3m.git
  ```



  See [HISTORY.md](./HISTORY.md) for a summary of changes between versions of this package.



  The documentation for the package is available at [https://datadrivendiscovery.org/](https://datadrivendiscovery.org/).



  See [CODE_STYLE.md](./CODE_STYLE.md) for our coding style and contribution guide. Please ensure any merge requests you open follow this guide.



  `master` branch contains latest stable release of the package.
  `devel` branch is a staging branch for the next release.

  Releases are [tagged](https://gitlab.com/datadrivendiscovery/d3m/-/tags).



  DARPA's Data Driven Discovery of Models (D3M) Program is researching ways to get machines to build
  machine learning pipelines automatically. It is split into three layers:
  TA1 (primitives), TA2 (systems which combine primitives automatically into pipelines
  and executes them), and TA3 (end-users interfaces).


pkgId: 070a68287c6b4eecec38f4a9264fca00576a8eceae4a0f003ae4bfc83b6fb8ef
name: python-d3rlpy
arch: src
version: 2.7.0
epoch: 0
release: 1
summary: An offline deep reinforcement learning library
url: https://github.com/takuseno/d3rlpy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d3rlpy-2.7.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img align="center" width="300px" src="assets/logo.png"></p>



  ![test](https://github.com/takuseno/d3rlpy/workflows/test/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/d3rlpy/badge/?version=latest)](https://d3rlpy.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/takuseno/d3rlpy/branch/master/graph/badge.svg?token=AQ02USKN6Y)](https://codecov.io/gh/takuseno/d3rlpy)
  [![Maintainability](https://api.codeclimate.com/v1/badges/c9162eb736d0b0f612d8/maintainability)](https://codeclimate.com/github/takuseno/d3rlpy/maintainability)
  ![MIT](https://img.shields.io/badge/license-MIT-blue)

  d3rlpy is an offline deep reinforcement learning library for practitioners and researchers.

  ```py
  import d3rlpy

  dataset, env = d3rlpy.datasets.get_dataset("hopper-medium-v0")


  sac = d3rlpy.algos.SACConfig().create(device="cuda:0")


  sac.fit(dataset, n_steps=1000000)


  sac.fit_online(env, n_steps=1000000)


  actions = sac.predict(x)
  ```

  - Documentation: https://d3rlpy.readthedocs.io
  - Paper: https://arxiv.org/abs/2111.03788

  > [!IMPORTANT]
  > v2.x.x introduces breaking changes. If you still stick to v1.x.x, please explicitly install previous versions (e.g. `pip install d3rlpy==1.1.1`).




  - **offline RL**: d3rlpy supports state-of-the-art offline RL algorithms. Offline RL is extremely powerful when the online interaction is not feasible during training (e.g. robotics, medical).
  - **online RL**: d3rlpy also supports conventional state-of-the-art online training algorithms without any compromising, which means that you can solve any kinds of RL problems only with `d3rlpy`.


  - **zero-knowledge of DL library**: d3rlpy provides many state-of-the-art algorithms through intuitive APIs. You can become a RL engineer even without knowing how to use deep learning libraries.
  - **extensive documentation**: d3rlpy is fully documented and accompanied with tutorials and reproduction scripts of the original papers.


  - **distributional Q function**: d3rlpy is the first library that supports distributional Q functions in the all algorithms. The distributional Q function is known as the very powerful method to achieve the state-of-the-performance.
  - **data-prallel distributed training**: d3rlpy is the first library that supports data-parallel distributed offline RL training, which allows you to scale up offline RL with multiple GPUs or nodes. See [example](examples/distributed_offline_training.py).



  d3rlpy supports Linux, macOS and Windows.


  Installing d3rlpy package will install or upgrade the following packages to satisfy requirements:
  - torch>=2.5.0
  - tqdm>=4.66.3
  - gym>=0.26.0
  - gymnasium>=1.0.0
  - click
  - colorama
  - dataclasses-json
  - h5py
  - structlog
  - typing-extensions


  [![PyPI version](https://badge.fury.io/py/d3rlpy.svg)](https://badge.fury.io/py/d3rlpy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/d3rlpy)
  ```
  $ pip install d3rlpy
  ```

  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/d3rlpy/badges/version.svg)](https://anaconda.org/conda-forge/d3rlpy)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/d3rlpy/badges/downloads.svg)](https://anaconda.org/conda-forge/d3rlpy)
  ```
  $ conda install conda-forge/noarch::d3rlpy
  ```


  ![Docker Pulls](https://img.shields.io/docker/pulls/takuseno/d3rlpy)
  ```
  $ docker run -it --gpus all --name d3rlpy takuseno/d3rlpy:latest bash
  ```


  | algorithm | discrete control | continuous control |
  |:-|:-:|:-:|
  | Behavior Cloning (supervised learning) | :white_check_mark: | :white_check_mark: |
  | [Neural Fitted Q Iteration (NFQ)](https://link.springer.com/chapter/10.1007/11564096_32) | :white_check_mark: | :no_entry: |
  | [Deep Q-Network (DQN)](https://www.nature.com/articles/nature14236) | :white_check_mark: | :no_entry: |
  | [Double DQN](https://arxiv.org/abs/1509.06461) | :white_check_mark: | :no_entry: |
  | [Deep Deterministic Policy Gradients (DDPG)](https://arxiv.org/abs/1509.02971) | :no_entry: | :white_check_mark: |
  | [Twin Delayed Deep Deterministic Policy Gradients (TD3)](https://arxiv.org/abs/1802.09477) | :no_entry: | :white_check_mark: |
  | [Soft Actor-Critic (SAC)](https://arxiv.org/abs/1812.05905) | :white_check_mark: | :white_check_mark: |
  | [Batch Constrained Q-learning (BCQ)](https://arxiv.org/abs/1812.02900) | :white_check_mark: | :white_check_mark: |
  | [Bootstrapping Error Accumulation Reduction (BEAR)](https://arxiv.org/abs/1906.00949) | :no_entry: | :white_check_mark: |
  | [Conservative Q-Learning (CQL)](https://arxiv.org/abs/2006.04779) | :white_check_mark: | :white_check_mark: |
  | [Advantage Weighted Actor-Critic (AWAC)](https://arxiv.org/abs/2006.09359) | :no_entry: | :white_check_mark: |
  | [Critic Reguralized Regression (CRR)](https://arxiv.org/abs/2006.15134) | :no_entry: | :white_check_mark: |
  | [Policy in Latent Action Space (PLAS)](https://arxiv.org/abs/2011.07213) | :no_entry: | :white_check_mark: |
  | [TD3+BC](https://arxiv.org/abs/2106.06860) | :no_entry: | :white_check_mark: |
  | [Implicit Q-Learning (IQL)](https://arxiv.org/abs/2110.06169) | :no_entry: | :white_check_mark: |
  | [Calibrated Q-Learning (Cal-QL)](https://arxiv.org/abs/2303.05479) | :no_entry: | :white_check_mark: |
  | [ReBRAC](https://arxiv.org/abs/2305.09836) | :no_entry: | :white_check_mark: |
  | [Decision Transformer](https://arxiv.org/abs/2106.01345) | :white_check_mark: | :white_check_mark: |
  | [Gato](https://arxiv.org/abs/2205.06175) | :construction: | :construction: |


  - [x] standard Q function
  - [x] [Quantile Regression](https://arxiv.org/abs/1710.10044)
  - [x] [Implicit Quantile Network](https://arxiv.org/abs/1806.06923)


  d3rlpy is benchmarked to ensure the implementation quality.
  The benchmark scripts are available [reproductions](https://github.com/takuseno/d3rlpy/tree/master/reproductions) directory.
  The benchmark results are available [d3rlpy-benchmarks](https://github.com/takuseno/d3rlpy-benchmarks) repository.



  <p align="center"><img align="center" width="160px" src="assets/mujoco_hopper.gif"></p>

  ```py
  import d3rlpy


  dataset, env = d3rlpy.datasets.get_d4rl('hopper-medium-v0')


  cql = d3rlpy.algos.CQLConfig().create(device='cuda:0')


  cql.fit(
      dataset,
      n_steps=100000,
      evaluators={"environment": d3rlpy.metrics.EnvironmentEvaluator(env)},
  )
  ```

  See more datasets at [d4rl](https://github.com/rail-berkeley/d4rl).


  <p align="center"><img align="center" width="160px" src="assets/breakout.gif"></p>

  ```py
  import d3rlpy


  dataset, env = d3rlpy.datasets.get_atari_transitions(
      'breakout',
      fraction=0.01,
      num_stack=4,
  )


  cql = d3rlpy.algos.DiscreteCQLConfig(
      observation_scaler=d3rlpy.preprocessing.PixelObservationScaler(),
      reward_scaler=d3rlpy.preprocessing.ClipRewardScaler(-1.0, 1.0),
  ).create(device='cuda:0')


  cql.fit(
      dataset,
      n_steps=1000000,
      evaluators={"environment": d3rlpy.metrics.EnvironmentEvaluator(env, epsilon=0.001)},
  )
  ```

  See more Atari datasets at [d4rl-atari](https://github.com/takuseno/d4rl-atari).



  ```py
  import d3rlpy
  import gym


  env = gym.make('Hopper-v3')
  eval_env = gym.make('Hopper-v3')


  sac = d3rlpy.algos.SACConfig().create(device='cuda:0')


  buffer = d3rlpy.dataset.create_fifo_replay_buffer(limit=1000000, env=env)


  sac.fit_online(env, buffer, n_steps=1000000, eval_env=eval_env)
  ```


  Try cartpole examples on Google Colaboratory!

  - offline RL tutorial: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/takuseno/d3rlpy/blob/master/tutorials/cartpole.ipynb)
  - online RL tutorial: [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/takuseno/d3rlpy/blob/master/tutorials/online.ipynb)

  More tutorial documentations are available [here](https://d3rlpy.readthedocs.io/en/stable/tutorials/index.html).


  Any kind of contribution to d3rlpy would be highly appreciated!
  Please check the [contribution guide](CONTRIBUTING.md).


  | Channel | Link |
  |:-|:-|
  | Issues | [GitHub Issues](https://github.com/takuseno/d3rlpy/issues) |

  > [!IMPORTANT]
  > Please do NOT email to any contributors including the owner of this project to ask for technical support. Such emails will be ignored without replying to your message. Use GitHub Issues to report your problems.


  | Project | Description |
  |:-:|:-|
  | [MINERVA](https://github.com/takuseno/minerva) | An out-of-the-box GUI tool for offline RL |
  | [SCOPE-RL](https://github.com/hakuhodo-technologies/scope-rl) | An off-policy evaluation and selection library |


  The roadmap to the future release is available in [ROADMAP.md](ROADMAP.md).


  The paper is available [here](https://arxiv.org/abs/2111.03788).
  ```
  @article{d3rlpy,
    author  = {Takuma Seno and Michita Imai},
    title   = {d3rlpy: An Offline Deep Reinforcement Learning Library},
    journal = {Journal of Machine Learning Research},
    year    = {2022},
    volume  = {23},
    number  = {315},
    pages   = {1--20},
    url     = {http://jmlr.org/papers/v23/22-0017.html}
  }
  ```


  This work started as a part of [Takuma Seno](https://github.com/takuseno)'s Ph.D project at Keio University in 2020.

  This work is supported by Information-technology Promotion Agency, Japan
  (IPA), Exploratory IT Human Resources Project (MITOU Program) in the fiscal
  year 2020.


pkgId: c8d1520a5ffe91a6aa0c35893ef8130fae3383d4a4a06f5c874c9d911f8e1367
name: python-d4-pyclient
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: D4 core software client in Python
url: https://github.com/D4-project/d4-pyclient
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d4-pyclient-0.1.7-1.src.rpm
checksum_type: sha256
description:
  **d4-pyclient** is python implemention of the [D4 encapsulation
  protocol](https://github.com/D4-project/architecture/tree/master/format).

  It is a low-barrier entry for anyone interested into tinkering with the D4
  protocol or embedding a d4 client into another project. It supports both regular
  types and types defined by meta-header.


  ```bash
  pip install d4-pyclient
  ```



  ```shell
  ./d4_client.py -h
  usage: d4_client.py [-h] -c CONFIG [-cc]

  optional arguments:
    -h, --help            show this help message and exit
    -c CONFIG, --config CONFIG
                          config directory
    -cc, --check_certificate
                          check server certificate
  ```



   of the client configuration can be stored in folder containing the following files:

   - key: your Pre-Shared-Key
   - snaplen: default is 4096
   - source: stdin or d4server
   - destination: stdout, [fe80::ffff:ffff:ffff:a6fb]:4443, 127.0.0.1:4443
   - type: D4 packet type, see [types](https://github.com/D4-project/architecture/tree/master/format)
   - uuid: generated automatically if empty
   - version: protocol version
   - rootCA.crt: optional : CA certificate to check the server certificate
   - metaheader.json: optional : a json file describing feed's meta-type [types](https://github.com/D4-project/architecture/tree/master/format)


pkgId: 720c004a5fca37e151655a28060da3425dabfcf2fa5bc2645c37991c990fae31
name: python-d4kms
arch: src
version: 0.13
epoch: 0
release: 1
summary: A python package for building d4k microservcies
url: https://pypi.org/project/d4kms/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d4kms-0.13-1.src.rpm
checksum_type: sha256
description:
  This read me identifies a set of microservices that implement a range of functionality that allows for the handling of clinical trial data in an automated manner. The use cases addressed are

  1. Import of data held in a variety of data formats into study designs
  1. Export of data in a number of formats

  The microservices within the system are:

  1. Registration Authority
  1. Clinical Recording Model
  1. Controlled Terminology
  1. Biomedical Concepts
  1. SDTM
  1. Forms
  1. Study

  The services are all python services running on FastAPI and uvicorn. They can be run locally using a single shared Neo4j instance or deployed. When deployed each micorservices requires a separate Aura Neo4j instance.



  Use a single Neo4 instance will all databases for the microservices setup within one instance. Typical names for a devlepoment environment are

  - ra-service-dev
  - crm-service-dev
  - bc-service-dev
  - sdtm-service-dev
  - study-service-dev
  - form-service-dev

  Note: there are no separate data bases for Study Import service or the Study Data Import service





  | Microservice | Port |
  | ------------- | ------------- |
  | CT | 8000 |
  | BC | 8001 |
  | Study | 8002 |
  | Form | 8003 |
  | SDTM | 8004 |



  | Microservice | Port |
  | ------------- | ------------- |
  | RA | 8010 |
  | CRM | 8011 |
  | CT | 8012 |
  | BC | 8013 |
  | Study | 8014 |
  | Study Import | 8015 |
  | Form | 8016 |
  | SDTM | 8017 |
  | Study Data Import | 8018 |



  Use the ```microservice.command``` file to run. Note this file is mac specific. This will start all of the services and the UIs. There is also a dev_server.sh file in each git repo to run each element individually.





  To deploy each microservice the following actions should be followed.

  1. Create Aura Neo4j instance.
  1. Load the data using the data prep utility
  1. Deploy the microservice
  1. Check all running



  Use the Aura console to create the database as per the site instructions. Download the file holding the credentials (username and password) for the instance





  From the appropriate data prep project

  1. Setup the virtual environment
  1. Set the environment variables for the credentials of the neo4j instance
  1. Set production
  1. Run the load python file



  Run ```. ./setup_env.sh```



  Modify the .production_env file. The file will need to contain the following lines

  ```
  NEO4J_URI=<database uri>
  NEO4J_DB_NAME=neo4j
  NEO4J_USERNAME=<username>
  NEO4J_PASSWORD=<password>
  GITHUB=<URL of the github repo main page>
  ```

  The database URI will look something like ```neo4j+s://a1bc23d4.databases.neo4j.io```
  The githb repo URL will look something like ```https://raw.githubusercontent.com/data4knowledge/ra_prep/main/```



  We need to tell the load utility to use the production database rather than the local (development) one. This is done via setting the ```PYTHON_ENVIRONMENT```environment variable. To so this run ```. ./set_production.sh```



  There will be a python rpogram to load the data. It will be named ```stage_<n>_load.py```. Run this program by entering ```python stage_2_load.py```, here n is 2.

  The output from the program should look somethig like

  ```
  Deleting database ...
  Database deleted. Load new data ...
  https://raw.githubusercontent.com/data4knowledge/ra_prep/main/load_data/node-namespace-1.csv
  https://raw.githubusercontent.com/data4knowledge/ra_prep/main/load_data/relationship-manages-1.csv
  https://raw.githubusercontent.com/data4knowledge/ra_prep/main/load_data/node-registration_authority-1.csv
  <Record file='progress.csv' source='file' format='csv' nodes=9 relationships=7 properties=58 time=4294 rows=0 batchSize=-1 batches=0 done=True data=None>
  Load complete. 9 nodes and 7 relationships loaded in 4294 milliseconds.
  ```



  The microservices are deployed using the fly.io cloud service.

  1. General python instructions are available here https://fly.io/docs/languages-and-frameworks/python/
  1. Installing the fly command line tool is detailed here https://fly.io/docs/hands-on/install-flyctl/
  1. deploy the app
  1. Set environment variables



  Setting environment variables on the server is achieved by using th ecommand line program, either one at a time

  ```fly secrets set SUPER_SECRET_KEY=password1234```

  or multiple values, note space delimited

  ```fly secrets set NEO4J_URI=xxx NEO4J_PASSWORD=yyy```





  ```
  AUTH0_SESSION_SECRET=<session secret key>
  AUTH0_DOMAIN=<from the Auth0 configuation>
  AUTH0_CLIENT_ID=<from the Auth0 configuation>
  AUTH0_CLIENT_SECRET=<from the Auth0 configuation>
  AUTH0_AUDIENCE=<from the Auth0 configuation>
  AUTH0_MNGT_CLIENT_ID=<Management API client ID>
  AUTH0_MNGT_CLIENT_SECRET=<Management API client secret>
  ROOT_URL=<base URL for the app>
  ```

  For the session secret run ```cat /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | fold -w 50 | head -n 1```to generate a 50 character randon string

  For the root URL use ```http:\\localhost:8000```or similar for a locally running app or ```https:\\xxx.fly.dev```for a deployed app



  Use this initialisation code

  ```
  authorisation = Auth0Service(app)
  authorisation.register()
  ```

  Need a local method to protect an endpoint

  ```
  def protect_endpoint(request: Request) -> None:
    authorisation.protect_route(request, "/login")
  ```

  and then protect an endpoint by using

  ```
  @app.get("/index", dependencies=[Depends(protect_endpoint)])
  def index(request: Request):
    ...code...
  ```



  To be defined.





  Use pip to install build and twine. Use the following commands to build

  ```python -m build```

  and upload to pypi.org using the command

  ```twine upload dist/*```

  Upload requires a token.



  Generate an API token on pypi.org. Then, to use the API token:

  ```
  Set your username to __token__
  Set your password to the token value, including the pypi- prefix
  ```


pkgId: f5a1c24d11e492806bb0157481a0d1f95028cac3ae008d1f9e2cafc296a04a4e
name: python-d64
arch: src
version: 1.10
epoch: 0
release: 1
summary: Read and write Commodore disk images
url: https://eden.mose.org.uk/gitweb/?p=python-d64.git
rpm_license: GNU General Public License v2 (GPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d64-1.10-1.src.rpm
checksum_type: sha256
description:
  This Python module enables access to disk image files (.d64, .d71, .d80, .d81, .d82) used by various Commodore microcomputer emulators and tools.

  It provides familiar interfaces for developers to read and write program and data files within an image.

  In addition it contains tools useful to inspect and modify images, for example a script to check the integrity of an image.




  Classes and functions reside in the `d64` module, the whole module may be imported or just those definitions referenced by the user.



  To perform a directory list

  ```python
  from d64 import DiskImage

  with DiskImage('squadron.d64') as image:
      for line in image.directory():
          print(line)
  ```

  This prints out

  ```
  0 "SQUADRON        " Q9 2A
  15   "SQUADRON PAL"     PRG
  15   "SQUADRON NTSC"    PRG
  634 BLOCKS FREE.
  ```



  To extract, for example, a BASIC program and write it to a file

  ```python
  from d64 import DiskImage

  with DiskImage('test.d64') as image:
      with image.path(b'METEOR').open() as in_f:
          with open('meteor.prg', 'wb') as out_f:
  	    out_f.write(in_f.read())
  ```




  - detailed documentation
  - better docstrings
  - more examples


pkgId: d5421c728a51d378fc745d4c4525343cfdefbc829506c7fe632f3dc207eaab1d
name: python-d6tcollect
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: d6tcollect: collects anonymous usage statistics for python libraries
url: https://github.com/d6t/d6tcollect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d6tcollect-1.0.6-1.src.rpm
checksum_type: sha256
description:
  Much like websites, this library collects anonymous usage statistics.It ONLY collects import and function call events. It does NOT collect any of your data.Example: `{'profile': 'prod', 'package': 'd6tmodule', 'module': 'd6tmodule.utils', 'classModule': 'd6tmodule.utils.MyClass', 'class': 'MyClass', 'function': 'MyClass0.myfunction_1', 'functionModule': 'd6tmodule.utils.MyClass.myfunction_1', 'event': 'call', 'params': {'args': 1, 'kwargs': 'another'}}`For privacy notice see https://www.databolt.tech/index-terms.html#privacy


pkgId: f35e87a611dd0555181964dbe0d8c52b1496e2389e5a57ec9a13c7b5c1356ff0
name: python-d6tflow
arch: src
version: 0.2.8
epoch: 0
release: 1
url: https://github.com/d6t/d6tflow
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d6tflow-0.2.8-1.src.rpm
checksum_type: sha256
summary:
  For data scientists and data engineers, d6tflow is a python library which makes building complex data science workflows easy, fast and intuitive.

description:
  d6tflow is a python library which makes it easier to build data workflowsSee https://github.com/d6t/d6tflow for details


pkgId: 187fdefea3503f1bf9abe59e4f602a4213a80355c50efc33df370bc36f3baa95
name: python-d6tstack
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: d6tstack: Quickly ingest CSV and XLS files. Export to pandas, SQL, parquet
url: https://github.com/d6t/d6tstack
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d6tstack-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Quickly ingest raw files. Works for XLS, CSV, TXT which can be exported to CSV, Parquet, SQL and Pandas. d6tstack solves many performance and schema problems typically encountered when ingesting raw files.


pkgId: 62a4e16caf763ff86a6419de186fbb15e82cb50dcb98eb24b98857e45087b55d
name: python-d8analysis
arch: src
version: 0.2.20
epoch: 0
release: 1
summary: Exploratory Data Analysis Framework
url: https://john-james-ai.github.io/d8analysis
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d8analysis-0.2.20-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: [https://john-james-ai.github.io/d8analysis](https://john-james-ai.github.io/d8analysis)
  **Source Code**: [https://github.com/john-james-ai/d8analysis](https://github.com/john-james-ai/d8analysis)


pkgId: fff31949d749a258dfcc11978ed2eab698c5826637f7e0766dd5582e026b3819
name: python-d8s-dicts
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Democritus functions for working with Python dictionaries.
url: https://github.com/democritus-project/d8s-dicts
rpm_license: GNU Lesser General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d8s-dicts-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/d8s-dicts.svg)](https://pypi.python.org/pypi/d8s-dicts)
  [![CI](https://github.com/democritus-project/d8s-dicts/workflows/CI/badge.svg)](https://github.com/democritus-project/d8s-dicts/actions)
  [![Lint](https://github.com/democritus-project/d8s-dicts/workflows/Lint/badge.svg)](https://github.com/democritus-project/d8s-dicts/actions)
  [![codecov](https://codecov.io/gh/democritus-project/d8s-dicts/branch/main/graph/badge.svg?token=V0WOIXRGMM)](https://codecov.io/gh/democritus-project/d8s-dicts)
  [![The Democritus Project uses semver version 2.0.0](https://img.shields.io/badge/-semver%20v2.0.0-22bfda)](https://semver.org/spec/v2.0.0.html)
  [![The Democritus Project uses black to format code](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://choosealicense.com/licenses/lgpl-3.0/)

  Democritus functions<sup>[1]</sup> for working with Python dictionaries.

  [1] Democritus functions are <i>simple, effective, modular, well-tested, and well-documented</i> Python functions.

  We use `d8s` (pronounced "dee-eights") as an abbreviation for `democritus` (you can read more about this [here](https://github.com/democritus-project/roadmap#what-is-d8s)).



  ```
  pip install d8s-dicts
  ```



  You import the library like:

  ```python
  from d8s_dicts import *
  ```

  Once imported, you can use any of the functions listed below.



    - ```python
      def dict_filter_by_values(dictionary: dict, filter_function: Callable) -> dict:
          """."""
      ```
    - ```python
      def dict_filter_by_keys(dictionary: dict, filter_function: Callable) -> dict:
          """."""
      ```
    - ```python
      def is_dict(possible_dict: Any) -> bool:
          """Return whether or not the possible_dict is a dictionary."""
      ```
    - ```python
      def dict_keys(dictionary: dict) -> List[Any]:
          """Get the dictionary's keys (as a list)."""
      ```
    - ```python
      def is_valid_dict_key(key: Any) -> bool:
          """Return whether or not a dictionary could have the given key."""
      ```
    - ```python
      def dict_values(dictionary: dict) -> List[Any]:
          """Get the dictionary's values (as a list)."""
      ```
    - ```python
      def dict_has_value(dictionary: dict, value) -> bool:
          """Return whether or not the dictionary has the given value (without evaluating the value)."""
      ```
    - ```python
      def dict_key_types(dictionary: dict) -> list:
          """Return a list with the type of each key in the dictionary."""
      ```
    - ```python
      def dict_value_types(dictionary: dict) -> dict:
          """Return a dictionary with the same keys and the type of each value in place of the actual value."""
      ```
    - ```python
      def dict_keys_with_value(dictionary: dict, value):
          """Find the key(s) in the dictionary which have the given value."""
      ```
    - ```python
      def dict_sort_by_keys(dictionary: dict, **kwargs) -> collections.OrderedDict:
          """Sort the dictionary based on the dictionary's keys."""
      ```
    - ```python
      def dict_sort_by_values(dictionary: dict, **kwargs) -> collections.OrderedDict:
          """Sort the dictionary based on the dictionary's values."""
      ```
    - ```python
      def dicts_sort_by_value_at_key(dictionaries: List[Dict[Any, Any]], key, **kwargs) -> List[Dict[Any, Any]]:
          """Sort the given dictionaries (we are assuming that we get a list of dictionaries) based on each dictionary's value at the given key."""
      ```
    - ```python
      def dict_flip(dictionary: dict, *, flatten_values: bool = False, flip_lists_and_sets: bool = False) -> dict:
          """Flip the dictionary's keys and values; all of the values become keys and keys become values."""
      ```
    - ```python
      def dict_delistify_values(dictionary: dict) -> dict:
          """For all values in the given dictionary that are lists whose lengths are one, replace the list of length one with the value in the list."""
      ```
    - ```python
      def dict_examples(n: int = 10, **kwargs) -> List[Dict[Any, Any]]:
          """Create n dictionary examples."""
      ```
    - ```python
      def dict_add(dictionary: Dict[Any, List[Any]], key: Any, value: Any) -> Dict[Any, List[Any]]:
          """Add the given value to the dictionary at the given key. This function expects that all values of the dictionary parameter are lists."""
      ```
    - ```python
      def dicts_diffs(dictionary_a: dict, dictionary_b: dict) -> list:
          """."""
      ```
    - ```python
      def dict_copy_value_at_key(dictionary: dict, key: Any, new_key: Any) -> dict:
          """Copy the value at the given key into the new key."""
      ```
    - ```python
      def dict_move_value_at_key(dictionary: dict, old_key: Any, new_key: Any) -> dict:
          """Move the given key and its values into the new key."""
      ```
    - ```python
      def dict_key_delete(dictionary: dict, key: Any) -> dict:
          """Delete the given key from the given dictionary."""
      ```
    - ```python
      def dict_delete_items(dictionary: dict, values_to_delete: List[Any] = None, keys_to_delete: List[Any] = None) -> dict:
          """Delete all items from the dictionary if the item's value is in values_to_delete or the item's key is in keys_to_delete."""
      ```
    - ```python
      def dict_delete_empty_values(dictionary: dict) -> dict:
          """Delete all key-values pairs from the dictionary if the value is an empty strings, empty list, zero, False or None."""
      ```
    - ```python
      def dict_keys_with_max_value(dictionary: dict) -> List[DictKeyType]:
          """."""
      ```
    - ```python
      def dict_keys_with_min_value(dictionary: dict) -> List[DictKeyType]:
          """."""
      ```
    - ```python
      def dict_value_with_max_key(dictionary: dict) -> Any:
          """."""
      ```
    - ```python
      def dict_value_with_min_key(dictionary: dict) -> Any:
          """."""
      ```



  👋 &nbsp;If you want to get involved in this project, we have some short, helpful guides below:

  - [contribute to this project 🥇][contributing]
  - [test it 🧪][local-dev]
  - [lint it 🧹][local-dev]
  - [explore it 🔭][local-dev]

  If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.



  This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and Floyd Hightower's [Python project template](https://github.com/fhightower-templates/python-project-template).

  [contributing]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#contributing-a-pr-
  [local-dev]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#local-development-


pkgId: 5af3a768e6a2c388b01c23778880d95b9b9d11e2bdf15f1912e754190b85b8c5
name: python-d8s-hypothesis
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Democritus functions to interact with Hypothesis.
url: https://github.com/democritus-project/d8s-hypothesis
rpm_license: GNU Lesser General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d8s-hypothesis-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/d8s-hypothesis.svg)](https://pypi.python.org/pypi/d8s-hypothesis)
  [![CI](https://github.com/democritus-project/d8s-hypothesis/workflows/CI/badge.svg)](https://github.com/democritus-project/d8s-hypothesis/actions)
  [![Lint](https://github.com/democritus-project/d8s-hypothesis/workflows/Lint/badge.svg)](https://github.com/democritus-project/d8s-hypothesis/actions)
  [![codecov](https://codecov.io/gh/democritus-project/d8s-hypothesis/branch/main/graph/badge.svg?token=V0WOIXRGMM)](https://codecov.io/gh/democritus-project/d8s-hypothesis)
  [![The Democritus Project uses semver version 2.0.0](https://img.shields.io/badge/-semver%20v2.0.0-22bfda)](https://semver.org/spec/v2.0.0.html)
  [![The Democritus Project uses black to format code](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://choosealicense.com/licenses/lgpl-3.0/)

  Democritus functions<sup>[1]</sup> for working with [Hypothesis](https://hypothesis.readthedocs.io/en/latest/).

  [1] Democritus functions are <i>simple, effective, modular, well-tested, and well-documented</i> Python functions.

  We use `d8s` (pronounced "dee-eights") as an abbreviation for `democritus` (you can read more about this [here](https://github.com/democritus-project/roadmap#what-is-d8s)).



  ```
  pip install d8s-hypothesis
  ```



  You import the library like:

  ```python
  from d8s_hypothesis import *
  ```

  Once imported, you can use any of the functions listed below.



    - ```python
      def hypothesis_get_strategy_results(strategy, *args, n: int = 10, **kwargs):
          """Return the given n of results from the given hypothesis strategy.

      For a list of hypothesis strategies, see: https://hypothesis.readthedocs.io/en/latest/data.html."""
      ```



  👋 &nbsp;If you want to get involved in this project, we have some short, helpful guides below:

  - [contribute to this project 🥇][contributing]
  - [test it 🧪][local-dev]
  - [lint it 🧹][local-dev]
  - [explore it 🔭][local-dev]

  If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.



  This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and Floyd Hightower's [Python project template](https://github.com/fhightower-templates/python-project-template).

  [contributing]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#contributing-a-pr-
  [local-dev]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#local-development-


pkgId: 890fa990af5de4118fc314a71cb98c1b341a3ad72cc844cc2326eacae7338ac4
name: python-d8s-lists
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Democritus functions for working with lists.
url: https://github.com/democritus-project/d8s-lists
rpm_license: GNU Lesser General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d8s-lists-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/d8s-lists.svg)](https://pypi.python.org/pypi/d8s-lists)
  [![CI](https://github.com/democritus-project/d8s-lists/workflows/CI/badge.svg)](https://github.com/democritus-project/d8s-lists/actions)
  [![Lint](https://github.com/democritus-project/d8s-lists/workflows/Lint/badge.svg)](https://github.com/democritus-project/d8s-lists/actions)
  [![codecov](https://codecov.io/gh/democritus-project/d8s-lists/branch/main/graph/badge.svg?token=V0WOIXRGMM)](https://codecov.io/gh/democritus-project/d8s-lists)
  [![The Democritus Project uses semver version 2.0.0](https://img.shields.io/badge/-semver%20v2.0.0-22bfda)](https://semver.org/spec/v2.0.0.html)
  [![The Democritus Project uses black to format code](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://choosealicense.com/licenses/lgpl-3.0/)

  Democritus functions<sup>[1]</sup> for working with lists.

  [1] Democritus functions are <i>simple, effective, modular, well-tested, and well-documented</i> Python functions.

  We use `d8s` (pronounced "dee-eights") as an abbreviation for `democritus` (you can read more about this [here](https://github.com/democritus-project/roadmap#what-is-d8s)).



  ```
  pip install d8s-lists
  ```



  You import the library like:

  ```python
  from d8s_lists import *
  ```

  Once imported, you can use any of the functions listed below.



    - ```python
      def iterable_sort_by_length(iterable: Iterable[Any], **kwargs) -> List[Any]:
          """."""
      ```
    - ```python
      def longest(iterable: Iterable[Any]) -> Any:
          """."""
      ```
    - ```python
      def shortest(iterable: Iterable[Any]) -> Any:
          """."""
      ```
    - ```python
      def flatten(iterable: Iterable[Any], level: int = None, **kwargs) -> Iterator[Any]:
          """Flatten all items in the iterable so that they are all items in the same list."""
      ```
    - ```python
      def has_index(iterable: Sized, index: int) -> bool:
          """."""
      ```
    - ```python
      def types(iterable: Iterable[Any]) -> Iterator[Type]:
          """Return a set containing the types of all items in the list_arg."""
      ```
    - ```python
      def iterable_item_of_types(iterable: Iterable[Any], item_types: Iterable[type]) -> bool:
          """Return True if the iterable has any item that is of the item_types. Otherwise, return False."""
      ```
    - ```python
      def iterable_all_items_of_types(iterable: Iterable[Any], item_types: Iterable[type]) -> bool:
          """Return True if all items in the iterable are of a type given in item_types. Otherwise, return False."""
      ```
    - ```python
      def iterable_has_all_items_of_type(iterable: Iterable[Any], type_arg: type) -> bool:
          """Return whether or not all iterable in iterable are of the type specified by the type_arg."""
      ```
    - ```python
      def deduplicate(iterable: Iterable[Any]) -> Iterator[Any]:
          """Deduplicate the iterable."""
      ```
    - ```python
      def cycle(iterable: Iterable[Any], length: Optional[int] = None) -> Iterator[Any]:
          """Cycle through the iterable as much as needed."""
      ```
    - ```python
      def truthy_items(iterable: Iterable[Any]) -> Iterator[Any]:
          """Return an iterable with only elements of the given iterable which evaluate to True.

      (see https://docs.python.org/3.9/library/stdtypes.html#truth-value-testing)"""
      ```
    - ```python
      def nontruthy_items(iterable: Iterable[Any]) -> Iterator[Any]:
          """Return an iterable with only elements of the given iterable which evaluate to False.

      (see https://docs.python.org/3.9/library/stdtypes.html#truth-value-testing)"""
      ```
    - ```python
      def iterable_has_single_item(iterable: Iterable[Any]) -> bool:
          """Return whether the iterable has a single item in it."""
      ```
    - ```python
      def iterables_are_same_length(a: Sized, b: Sized, *args: Sized, debug_failure: bool = False) -> bool:
          """Return whether or not the given iterables are the same lengths."""
      ```
    - ```python
      def iterables_have_same_items(a: Sequence, b: Sequence, *args: Sequence) -> bool:
          """Return whether iterables have identical items (considering both identity and count)."""
      ```
    - ```python
      def run_length_encoding(iterable: Iterable[Any]) -> Iterator[str]:
          """Perform run-length encoding on the given array.

      See https://en.wikipedia.org/wiki/Run-length_encoding for more details."""
      ```
    - ```python
      def iterable_count(iterable: Iterable[Any]) -> Dict[Any, int]:
          """Count each item in the iterable."""
      ```
    - ```python
      def iterable_item_index(iterable: Sequence, item: Any) -> int:
          """Find the given item in the iterable. Return -1 if the item is not found."""
      ```
    - ```python
      def iterable_item_indexes(iterable: Iterable[Any], item: Any) -> Iterator[int]:
          """Find the given item in the iterable. Return -1 if the item is not found."""
      ```
    - ```python
      def duplicates(iterable: Sequence) -> Iterator[Sequence]:
          """Find duplicates in the given iterable."""
      ```
    - ```python
      def iterable_has_mixed_types(iterable: Iterable[Any]) -> bool:
          """Return whether or not the iterable has items with two or more types."""
      ```
    - ```python
      def iterable_has_single_type(iterable: Iterable[Any]) -> bool:
          """Return whether or not the iterable has items of only one type."""
      ```
    - ```python
      def iterable_replace(iterable: Iterable[Any], old_value: Any, new_value: Any) -> Iterator[Any]:
          """Replace all instances of the old_value with the new_value in the given iterable."""
      ```



  👋 &nbsp;If you want to get involved in this project, we have some short, helpful guides below:

  - [contribute to this project 🥇][contributing]
  - [test it 🧪][local-dev]
  - [lint it 🧹][local-dev]
  - [explore it 🔭][local-dev]

  If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.



  This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and Floyd Hightower's [Python project template](https://github.com/fhightower-templates/python-project-template).

  [contributing]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#contributing-a-pr-
  [local-dev]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#local-development-


pkgId: a97330f7776d5e914e797c470fec0f681aac44a18dc04e9f5b682f8af90af844
name: python-d8s-math
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Democritus functions for working with math.
url: https://github.com/democritus-project/d8s-math
rpm_license: GNU Lesser General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d8s-math-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/d8s-math.svg)](https://pypi.python.org/pypi/d8s-math)
  [![CI](https://github.com/democritus-project/d8s-math/workflows/CI/badge.svg)](https://github.com/democritus-project/d8s-math/actions)
  [![Lint](https://github.com/democritus-project/d8s-math/workflows/Lint/badge.svg)](https://github.com/democritus-project/d8s-math/actions)
  [![codecov](https://codecov.io/gh/democritus-project/d8s-math/branch/main/graph/badge.svg?token=V0WOIXRGMM)](https://codecov.io/gh/democritus-project/d8s-math)
  [![The Democritus Project uses semver version 2.0.0](https://img.shields.io/badge/-semver%20v2.0.0-22bfda)](https://semver.org/spec/v2.0.0.html)
  [![The Democritus Project uses black to format code](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://choosealicense.com/licenses/lgpl-3.0/)

  Democritus functions<sup>[1]</sup> for working with math.

  [1] Democritus functions are <i>simple, effective, modular, well-tested, and well-documented</i> Python functions.

  We use `d8s` (pronounced "dee-eights") as an abbreviation for `democritus` (you can read more about this [here](https://github.com/democritus-project/roadmap#what-is-d8s)).



  ```
  pip install d8s-math
  ```



  You import the library like:

  ```python
  from d8s_math import *
  ```

  Once imported, you can use any of the functions listed below.



    - ```python
      def fibonacci_sequence(n: int) -> List[int]:
          """Return the first n digits of the fibonacci sequence."""
      ```
    - ```python
      def fibonacci(n: int) -> int:
          """Return the value of the Fibonacci sequence at index n."""
      ```
    - ```python
      def number_closest(a, b, target):
          """Return a or b, whichever is closest to the target."""
      ```
    - ```python
      def number_furthest(a, b, target):
          """Return a or b, whichever is furthest to the target."""
      ```
    - ```python
      def cartesian_product(a: Any, *args: Any, repeat: int = 1):
          """."""
      ```
    - ```python
      def sympy_symbol(symbol_name: str):
          """."""
      ```
    - ```python
      def equation_solve(equation: str, symbols: List[str]):
          """."""
      ```
    - ```python
      def expression_explore(expression: str, symbol: str, start: int, end: int, step: int):
          """."""
      ```
    - ```python
      def one_cold_encode(items: list, *, reverse: bool = False) -> List[list]:
          """."""
      ```
    - ```python
      def one_hot_encode(items: list, *, reverse: bool = False) -> List[list]:
          """."""
      ```
    - ```python
      def is_integer_tuple(possible_integer_tuple: Any) -> bool:
          """."""
      ```
    - ```python
      def string_to_number(string: str) -> Union[int, float]:
          """Convert a number as a string into either an integer or float."""
      ```
    - ```python
      def first_arg_as_decimal(func):
          """Convert the first argument to a number (either integer or float)."""
      ```
    - ```python
      def arguments_as_decimals(func):
          """Convert all arguments to numbers (either integers or floats)."""
      ```
    - ```python
      def decimal_to_gray_code(num: Union[str, int, float]) -> integerTupleType:
          """Convert the given number to a gray code. This function was inspired by the code here: https://en.wikipedia.org/wiki/Gray_code#Converting_to_and_from_Gray_code."""
      ```
    - ```python
      def gray_code_to_decimal(num: integerTupleType) -> int:
          """Convert the given number to a gray code. This function was inspired by the code here: https://en.wikipedia.org/wiki/Gray_code#Converting_to_and_from_Gray_code."""
      ```
    - ```python
      def decimal_to_hex(decimal_number):
          """."""
      ```
    - ```python
      def hex_to_decimal(hex):
          """."""
      ```
    - ```python
      def roman_numeral_to_decimal(roman_numeral: str) -> int:
          """."""
      ```
    - ```python
      def decimal_to_roman_numeral(decimal_number) -> str:
          """."""
      ```
    - ```python
      def integer_tuple_to_decimal(integer_tuple: integerTupleType) -> int:
          """Return the decimal form of the given number (represented as an integer tuple)."""
      ```
    - ```python
      def integer_to_decimal(num: Union[str, int, float], base: int) -> int:
          """Convert the number of the given base to a decimal number."""
      ```
    - ```python
      def decimal_to_base(decimal_number: Union[str, int, float], base: int):
          """Convert the decimal_number to the given base."""
      ```
    - ```python
      def outer_division():
          """."""
      ```
    - ```python
      def outer_product(a: int, b: int, a_start: int = 1, b_start: int = 1):
          """Return a two-dimensional array with the results of range(a_start, a+1) multiplied by range(b_start, b+1)."""
      ```
    - ```python
      def multiplication_table(a: int, b: int, a_start: int = 1, b_start: int = 1):
          """."""
      ```
    - ```python
      def number_evenly_divides(a, b):
          """Return True if a evenly divides b. Otherwise, return False."""
      ```
    - ```python
      def number_evenly_divided_by(a, b):
          """Return True if a is evenly divided by b. Otherwise, return False."""
      ```
    - ```python
      def fraction_examples(n=10, *, fractions_as_strings: bool = True):
          """Create n fractions."""
      ```
    - ```python
      def iterable_differences(iterable):
          """Find all of the possible differences of all possible orders of the given iterable."""
      ```
    - ```python
      def combinations(iterable, length=None):
          """Return all possible combinations of the given length which can be created from the given iterable. If no length is given, we will find all combinations of all lengths for the given iterable."""
      ```
    - ```python
      def combinations_with_replacement(iterable, length=None):
          """Return all possible combinations of the given length which can be created from the given iterable. If no length is given, we will find all combinations of all lengths for the given iterable."""
      ```
    - ```python
      def prod(iterable):
          """Get the product of the iterable."""
      ```
    - ```python
      def permutations(iterable, length=None):
          """Return all possible permutations of the given iterable. If no length is given, we will find all permutations of all lengths for the given iterable"""
      ```
    - ```python
      def fraction_simplify(fraction_string):
          """Simplify the fraction represented as a string."""
      ```
    - ```python
      def remainder(dividend, divisor):
          """."""
      ```
    - ```python
      def floor(number):
          """."""
      ```
    - ```python
      def ceiling(number):
          """."""
      ```
    - ```python
      def factorial(number):
          """."""
      ```
    - ```python
      def fraction_complex_to_mixed_fraction(fraction_string):
          """Simplify the fraction represented as a string."""
      ```
    - ```python
      def fraction_mixed_to_complex_fraction(fraction_string):
          """Simplify the fraction represented as a string."""
      ```
    - ```python
      def dot_product(item_a, item_b):
          """Find the dot product for the two items. See https://en.wikipedia.org/wiki/Dot_product for more details."""
      ```
    - ```python
      def percent(ratio):
          """Return the ratio as a percentage."""
      ```
    - ```python
      def gcd(number1, number2):
          """Return the greatest common divisor."""
      ```
    - ```python
      def ratio(number1, number2):
          """Return the ratio of the two numbers in the form 1:2. For example, if given 5 and 10, this function would return "1:2". If given 2 and 20, this function would return "1:10"."""
      ```
    - ```python
      def transpose(matrix):
          """Transpose the given matrix. See https://en.wikipedia.org/wiki/Transpose."""
      ```
    - ```python
      def number_line(value, min_, max_, interval: int = 1):
          """."""
      ```
    - ```python
      def number_zero_pad(num: StrOrNumberType, length: StrOrNumberType) -> str:
          """."""
      ```
    - ```python
      def is_number(item):
          """Return whether or not the item is a number."""
      ```
    - ```python
      def number_is_even(number: StrOrNumberType):
          """."""
      ```
    - ```python
      def number_is_odd(number: StrOrNumberType):
          """."""
      ```
    - ```python
      def number_is_approx(number, approximate_value, *, relative_tolerance=1e-6):
          """."""
      ```
    - ```python
      def enumerate_range(range_string, range_split_string: str = '-'):
          """Enumerate the range specified by the string. For example, `1-3` returns `[1, 2, 3]`."""
      ```
    - ```python
      def hex_endiness_swap(hex_string):
          """Credit to: https://stackoverflow.com/questions/27506474/how-to-byte-swap-a-32-bit-integer-in-python."""
      ```
    - ```python
      def number_to_words(number):
          """Convert a number to its English representation (e.g. 100 => "One Hundred")."""
      ```
    - ```python
      def number_to_scientific_notation(number):
          """Convert the given number to scientific notation."""
      ```
    - ```python
      def number_to_engineering_notation(number):
          """Convert the given number to engineering notation."""
      ```



  👋 &nbsp;If you want to get involved in this project, we have some short, helpful guides below:

  - [contribute to this project 🥇][contributing]
  - [test it 🧪][local-dev]
  - [lint it 🧹][local-dev]
  - [explore it 🔭][local-dev]

  If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.



  This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and Floyd Hightower's [Python project template](https://github.com/fhightower-templates/python-project-template).

  [contributing]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#contributing-a-pr-
  [local-dev]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#local-development-


pkgId: 76881d7814b3a0dce39edc59f60e44447cd5793f9bca85e0fd3dc37b8b3de777
name: python-d8s-strings
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Democritus functions for working with Python strings.
url: https://github.com/democritus-project/d8s-strings
rpm_license: GNU Lesser General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d8s-strings-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/d8s-strings.svg)](https://pypi.python.org/pypi/d8s-strings)
  [![CI](https://github.com/democritus-project/d8s-strings/workflows/CI/badge.svg)](https://github.com/democritus-project/d8s-strings/actions)
  [![Lint](https://github.com/democritus-project/d8s-strings/workflows/Lint/badge.svg)](https://github.com/democritus-project/d8s-strings/actions)
  [![codecov](https://codecov.io/gh/democritus-project/d8s-strings/branch/main/graph/badge.svg?token=V0WOIXRGMM)](https://codecov.io/gh/democritus-project/d8s-strings)
  [![The Democritus Project uses semver version 2.0.0](https://img.shields.io/badge/-semver%20v2.0.0-22bfda)](https://semver.org/spec/v2.0.0.html)
  [![The Democritus Project uses black to format code](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://choosealicense.com/licenses/lgpl-3.0/)

  Democritus functions<sup>[1]</sup> for working with Python strings.

  [1] Democritus functions are <i>simple, effective, modular, well-tested, and well-documented</i> Python functions.

  We use `d8s` (pronounced "dee-eights") as an abbreviation for `democritus` (you can read more about this [here](https://github.com/democritus-project/roadmap#what-is-d8s)).



  ```
  pip install d8s-strings
  ```



  You import the library like:

  ```python
  from d8s_strings import *
  ```

  Once imported, you can use any of the functions listed below.



    - ```python
      def string_chars_at_start(string: str, chars: Iterable) -> Iterable[str]:
          """."""
      ```
    - ```python
      def string_chars_at_start_len(string: str, chars: Iterable) -> int:
          """."""
      ```
    - ```python
      def a10n(string: str) -> str:
          """."""
      ```
    - ```python
      def string_remove_index(string: str, index: int) -> str:
          """Remove the item from the string at the given index."""
      ```
    - ```python
      def string_replace_index(string: str, index: int, replacement: str) -> str:
          """Replace the character in the string at the given index with the replacement."""
      ```
    - ```python
      def string_remove_before(string: str, stop_string: str):
          """Remove everything from the start of the given string until the stop_string."""
      ```
    - ```python
      def string_remove_after(string: str, start_string: str):
          """Remove everything after the start_string to the end of the given string."""
      ```
    - ```python
      def string_is_palindrome(string: str) -> bool:
          """Return whether or not the given string is a palindrome."""
      ```
    - ```python
      def string_reverse(string: str) -> str:
          """Reverse the given string."""
      ```
    - ```python
      def indefinite_article(word):
          """Return the word with the appropriate indefinite article."""
      ```
    - ```python
      def is_plural(possible_plural: str) -> bool:
          """Return whether or not the possible_plural is plural."""
      ```
    - ```python
      def pluralize(word: str) -> str:
          """Make the word plural."""
      ```
    - ```python
      def is_singular(possible_singular: str) -> bool:
          """Return whether or not the possible_singular is singular."""
      ```
    - ```python
      def singularize(word: str) -> str:
          """Make the word singular."""
      ```
    - ```python
      def cardinalize(word: str, count: int) -> str:
          """Return the appropriate form of the given word for the count."""
      ```
    - ```python
      def ordinalize(number: int) -> str:
          """Return the appropriate form for the ordinal form of the given number."""
      ```
    - ```python
      def string_forms(text):
          """Return multiple forms for the given text."""
      ```
    - ```python
      def string_left_pad(string, length: int, *, padding_characters=' '):
          """Pad the given string with the given padding_characters such that the length of the resulting string is equal to the `length` argument. Adapted from the javascript code here: https://www.theregister.co.uk/2016/03/23/npm_left_pad_chaos/."""
      ```
    - ```python
      def string_to_bool(string: str) -> bool:
          """."""
      ```
    - ```python
      def text_examples(n=10):
          """Create n example texts."""
      ```
    - ```python
      def string_has_multiple_consecutive_spaces(string):
          """Return True if the given string has multiple, consecutive spaces."""
      ```
    - ```python
      def character_examples(n=10):
          """Create n example characters."""
      ```
    - ```python
      def text_abbreviate(text):
          """Abbreviate the given text."""
      ```
    - ```python
      def text_input_is_yes(message):
          """Get yes/no input from the user and return `True` if the input is yes and `False` if the input is no."""
      ```
    - ```python
      def text_input_is_no(message):
          """Get yes/no input from the user and return `True` if the input is no and `False` if the input is yes."""
      ```
    - ```python
      def string_is_yes(string):
          """Check if a string is some form of `y` or `yes`."""
      ```
    - ```python
      def string_is_no(string):
          """Check if a string is some form of `n` or `no`."""
      ```
    - ```python
      def xor(message, key):
          """."""
      ```
    - ```python
      def text_join(join_character, *args):
          """Join all of the arguments around the given join_character."""
      ```
    - ```python
      def string_insert(existing_string, new_string, index):
          """Insert the new_string into the existing_string at the given index."""
      ```
    - ```python
      def base64_encode(input_string):
          """Base64 encode the string."""
      ```
    - ```python
      def base64_decode(input_string):
          """Base64 decode the string."""
      ```
    - ```python
      def string_sequence_matcher(string_a, string_b):
          """Create a difflib.SequenceMatcher for the given string."""
      ```
    - ```python
      def strings_diff(string_a, string_b):
          """Return the diff of the two strings."""
      ```
    - ```python
      def string_add_to_start_of_each_line(string: str, string_to_add_to_each_line: str):
          """Add the given string_to_add_to_each_line to the beginning of each line in the string."""
      ```
    - ```python
      def string_get_closes_matches(word, possible_matches, maximum_matches=3, cutoff=0.6):
          """Return the words from the list of possible matches that are closest to the given word."""
      ```
    - ```python
      def strings_similarity(a: str, b: str):
          """Return the ratio of similarity between the two strings."""
      ```
    - ```python
      def strings_matching_blocks(a: str, b: str):
          """Return the matching blocks in the given strings."""
      ```
    - ```python
      def strings_longest_matching_block(a: str, b: str):
          """Return the longest matching block in the string."""
      ```
    - ```python
      def strings_diff_opcodes(a: str, b: str):
          """Return the opcodes representing the differences/similarities between two strings."""
      ```
    - ```python
      def string_common_prefix(a: str, b: str) -> str:
          """Returns the common prefix string from left to right between a and b."""
      ```
    - ```python
      def string_common_suffix(a: str, b: str):
          """Returns the common suffix string from left to right between a and b."""
      ```
    - ```python
      def characters(input_string):
          """Return all of the characters in the given string."""
      ```
    - ```python
      def hex_to_string(hex_string):
          """Convert the given hex string to ascii."""
      ```
    - ```python
      def string_to_hex(ascii_string: str, seperator='') -> str:
          """Convert the given ascii string to hex."""
      ```
    - ```python
      def character_to_unicode_number(character):
          """Convert the given character to its Unicode number. This is the same as the `ord` function in python."""
      ```
    - ```python
      def unicode_number_to_character(unicode_number):
          """Convert the given unicode_number to it's unicode character form. This is the same as the `chr` function in python."""
      ```
    - ```python
      def hamming_distance(string_1, string_2, as_percent=False):
          """Return the number of positions at which corresponding symbols in string_1 and string_2 are different (this is known as the Hamming Distance). See https://en.wikipedia.org/wiki/Hamming_distance."""
      ```
    - ```python
      def from_char_code(integer_list):
          """."""
      ```
    - ```python
      def text_ascii_characters(text: str) -> Tuple[str]:
          """."""
      ```
    - ```python
      def text_non_ascii_characters(text: str) -> Tuple[str]:
          """."""
      ```
    - ```python
      def letter_as_number(letter):
          """."""
      ```
    - ```python
      def letter_frequency(letter, text):
          """Find the frequency of the given letter in the given text."""
      ```
    - ```python
      def string_entropy(text, ignore_case=False):
          """Find the shannon entropy of the text. Inspired by the algorithm here https://web.archive.org/web/20160320142455/https://deadhacker.com/2007/05/13/finding-entropy-in-binary-files/. You can see more here: https://en.wikipedia.org/wiki/Entropy_(information_theory)"""
      ```
    - ```python
      def substrings(iterable):
          """Find all substrings in the given string."""
      ```
    - ```python
      def string_remove_non_alphabetic_characters(string: str):
          """."""
      ```
    - ```python
      def string_remove_non_numeric_characters(string: str):
          """."""
      ```
    - ```python
      def string_remove_non_alpha_numeric_characters(string: str):
          """."""
      ```
    - ```python
      def string_remove(regex_pattern, input_string, **kwargs):
          """Remove the regex_pattern from the input_string."""
      ```
    - ```python
      def string_remove_unicode(string: str):
          """Remove all Unicode characters from the given string."""
      ```
    - ```python
      def string_remove_numbers(input_string: str, replacement: str = ' '):
          """Remove all numbers from the input_strings."""
      ```
    - ```python
      def string_remove_from_start(input_string, string_to_remove):
          """Remove the string_to_remove from the start of the input_string."""
      ```
    - ```python
      def string_remove_from_end(input_string, string_to_remove):
          """Remove the string_to_remove from the end of the input_string."""
      ```
    - ```python
      def string_as_numbers(input_string: str):
          """."""
      ```
    - ```python
      def string_in_iterable_fuzzy(input_string, iterable):
          """Find if the given input_string is in one of the strings in an iterable."""
      ```
    - ```python
      def string_find_between(input_string: str, start_string: str, end_string: str, *args):
          """Find the string in the input_string that is between the start_string and the end_string."""
      ```
    - ```python
      def switch(a, b, text):
          """Switch a and b in the text."""
      ```
    - ```python
      def string_encode_as_bytes(input_string, encoding='utf-8', **kwargs):
          """."""
      ```
    - ```python
      def bytes_decode_as_string(bytes_text, encoding='utf-8', **kwargs):
          """."""
      ```
    - ```python
      def string_shorten(input_string, length, suffix='...'):
          """Shorten the given input_string to the given length."""
      ```
    - ```python
      def string_split_without_empty(input_string, split_char):
          """Split a input_string on split_char and remove empty entries."""
      ```
    - ```python
      def string_has_index(string: str, index: Union[str, int]) -> bool:
          """."""
      ```
    - ```python
      def string_split_on_uppercase(input_string: str, include_uppercase_characters=False, split_acronyms=True):
          """Split the input_string on uppercase characters. If split_acronyms is False, the function will not split consecutive uppercase letters."""
      ```
    - ```python
      def string_split_on_lowercase(input_string, include_lowercase_characters=False):
          """Split the string on lowercase characters."""
      ```
    - ```python
      def string_split_multiple(string, *splitting_characters):
          """Split a string up based on multiple splitting_characters."""
      ```
    - ```python
      def string_reverse_case(input_string):
          """Make lowercase characters uppercased and visa-versa."""
      ```
    - ```python
      def text_vowels(text):
          """Return all of the vowels in the text."""
      ```
    - ```python
      def text_vowel_count(text):
          """Count the number of vowels in the text."""
      ```
    - ```python
      def text_consonants(text):
          """Return all of the consonants in the text."""
      ```
    - ```python
      def text_consonant_count(text):
          """Count the number of consonants in the text."""
      ```
    - ```python
      def text_input(message='Enter/Paste your content.'):
          """."""
      ```
    - ```python
      def text_ensure_starts_with(text: str, prefix: str):
          """Make sure the given text starts with the given prefix."""
      ```
    - ```python
      def text_ensure_ends_with(text: str, suffix: str):
          """Make sure the given text ends with the given suffix."""
      ```
    - ```python
      def titlecase(item):
          """."""
      ```
    - ```python
      def uppercase(item):
          """."""
      ```
    - ```python
      def uppercase_first_letter(text):
          """Make the first letter of the text uppercase."""
      ```
    - ```python
      def lowercase_first_letter(text):
          """Make the first letter of the text lowercase."""
      ```
    - ```python
      def crazycase(text):
          """Make the case of the characters in the given text pseudo-random"""
      ```
    - ```python
      def kebab_case(text):
          """Return the text with a "-" in place of every space."""
      ```
    - ```python
      def snake_case(text):
          """Return the text with a "_" in place of every space."""
      ```
    - ```python
      def camel_case(text: str):
          """Return the text with no spaces and every word (except the first one) capitalized."""
      ```
    - ```python
      def pascal_case(text: str):
          """Return the text with no spaces and every word capitalized."""
      ```
    - ```python
      def sentence_case(text: str):
          """."""
      ```
    - ```python
      def uppercase_count(text):
          """Count the number of uppercase letters in the given text."""
      ```
    - ```python
      def lowercase_count(text):
          """Count the number of lowercase letters in the given text."""
      ```
    - ```python
      def lowercase(item):
          """."""
      ```
    - ```python
      def string_rotate(text, rot=13):
          """Return the text converted using a Caesar cipher (https://en.wikipedia.org/wiki/Caesar_cipher) in which the text is rotated by the given amount (using the `rot` argument)."""
      ```
    - ```python
      def text_is_english_sentence(text: str) -> bool:
          """Determine whether or not the sentence is likely English."""
      ```
    - ```python
      def leet_speak_to_text(leet_speak_text):
          """."""
      ```
    - ```python
      def text_to_leet_speak(text):
          """."""
      ```
    - ```python
      def unicode_to_ascii(text: str):
          """Convert the text to ascii."""
      ```



  👋 &nbsp;If you want to get involved in this project, we have some short, helpful guides below:

  - [contribute to this project 🥇][contributing]
  - [test it 🧪][local-dev]
  - [lint it 🧹][local-dev]
  - [explore it 🔭][local-dev]

  If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.



  This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and Floyd Hightower's [Python project template](https://github.com/fhightower-templates/python-project-template).

  [contributing]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#contributing-a-pr-
  [local-dev]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#local-development-


pkgId: c8e242e72269d8afdef354adc107bad4c0967e1bb71bf329e8bfbc6135c2f431
name: python-d8s-uuids
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Democritus functions for working with uuids.
url: https://github.com/democritus-project/d8s-uuids
rpm_license: GNU Lesser General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-d8s-uuids-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/d8s-uuids.svg)](https://pypi.python.org/pypi/d8s-uuids)
  [![CI](https://github.com/democritus-project/d8s-uuids/workflows/CI/badge.svg)](https://github.com/democritus-project/d8s-uuids/actions)
  [![Lint](https://github.com/democritus-project/d8s-uuids/workflows/Lint/badge.svg)](https://github.com/democritus-project/d8s-uuids/actions)
  [![codecov](https://codecov.io/gh/democritus-project/d8s-uuids/branch/main/graph/badge.svg?token=V0WOIXRGMM)](https://codecov.io/gh/democritus-project/d8s-uuids)
  [![The Democritus Project uses semver version 2.0.0](https://img.shields.io/badge/-semver%20v2.0.0-22bfda)](https://semver.org/spec/v2.0.0.html)
  [![The Democritus Project uses black to format code](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://choosealicense.com/licenses/lgpl-3.0/)

  Democritus functions<sup>[1]</sup> for working with uuids.

  [1] Democritus functions are <i>simple, effective, modular, well-tested, and well-documented</i> Python functions.

  We use `d8s` (pronounced "dee-eights") as an abbreviation for `democritus` (you can read more about this [here](https://github.com/democritus-project/roadmap#what-is-d8s)).



  ```
  pip install d8s-uuids
  ```



  You import the library like:

  ```python
  from d8s_uuids import *
  ```

  Once imported, you can use any of the functions listed below.



    - ```python
      def uuid4_examples(n: int = 10, *, uuids_as_strings: bool = True) -> Union[List[str], List[uuid.UUID]]:
          """Create n uuids."""
      ```
    - ```python
      def uuid4() -> str:
          """Create a random UUID."""
      ```
    - ```python
      def uuid3(name: str, *, namespace: Optional[uuid.UUID] = None) -> str:
          """Create a random uuid based on the given name."""
      ```
    - ```python
      def uuid5(name: str, *, namespace: Optional[uuid.UUID] = None) -> str:
          """Create a random uuid based on the given name."""
      ```
    - ```python
      def is_uuid(possible_uuid: Union[str, uuid.UUID], *, version: Optional[int] = None) -> bool:
          """Return whether or not the possible_uuid is a uuid."""
      ```



  👋 &nbsp;If you want to get involved in this project, we have some short, helpful guides below:

  - [contribute to this project 🥇][contributing]
  - [test it 🧪][local-dev]
  - [lint it 🧹][local-dev]
  - [explore it 🔭][local-dev]

  If you have any questions or there is anything we did not cover, please raise an issue and we'll be happy to help.



  This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and Floyd Hightower's [Python project template](https://github.com/fhightower-templates/python-project-template).

  [contributing]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#contributing-a-pr-
  [local-dev]: https://github.com/democritus-project/.github/blob/main/CONTRIBUTING.md#local-development-


pkgId: ab0d7b2784c6d07f282c598ee7a8291dc7662adc1d9f86e2215a78b84bb8f451
name: python-dabapush
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/Leibniz-HBI/dabapush
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dabapush-0.3.3-1.src.rpm
checksum_type: sha256
description:
  `run all` -- collect all known items and execute targets/destinations
  `run <target>` -- run a single writer and/or named target
  Options:


pkgId: 45dc10e758dddf8f7e0c47b256497dcd5b0d640f5e9b42fa1943fa6b9b207343
name: python-dabarqus
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A Python SDK for interacting with the Dabarqus REST API
url: https://github.com/electricpipelines/dabarqus-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-dabarqus-1.1.2-1.src.rpm
checksum_type: sha256
description:
  1. [What is Dabarqus?](#what-is-dabarqus)
  2. [Installation](#installation)
  3. [Getting Started](#getting-started)
  4. [API Reference](#api-reference)
     - [Health and Admin](#health-and-admin)
     - [Models and Downloads](#models-and-downloads)
     - [Inference](#inference)
     - [Hardware](#hardware)
     - [Silk (Memory) Operations](#silk-memory-operations)
     - [Shutdown](#shutdown)
     - [Logging](#logging)
     - [Embedding](#embedding)
  5. [Examples](#examples)


  **Dabarqus: Community Edition** &ndash; Zero to RAG in minutes. Chat with your PDFs, summarize emails and messaging, and digest a vast range of facts, figures, and reports. A dash of genius for your LLM.
  This is the **Python SDK** for Dabarqus. For more info on Dabarqus, [visit the github](https://github.com/electricpipelines/barq).





  First, install the Dabarqus Python SDK using pip:

  ```bash
  pip install dabarqus
  ```

  This command installs the SDK and all its dependencies, including the service installation script.



  After installing the SDK, you need to install and run the Dabarqus service:



  1. Download the latest Dabarqus release from the [official GitHub repository](https://github.com/electricpipelines/dabarqus/releases).

  2. Extract the downloaded zip file.

  3. Navigate to the extracted folder.

  4. Install the Dabarqus service (requires elevated privileges):
     - On Windows: Open an elevated Command Prompt or PowerShell and run:
       ```
       barq.exe service install
       ```
     - On macOS/Linux: Use sudo to run the installation:
       ```
       sudo ./barq service install
       ```

  5. Start the Dabarqus service:
     - On Windows:
       ```
       barq.exe service start
       ```
     - On macOS/Linux:
       ```
       sudo ./barq service start
       ```



  Use the provided installation script. **Note: This script must be run with elevated privileges (admin rights).**

  - On Windows: Open an elevated Command Prompt or PowerShell and run:
    ```
    dabarqus-install-service
    ```
  - On macOS/Linux: Use sudo to run the script:
    ```
    sudo dabarqus-install-service
    ```

  This script will download the appropriate Dabarqus executable for your system, install it, and set up the service.




  The Dabarqus service should start automatically after installation. You can verify this by running:
  ```
  barq
  ```

  If it doesn't work, you can start the service manually (requires elevated privileges):
  - On Windows: Run `sc start Dabarqus` in an elevated command prompt.
  - On macOS/Linux: Run `sudo systemctl start dabarqus` or `sudo launchctl start com.dabarqus.service` depending on your system.





  To start using the Dabarqus SDK, import it and create an instance:

  ```python
  from dabarqus import barq


  sdk = barq("http://localhost:6568")  # Replace with your Dabarqus server URL
  ```






  Check the health status of the Dabarqus service.

  ```python
  health_status = sdk.check_health()
  print(health_status)
  ```




  Retrieve available AI models.

  ```python
  models = sdk.get_models()
  print(models)
  ```


  Get metadata for a specific model.

  ```python
  metadata = sdk.get_model_metadata("model_repo_name", "path/to/model")
  print(metadata)
  ```


  Get information about downloaded items.

  ```python
  downloads = sdk.get_downloads("model_repo_name")
  print(downloads)
  ```


  Enqueue a new download.

  ```python
  result = sdk.enqueue_download("model_repo_name", "path/to/model")
  print(result)
  ```


  Cancel a download.

  ```python
  result = sdk.cancel_download("model_repo_name", "path/to/model")
  print(result)
  ```


  Remove a downloaded item.

  ```python
  result = sdk.remove_download("model_repo_name", "path/to/model")
  print(result)
  ```




  Get information about inference items.

  ```python
  info = sdk.get_inference_info("my_inference")
  print(info)
  ```


  Start an inference.

  ```python
  result = sdk.start_inference("my_inference", "model_repo", "path/to/model")
  print(result)
  ```


  Stop an inference.

  ```python
  result = sdk.stop_inference("my_inference")
  print(result)
  ```


  Get the status of an inference.

  ```python
  status = sdk.get_inference_status("my_inference")
  print(status)
  ```


  Reset an inference.

  ```python
  result = sdk.reset_inference("my_inference")
  print(result)
  ```


  Restart the current inference.

  ```python
  result = sdk.restart_inference()
  print(result)
  ```




  Get hardware information.

  ```python
  hardware_info = sdk.get_hardware_info()
  print(hardware_info)
  ```




  Get memory status.

  ```python
  status = sdk.get_memory_status()
  print(status)
  ```


  Enable memories.

  ```python
  result = sdk.enable_memories()
  print(result)
  ```


  Disable memories.

  ```python
  result = sdk.disable_memories()
  print(result)
  ```


  Get memory banks information.

  ```python
  banks = sdk.get_memory_banks()
  print(banks)
  ```


  Activate a memory bank.

  ```python
  result = sdk.activate_memory_bank("my_bank")
  print(result)
  ```


  Deactivate a memory bank.

  ```python
  result = sdk.deactivate_memory_bank("my_bank")
  print(result)
  ```


  Perform a semantic query.

  ```python
  results = sdk.query_semantic_search("What is Dabarqus?", limit=5, memory_bank="my_bank")
  print(results)
  ```


  Check the health of the Silk retriever.

  ```python
  health = sdk.check_silk_health()
  print(health)
  ```


  Get model metadata from the Silk retriever.

  ```python
  metadata = sdk.get_silk_model_metadata()
  print(metadata)
  ```


  Check the health of the Silk store.

  ```python
  health = sdk.check_silk_store_health()
  print(health)
  ```


  Enqueue a new ingestion item.

  ```python
  result = sdk.enqueue_ingestion("my_bank", "/path/to/documents")
  print(result)
  ```


  Cancel an ingestion.

  ```python
  result = sdk.cancel_ingestion("my_bank")
  print(result)
  ```


  Get information about ingestion items.

  ```python
  ingestions = sdk.get_ingestions("my_bank")
  print(ingestions)
  ```




  Initiate server shutdown.

  ```python
  result = sdk.shutdown_server()
  print(result)
  ```




  Write to log.

  ```python
  log_result = sdk.write_to_log({"message": "Test log entry", "level": "INFO"})
  print(log_result)
  ```




  Get an embedding from the Silk retriever.

  ```python
  embedding = sdk.get_embedding("Hello, world!")
  print(embedding)
  ```



  Here's a more comprehensive example that demonstrates using multiple SDK functions:

  ```python
  from dabarqus import barq


  sdk = barq("http://localhost:6568")


  health = sdk.check_health()
  print(f"Service health: {health}")


  banks = sdk.get_memory_banks()
  print(f"Available memory banks: {banks}")


  sdk.activate_memory_bank("my_documents")


  ingestion_result = sdk.enqueue_ingestion("my_documents", "/path/to/documents")
  print(f"Ingestion result: {ingestion_result}")


  search_results = sdk.query_semantic_search("What is Dabarqus?", limit=5, memory_bank="my_documents")
  print("Search results:")
  for result in search_results:
      print(f"- {result}")


  embedding = sdk.get_embedding("Dabarqus is a powerful RAG solution")
  print(f"Embedding (first 5 elements): {embedding[:5]}")


  hardware_info = sdk.get_hardware_info()
  print(f"Hardware info: {hardware_info}")
  ```

  This documentation provides a comprehensive guide to using the Dabarqus SDK. Users can refer to this documentation to understand how to use each method in the SDK, along with examples of how to use them in their code.


