# packages

pkgId: 8cfd0fb227007252f1cb4ad4ac3e9c19fcb8f1c32ebbd855495f0c42ea835bb2
name: python-coveo-stew
arch: src
version: 3.0.34
epoch: 0
release: 1
summary: Opinionated python packaging and development utilities
url: https://github.com/coveo/stew
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coveo-stew-3.0.34-1.src.rpm
checksum_type: sha256
description:
  The 3.0 update contains breaking changes:
  `poetry`, `mypy` and `black` are no longer distributed with `coveo-stew`.

  Please refer to the [upgrade guide](./README_UPGRADE.md#upgrading-from-2x-to-3x) for more information and resolution steps.




  coveo-stew delivers a complete Continuous Integration (CI) and Continuous Delivery (CD) solution
  using [poetry](https://python-poetry.org) as its backend.



  - Config-free pytest, mypy and black runners
  - Add your own linters and tools
  - JUnit report generation
  - GitHub Action that runs all your CI tools

  Similar to: tox


  - GitHub Action for Continuous Delivery (CD) (publish to pypi)
  - Automated "patch" version bumps (requires a `pypi` server)
  - Can download locked dependencies into a folder, for offline distribution

  Similar to: poetry, flit, pbr, setuptools


  - Support for several isolated poetry projects in one GitHub repository
  - Support for local path references
  - A "one ring to rule them all" virtual environment that includes all subprojects within the repository
  - Batch operations
  - Note: Single projects are also supported! 😅

  Similar to: nothing! it's unique! 😎




  *Changed in 3.0*: `poetry` is no longer provided out-of-the-box.

  You need [poetry](https://python-poetry.org/) installed on your system, and it must be available through the `PATH`.

  The `3.0` version of `coveo-stew` is designed to work with modern versions of `poetry`.

  While it is compatible with older versions, old poetry issues
  such as [this](https://github.com/python-poetry/poetry/issues/3189)
  and [this](https://github.com/python-poetry/poetry/issues/3254)
  will cause `stew` to misbehave.

  If you need to work with an older version of poetry,
  consider using `coveo-stew < 3.0` which had workarounds implemented around these issues.




  Just like poetry, `stew` is a CLI tool that you install in your system.

  It is recommended to install using [pipx](https://github.com/pipxproject/pipx) in order to isolate this into a nice little space:

  ```
  pip install pipx --user
  pipx install coveo-stew
  ```

  If you don't use pipx, make sure to isolate the installation into a virtual environment.




  This action checkouts the code, installs python, poetry and stew, and proceeds to run "stew ci" on a python project.



  ```yml
  jobs:
    stew-ci:
      runs-on: ubuntu-latest
      steps:
        - uses: coveo/stew@main
          with:
            python-version: "3.10"
            project-name: your-project-name
  ```

  See additional options and documentation in [the action file.](action.yml)




  When running in a GitHub context, a step summary will automatically be generated.
  This summary can be seen in the `Summary` tab of a workflow run view in GitHub.

  You can disable this feature by launching `stew ci` with `--no-github-step-report`.




  Please read these guides in order to learn how to organize your repository for maximum compatibility:

  - [For a single library](README_SINGLE_LIBRARY.md)
  - [For multiple libraries](README_MULTIPLE_LIBRARIES.md)






  Unless a project name is specified, most commands will operate on all projects in a git repository based on the current working folder:

  - `stew <command>`
      - Perform a command on all projects
  - `stew <command> --help`
      - Obtain help about a particular command
  - `stew <command> <project-name>`
      - Perform the command on all projects with `<project-name>` in their name (partial match)
  - `stew <command> <project-name> --exact-match`
      - Disable partial project name matching

  The main commands are explained below.




  The main show; it runs all CI tools on one or multiple projects.

  Errors will show in the console, and junit xml reports will be generated inside the `.ci` folder.

  Without configuration, this command will run the following checks:

  - mypy (using opinionated, strict rules)
    - Note: `mypy` is not provided with `coveo-stew`. See [builtin-runners](#builtin-runners) for info.
  - poetry check
  - stew check-outdated

  Options:

  - `--fix` will reformat the code if `black` fails. Additional fix routines may be added in the future.
  - `--check <runner>` will launch only that runner. This option can be repeated.
  - `--skip <runner>` will skip that runner. Takes precedence over `--check`. This option can be repeated.
  - `--quick` skips running `poetry install --remove-untracked` before running the checks.
    - **v3.0.30**: You can now customize which checks to run when `--quick` is specified. See the [quick](#configuration) configuration option.
  - `--no-github-step-report` can be used to disable Step Report generation when running in a GitHub context.

  The configuration for this feature is explained in more details in the [runners](#runners-stew-ci) section.



  Store the project and its **locked dependencies** to disk, so it can be installed without contacting a `pypi` server.

  Optimally used to create truly repeatable builds and workflows (e.g.: containerized images, cloud storage, etc).

  The folder can later be installed offline with `pip install --no-index --find-links <folder> <project-name>`.


  Options:

  - `--directory` specifies where the wheels should be downloaded.
  - `--python` may be used to target a different python. It's important to use the same python version, architecture and OS than the target system.

  **Make sure your target `<folder>` is clean**: Keep in mind that `pip` will still use the `pyproject.toml` constraints when installing, not `poetry.lock`.
  The locked version system works when the locked version is the only thing that `pip` can find in the `<folder>`.




  Checks for out-of-date files or automatically update them.

  Summary of actions:
  - `poetry lock` if `pyproject.toml` changed but not the `poetry.lock`
  - `stew pull-dev-requirements` if a pydev project's dev-requirements are out of sync




  Only useful on `pydev` projects (see about [multiple-libraries](README_MULTIPLE_LIBRARIES.md)).
  It pulls the dev requirements from the local projects in order to aggregate them into the dev requirements of the root project.

  Note: This command uses the `dev` group to identify test dependencies.
  This can be defined as `tool.poetry.dev-dependencies` (poetry 1.1.15) or `tool.poetry.group.dev.dependencies`.
  The group name cannot be customized, feel free to contribute the feature if that's useful to you.




  Calls `poetry lock` on all projects.




  Calls `poetry install` on all projects.




  Clears the `.egg-info` folder from your projects. Usually followed by a `poetry install` or a `stew refresh`.

  Use this if you change a `[tool.poetry.scripts]` section, else the changes will not be honored.




  Returns the path to a project:

  ```
  $ stew locate coveo-stew
  /home/jonapich/code/stew/coveo-stew
  ```





  Configuration is done through the `pyproject.toml` file; default values are shown:

  ```
  [tool.stew]
  build-without-hashes = false
  pydev = false
  build-dependencies = {}
  extras = []
  all-extras = false
  quick = {}
  ```

  - **build-without-hashes**: Disables hashes when calling `pip` to download dependencies during `stew build`.
  - **pydev**: See the [multiple-libraries](README_MULTIPLE_LIBRARIES.md) guide.
  - **build-dependencies**: You can specify additional dependencies to be installed during `stew build`.
    - The format is the same as poetry dependencies: `name = "version"` or `name = { version = "version", ... }`
  - **extras**: A list of extras to install during `stew build` and `stew ci`.
  - **all-extras**: If true, all extras will be installed during `stew build` and `stew ci`. Overrides the `extras` list.
  - **quick**: *(v3.0.30)* Controls which checks are skipped when calling `stew ci --quick`.
    - The format is a dictionary with either the `check` or `skip` key, followed by a list of runners.
    - The behavior is identical to the `--check` and `--skip` options.
    - e.g.: skip these checks `quick = { skip = ["poetry-check", "check-outdated", "poetry-build", "pytest"] }`
    - e.g.: only run these checks `quick = { check = ["mypy", "black"] }`


  Configuration is done through each `pyproject.toml` file; default values are shown:

  ```
  [tool.stew.ci]
  mypy = true
  pytest = false
  black = false
  poetry-check = true
  check-outdated = true
  offline-build = false
  ```

  You don't have to include the `[tool.stew.ci]` section at all if these defaults suit you!




  *Changed in coveo-stew 3.0*: mypy and black are no longer provided out-of-the-box.

  In order to use a builtin or custom runner, you must have it installed. These locations are supported:

  - Recommended: The runner is in the project's virtual environment (most likely as a dev dependency in `pyproject.toml`)
  - Alternative: The runner is installed in your system and available through the PATH

  We strongly suggest pinning them to your
  `pyproject.toml` file in the `[tool.poetry.dev-dependencies]` section.

  This way, mypy won't surprise you with new failures when they release new versions! 😎

  Note: You can override and customize most runners by [rewriting them as custom runners.](#custom-runners)






  A strict mypy configuration is provided.

  You can provide your own mypy configuration, but you'll have to specify the `set-config` option:

  ```
  [tool.stew.ci]


  mypy = { set-config = False }


  mypy = { set-config = "mypy.ini" }
  ```

  See https://mypy.readthedocs.io/en/stable/config_file.html#using-a-pyproject-toml



  Pytest is configured to run with `--doctest-modules --tb=short --durations=5` as well as JUnit report generation.

  Some additional options are available:

  ```
  [tool.stew.ci]


  pytest = { marker-expression = 'not docker_tests' }


  pytest = { doctest-modules = False }
  ```




  Black supports the `pyproject.toml` file natively:

  ```
  [tool.black]
  line-length = 100
  ```

  Ref: [black documentation](https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html#configuration-via-a-file)




  Runs `poetry check` on each project.




  Runs `stew check-outdated`.

  Note: This runner cannot be overridden, but it can be disabled.




  Runs `stew build` to a temporary folder and ensures that pip is able to reinstall everything from there.

  Note: This runner cannot be overridden, but it can be disabled.




  You can add your own runners to `stew ci`.
  You can also redefine a builtin runner completely.

  In this example, we create runners for flake8, bandit and isort. We also redefine the pytest runner:


  ```
  [tool.stew.ci.custom-runners]
  flake8 = true
  bandit = { check-args = ["--quiet", "--recursive", "."] }


  [tool.stew.ci.custom-runners.isort]
  check-args = ["--check", ".", "--profile black"]
  autofix-args = [".", "--profile black"]

  [tool.stew.ci.custom-runners.pytest]
  check-args = ["--tb=long", "--junitxml=.ci/pytest-results.xml"]


  [tool.stew.ci.custom-runners.ruff-check]
  executable = "ruff"
  working-directory = "project"
  check-args = ["check", "."]
  autofix-args = [ "check", "--fix", "."]

  [tool.stew.ci.custom-runners.ruff-format]
  executable = "ruff"
  working-directory = "project"
  check-args = ["format", "--check", "."]
  autofix-args = ["format", "."]
  ```

  When a builtin runner such as pytest is redefined as a custom runner, you must provide all the arguments.
  In this case, not passing `--junitxml` would mean that we lose the report that used to be in the `.ci/` directory.




  - executable: You can specify the executable name if it's different from the tool's name.
    - Runners are called through `python -m <executable>` first to see if it's installed in the virtual environment, else through the shell.
    - Using `executable`, you can create multiple custom runners with the same executable (e.g.: `ruff check` vs `ruff format`)
  - check-args: The arguments to invoke the check.
  - autofix-args: The arguments to invoke the autofix. Provide the empty string "" in order to run without arguments.
  - check-failed-exit-codes: A list of ints denoting the exit codes to consider "failed" (anything else will be "error"). 0 is always a success. default is `[1]`.
  - create-generic-report: Whether to create a generic pass/fail JUnit report for this check.
  - working-directory: The default is "project" which corresponds to the project's `pyproject.toml` file. You can change it to "repository" in order to run from the root.
  - name: You can specify the module name if it differs from the name of the tool.
    - Deprecated: name must be unique. This has been replaced by `executable`.

  The `args` and `check-args` can be:

  - A string
    - Such as a single argument "--check"
    - Such as a path "."
    - Such as an option "--profile black"
    - But NOT as a combo of the above: "--check . --profile black" will most likely not work.

  - A list of string:
    - Any combination of the "string" rules explained above.






  When you call `poetry install`, you end up installing packages based on the `poetry.lock` file.
  The resulting packages will always be the same, no matter what.
  This is the dev scenario.

  When you call `pip install`, you are installing packages based on the constraints placed in a `pyproject.toml` or a `setup.py` file.
  Unless the constraints are hard pinned versions, the resulting packages are not guaranteed and will depend on the point in time when the installation is performed, among other factors.
  This is the shared library scenario.

  When you use poetry, you cover the two scenarios above.

  The third scenario is the private business use case: you want to freeze your dependencies in time so that everything from the developer to the CI servers to the production system is identical.
  Essentially, you want `poetry install` without the dev requirements.

  This functionality is provided out of the box by `stew build`, which creates a pip-installable package from the lock file that you can then stash in a private storage of your choice or pass around your deployments.




  You can keep `poetry` and `stew` off your production environment by creating a frozen archive of your application or library from your CI servers (docker used as example):

  - Use the `stew build` tool which:
      - performs a `poetry build` on your project
      - calls `pip download` based on the content of the lock file
      - Moves the artifacts to the `.wheels` folder of your repo
  - Recommended: Use the `--python` switch when calling `stew build` to specify which python executable to use! Make sure to use a python interpreter that matches the os/arch/bits of the system you want to provision.

  The content in `.wheels` can then be zipped and moved around. A typical scenario is to push it into a Docker Container:

  - Include the `.wheels` folder into your Docker build context
  - In your Dockerfile:
      - ADD the `.wheels` folder
      - Manage the `pip` version! Either update it to latest, or pin it to something.
      - Prepare a python environment
          - Use `python -m venv <location>` to create a virtual environment natively.
          - Note the executable location... typically (`location/bin/python` or `location/Scripts/python.exe`)
      - Install your application into the python environment you just created:
          - Use `<venv-python-executable> -m pip install <your-package> --no-index --find-links <wheels-folder-location>`
      - You may delete the `.wheels` folder if you want. Consider keeping a copy of the lock file within the docker image, for reference.

  To make sure you use the python interpreter that matches the os/arch/bits of the system you want to provision, you can run `stew build` directly when building the container image.
  In order to do so without packaging `stew` in production, you can use [multi-stage builds](https://docs.docker.com/develop/develop-images/multistage-build/).



  If your IDE supports poetry, it should detect and use the `pyproject.toml` file.

  To set it up manually:

  1. Call `poetry install` from the location of the `pyproject.toml` file
  1. Obtain the location of the virtual environment (i.e.: `poetry env list --full-path`)
  1. Configure your IDE to use the python interpreter from that location

  Your IDE should proceed to analyze the environment and will pick up all imports automatically,
  regardless of your PYTHONPATH or your working directory.
  Since the local source is editable, any change to the source code will be reflected on the next interpreter run.

  If you use the multiple-projects approach, you should hook your IDE to the `pydev` environment. See [this documentation](./README_MULTIPLE_LIBRARIES.md) for more information.




  Using the correct interpreter is all you need to do.
  There is no activation script or environment variables to set up: the interpreter executable inside the virtual environment folder is a fully bootstrapped and isolated environment.

  - A python dockerfile may call `<venv-python-exec>` directly in the dockerfile's CMD
  - A service that spawns other processes should receive the path to the `<venv-python-exec>`

  [Use the `-m` switch](https://docs.python.org/3/using/cmdline.html#cmdoption-m) in order to launch your app!


pkgId: 7dd303c58ec9814fadd0a3d9b7ef5e403f63ae1a0234c3e7d7a998d4785b21cb
name: python-coveo-stew
arch: src
version: 3.1.4
epoch: 0
release: 1
summary: Opinionated python packaging and development utilities
url: https://github.com/coveo/stew
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coveo-stew-3.1.4-1.src.rpm
checksum_type: sha256
description:
  The 3.0 update contains breaking changes:
  `poetry`, `mypy` and `black` are no longer distributed with `coveo-stew`.

  Please refer to the [upgrade guide](./README_UPGRADE.md#upgrading-from-2x-to-3x) for more information and resolution steps.




  coveo-stew delivers a complete Continuous Integration (CI) and Continuous Delivery (CD) solution
  using [poetry](https://python-poetry.org) as its backend.



  - Config-free pytest, mypy and black runners
  - Add your own linters and tools
  - JUnit report generation
  - GitHub Action that runs all your CI tools

  Similar to: tox


  - GitHub Action for Continuous Delivery (CD) (publish to pypi)
  - Automated "patch" version bumps (requires a `pypi` server)
  - Can download locked dependencies into a folder, for offline distribution

  Similar to: poetry, flit, pbr, setuptools


  - Support for several isolated poetry projects in one GitHub repository
  - Support for local path references
  - A "one ring to rule them all" virtual environment that includes all subprojects within the repository
  - Batch operations
  - Note: Single projects are also supported! 😅

  Similar to: nothing! it's unique! 😎



  *Changed in 3.1*: You need python 3.9+ to run stew, but you can still use it on projects requiring older versions of python.

  *Changed in 3.0*: `poetry` is no longer provided out-of-the-box.

  You need [poetry](https://python-poetry.org/) installed on your system, and it must be available through the `PATH`.

  The `3.0` version of `coveo-stew` is designed to work with modern versions of `poetry`.

  While it is compatible with older versions, old poetry issues
  such as [this](https://github.com/python-poetry/poetry/issues/3189)
  and [this](https://github.com/python-poetry/poetry/issues/3254)
  will cause `stew` to misbehave.

  If you need to work with an older version of poetry,
  consider using `coveo-stew < 3.0` which had workarounds implemented around these issues.




  Just like poetry, `stew` is a CLI tool that you install in your system.

  It is recommended to install using [pipx](https://github.com/pipxproject/pipx) in order to isolate this into a nice little space:

  ```
  pip install pipx --user
  pipx install coveo-stew
  ```

  If you don't use pipx, make sure to isolate the installation into a virtual environment.




  This action checkouts the code, installs python, poetry and stew, and proceeds to run "stew ci" on a python project.



  ```yml
  jobs:
    stew-ci:
      runs-on: ubuntu-latest
      steps:
        - uses: coveo/stew@main
          with:
            python-version: "3.10"
            project-name: your-project-name
  ```

  See additional options and documentation in [the action file.](action.yml)




  When running in a GitHub context, a step summary will automatically be generated.
  This summary can be seen in the `Summary` tab of a workflow run view in GitHub.

  You can disable this feature by launching `stew ci` with `--no-github-step-report`.




  Please read these guides in order to learn how to organize your repository for maximum compatibility:

  - [For a single library](README_SINGLE_LIBRARY.md)
  - [For multiple libraries](README_MULTIPLE_LIBRARIES.md)






  Unless a project name is specified, commands will operate on all projects in a git repository based on the current working folder:

  - `stew <command>`
      - Perform a command on all projects
  - `stew <command> --help`
      - Obtain help about a particular command


  Some commands allow specifying a project name:

  - `stew <command> <project-name>`
      - Perform the command on all projects with `<project-name>` in their name (partial, case-insensitive)
      - e.g.: `stew ci tools` will run on `tools`, `tools-common`, `my-tools`, etc.
  - `stew <command> <project-name> --exact-match`
      - Disable partial project name matching
      - e.g.: `stew ci tools --exact-match` will run on `tools` but not on `tools-common`, `my-tools`, etc.
  - `stew <command> .<path>`
      - **v3.1.3** Only consider the project at this location
      - The path must start with `.`
      - Nested projects will not run
      - e.g.: `stew ci .` will only run on the project in the current folder
      - e.g.: `stew ci ./tools` will only run on the project in the `tools` folder

  The main commands are explained below.




  The main show; it runs all CI tools on one or multiple projects.

  Errors will show in the console, and junit xml reports will be generated inside the `.ci` folder.

  Without configuration, this command will run the following checks:

  - mypy (using opinionated, strict rules)
    - Note: `mypy` is not provided with `coveo-stew`. See [builtin-runners](#builtin-runners) for info.
  - poetry check
  - stew check-outdated

  Options:

  - `--fix` will reformat the code if `black` fails. Additional fix routines may be added in the future.
  - `--check <runner>` will launch only that runner. This option can be repeated.
  - `--skip <runner>` will skip that runner. Takes precedence over `--check`. This option can be repeated.
  - `--quick` skips running `poetry install --remove-untracked` before running the checks.
    - **v3.0.30**: You can now customize which checks to run when `--quick` is specified. See the [quick](#configuration) configuration option.
  - `--no-github-step-report` can be used to disable Step Report generation when running in a GitHub context.
  - `--extra <extra>` *(v3.1.1)* will install the specified extra(s) for this run. Can be specified multiple times.
  - `--all-extras` *(v3.1.1)* will install all extras for this run.
  - `--no-extras` *(v3.1.1)* will not install any extra for this run.

  The configuration for this feature is explained in more details in the [runners](#runners-stew-ci) section.



  Store the project and its **locked dependencies** to disk, so it can be installed without contacting a `pypi` server.

  Optimally used to create truly repeatable builds and workflows (e.g.: containerized images, cloud storage, etc).

  The folder can later be installed offline with `pip install --no-index --find-links <folder> <project-name>`.


  Options:

  - `--directory` specifies where the wheels should be downloaded.
  - `--python` may be used to target a different python. It's important to use the same python version, architecture and OS than the target system.

  **Make sure your target `<folder>` is clean**: Keep in mind that `pip` will still use the `pyproject.toml` constraints when installing, not `poetry.lock`.
  The locked version system works when the locked version is the only thing that `pip` can find in the `<folder>`.




  Checks for out-of-date files or automatically update them.

  Summary of actions:
  - `poetry lock` if `pyproject.toml` changed but not the `poetry.lock`
  - `stew pull-dev-requirements` if a pydev project's dev-requirements are out of sync




  Only useful on `pydev` projects (see about [multiple-libraries](README_MULTIPLE_LIBRARIES.md)).
  It pulls the dev requirements from the local projects in order to aggregate them into the dev requirements of the root project.

  Note: This command uses the `dev` group to identify test dependencies.
  This can be defined as `tool.poetry.dev-dependencies` (poetry 1.1.15) or `tool.poetry.group.dev.dependencies`.
  The group name cannot be customized, feel free to contribute the feature if that's useful to you.




  Calls `poetry lock` on all projects.




  Calls `poetry install` on all projects.




  Clears the `.egg-info` folder from your projects. Usually followed by a `poetry install` or a `stew refresh`.

  Use this if you change a `[tool.poetry.scripts]` section, else the changes will not be honored.




  Returns the path to a project:

  ```
  $ stew locate coveo-stew
  /home/jonapich/code/stew/coveo-stew
  ```





  Configuration is done through the `pyproject.toml` file; default values are shown:

  ```
  [tool.stew]
  build-without-hashes = false
  pydev = false
  build-dependencies = {}
  extras = []
  all-extras = false
  quick = {}
  ```

  - **build-without-hashes**: Disables hashes when calling `pip` to download dependencies during `stew build`.
  - **pydev**: See the [multiple-libraries](README_MULTIPLE_LIBRARIES.md) guide.
  - **build-dependencies**: You can specify additional dependencies to be installed during `stew build`.
    - The format is the same as poetry dependencies: `name = "version"` or `name = { version = "version", ... }`
  - **extras**: A list of extras to install during `stew build` and `stew ci`.
    - *(v3.1.1)* Can be specified at execution time with `stew ci --extra <this> --extra <that>`.
  - **all-extras**: If true, all extras will be installed during `stew build` and `stew ci`. Overrides the `extras` list.
    - *(v3.1.1)* Can be specified at execution time with `stew ci --all-extras` and `stew ci --no-extras`.
  - **quick**: *(v3.0.30)* Controls which checks are skipped when calling `stew ci --quick`.
    - The format is a dictionary with either the `check` or `skip` key, followed by a list of runners.
    - The behavior is identical to the `--check` and `--skip` options.
    - e.g.: skip these checks `quick = { skip = ["poetry-check", "check-outdated", "poetry-build", "pytest"] }`
    - e.g.: only run these checks `quick = { check = ["mypy", "black"] }`


  Configuration is done through each `pyproject.toml` file; default values are shown:

  ```
  [tool.stew.ci]
  mypy = true
  pytest = false
  black = false
  poetry-check = true
  check-outdated = true
  offline-build = false
  ```

  You don't have to include the `[tool.stew.ci]` section at all if these defaults suit you!




  *Changed in coveo-stew 3.0*: mypy and black are no longer provided out-of-the-box.

  In order to use a builtin or custom runner, you must have it installed. These locations are supported:

  - Recommended: The runner is in the project's virtual environment (most likely as a dev dependency in `pyproject.toml`)
  - Alternative: The runner is installed in your system and available through the PATH

  We strongly suggest pinning them to your
  `pyproject.toml` file in the `[tool.poetry.dev-dependencies]` section.

  This way, mypy won't surprise you with new failures when they release new versions! 😎

  Note: You can override and customize most runners by [rewriting them as custom runners.](#custom-runners)






  A strict mypy configuration is provided.

  You can provide your own mypy configuration, but you'll have to specify the `set-config` option:

  ```
  [tool.stew.ci]


  mypy = { set-config = False }


  mypy = { set-config = "mypy.ini" }
  ```

  See https://mypy.readthedocs.io/en/stable/config_file.html#using-a-pyproject-toml



  Pytest is configured to run with `--doctest-modules --tb=short --durations=5` as well as JUnit report generation.

  Some additional options are available:

  ```
  [tool.stew.ci]


  pytest = { marker-expression = 'not docker_tests' }


  pytest = { doctest-modules = False }
  ```




  Black supports the `pyproject.toml` file natively:

  ```
  [tool.black]
  line-length = 100
  ```

  Ref: [black documentation](https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html#configuration-via-a-file)




  Runs `poetry check` on each project.




  Runs `stew check-outdated`.

  Note: This runner cannot be overridden, but it can be disabled.




  Runs `stew build` to a temporary folder and ensures that pip is able to reinstall everything from there.

  Note: This runner cannot be overridden, but it can be disabled.




  You can add your own runners to `stew ci`.
  You can also redefine a builtin runner completely.

  In this example, we create runners for flake8, bandit and isort. We also redefine the pytest runner:


  ```
  [tool.stew.ci.custom-runners]
  flake8 = true
  bandit = { check-args = ["--quiet", "--recursive", "."] }


  [tool.stew.ci.custom-runners.isort]
  check-args = ["--check", ".", "--profile black"]
  autofix-args = [".", "--profile black"]

  [tool.stew.ci.custom-runners.pytest]
  check-args = ["--tb=long", "--junitxml=.ci/pytest-results.xml"]


  [tool.stew.ci.custom-runners.ruff-check]
  executable = "ruff"
  working-directory = "project"
  check-args = ["check", "."]
  autofix-args = [ "check", "--fix", "."]

  [tool.stew.ci.custom-runners.ruff-format]
  executable = "ruff"
  working-directory = "project"
  check-args = ["format", "--check", "."]
  autofix-args = ["format", "."]
  ```

  When a builtin runner such as pytest is redefined as a custom runner, you must provide all the arguments.
  In this case, not passing `--junitxml` would mean that we lose the report that used to be in the `.ci/` directory.




  - executable: You can specify the executable name if it's different from the tool's name.
    - Runners are called through `python -m <executable>` first to see if it's installed in the virtual environment, else through the shell.
    - Using `executable`, you can create multiple custom runners with the same executable (e.g.: `ruff check` vs `ruff format`)
  - check-args: The arguments to invoke the check.
  - autofix-args: The arguments to invoke the autofix. Provide the empty string "" in order to run without arguments.
  - check-failed-exit-codes: A list of ints denoting the exit codes to consider "failed" (anything else will be "error"). 0 is always a success. default is `[1]`.
  - create-generic-report: Whether to create a generic pass/fail JUnit report for this check.
  - working-directory: The default is "project" which corresponds to the project's `pyproject.toml` file. You can change it to "repository" in order to run from the root.
  - name: You can specify the module name if it differs from the name of the tool.
    - Deprecated: name must be unique. This has been replaced by `executable`.

  The `args` and `check-args` can be:

  - A string
    - Such as a single argument "--check"
    - Such as a path "."
    - Such as an option "--profile black"
    - But NOT as a combo of the above: "--check . --profile black" will most likely not work.

  - A list of string:
    - Any combination of the "string" rules explained above.






  When you call `poetry install`, you end up installing packages based on the `poetry.lock` file.
  The resulting packages will always be the same, no matter what.
  This is the dev scenario.

  When you call `pip install`, you are installing packages based on the constraints placed in a `pyproject.toml` or a `setup.py` file.
  Unless the constraints are hard pinned versions, the resulting packages are not guaranteed and will depend on the point in time when the installation is performed, among other factors.
  This is the shared library scenario.

  When you use poetry, you cover the two scenarios above.

  The third scenario is the private business use case: you want to freeze your dependencies in time so that everything from the developer to the CI servers to the production system is identical.
  Essentially, you want `poetry install` without the dev requirements.

  This functionality is provided out of the box by `stew build`, which creates a pip-installable package from the lock file that you can then stash in a private storage of your choice or pass around your deployments.




  You can keep `poetry` and `stew` off your production environment by creating a frozen archive of your application or library from your CI servers (docker used as example):

  - Use the `stew build` tool which:
      - performs a `poetry build` on your project
      - calls `pip download` based on the content of the lock file
      - Moves the artifacts to the `.wheels` folder of your repo
  - Recommended: Use the `--python` switch when calling `stew build` to specify which python executable to use! Make sure to use a python interpreter that matches the os/arch/bits of the system you want to provision.

  The content in `.wheels` can then be zipped and moved around. A typical scenario is to push it into a Docker Container:

  - Include the `.wheels` folder into your Docker build context
  - In your Dockerfile:
      - ADD the `.wheels` folder
      - Manage the `pip` version! Either update it to latest, or pin it to something.
      - Prepare a python environment
          - Use `python -m venv <location>` to create a virtual environment natively.
          - Note the executable location... typically (`location/bin/python` or `location/Scripts/python.exe`)
      - Install your application into the python environment you just created:
          - Use `<venv-python-executable> -m pip install <your-package> --no-index --find-links <wheels-folder-location>`
      - You may delete the `.wheels` folder if you want. Consider keeping a copy of the lock file within the docker image, for reference.

  To make sure you use the python interpreter that matches the os/arch/bits of the system you want to provision, you can run `stew build` directly when building the container image.
  In order to do so without packaging `stew` in production, you can use [multi-stage builds](https://docs.docker.com/develop/develop-images/multistage-build/).



  If your IDE supports poetry, it should detect and use the `pyproject.toml` file.

  To set it up manually:

  1. Call `poetry install` from the location of the `pyproject.toml` file
  1. Obtain the location of the virtual environment (i.e.: `poetry env list --full-path`)
  1. Configure your IDE to use the python interpreter from that location

  Your IDE should proceed to analyze the environment and will pick up all imports automatically,
  regardless of your PYTHONPATH or your working directory.
  Since the local source is editable, any change to the source code will be reflected on the next interpreter run.

  If you use the multiple-projects approach, you should hook your IDE to the `pydev` environment. See [this documentation](./README_MULTIPLE_LIBRARIES.md) for more information.




  Using the correct interpreter is all you need to do.
  There is no activation script or environment variables to set up: the interpreter executable inside the virtual environment folder is a fully bootstrapped and isolated environment.

  - A python dockerfile may call `<venv-python-exec>` directly in the dockerfile's CMD
  - A service that spawns other processes should receive the path to the `<venv-python-exec>`

  [Use the `-m` switch](https://docs.python.org/3/using/cmdline.html#cmdoption-m) in order to launch your app!


pkgId: 7fe525efd9ffb2c9384475f4f0b0eb936138732a2d77856c68f86d078ee245dc
name: python-coveo-styles
arch: src
version: 2.1.10
epoch: 0
release: 1
summary: Styles, colors and emojis for the command line.
url: https://github.com/coveooss/coveo-python-oss/tree/main/coveo-styles
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coveo-styles-2.1.10-1.src.rpm
checksum_type: sha256
description:
  Don't let your CLI app spit out hundreds of boring lines!

  Manage your user feedback a bit like you manage logs, and get bonus colors and emojis just because we can!

  This module provides an `echo` symbol that you can use instead of `print` for convenience.

  It is also completely customizable!




  Here's how a ci run could look like:

  ```python
  from coveo_styles.styles import echo

  echo.step("Launching ci operations")
  echo.normal("pytest", emoji='hourglass')
  echo.normal("black", emoji='hourglass')
  echo.noise("Generated test reports in .ci/")
  echo.success()
  echo.warning("Formatting errors detected")
  echo.suggest("The --fix switch will automatically fix these for you and re-run the test !!smile!!")
  echo.error("The CI run detected errors you need to fix", pad_after=False)
  echo.error_details("Black reported files to reformat", item=True)
  echo.error_details("Details as items is nice!", item=True)
  ```


  ```
  Launching ci operations

  ⌛ pytest
  ⌛ black
  Generated test reports in .ci/

  ✔ Success!


  ⚠ Formatting errors detected


  🤖 The --fix switch will automatically fix these for you and re-run the test 😄


  💥 The CI run detected errors you need to fix
   · Black reported files to reformat
   · Details as items is nice
  ```

  It's even nicer with colors! :) This doc needs a few animated gifs!





  Exception handlers may re-raise an exception as an `ExitWithFailure` in order to hide the traceback from the user and show a helpful error message.

  Here's an example for the sake of demonstration:

  ```python
  from pathlib import Path
  from coveo_styles.styles import ExitWithFailure

  try:
      project = Path('./project').read_text()
  except FileNotFoundError as exception:
      raise ExitWithFailure(suggestions='Use the --list switch to see which projects I can see') from exception
  ```

  The stacktrace will be hidden, the app will exit with code 1 after printing the exception type and message:

  ```
  ! FileNotFoundError: [Errno 2] No such file or directory: 'project'

  🤖 Use the --list switch to see which projects I can see
  ```

  Unhandled exceptions (those that are not wrapped by an ExitWithFailure), will display the usual python feedback and stacktrace.





  Emoji support is provided by the [emoji](https://pypi.org/project/emoji/) package.
  Their description provides different links to help with your emoji hunt, but for some reason not everything is supported or has the name it should have.

  The only foolproof way I have found is to actually inspect the `emoji` package, either by opening `site-packages/emoji/unicode_codes/en.py` in my IDE or programmatically like this:

  ```python
  from coveo_styles.styles import echo
  from emoji.unicode_codes.en import EMOJI_UNICODE_ENGLISH, EMOJI_ALIAS_UNICODE_ENGLISH

  query = 'smile'.lower()

  for emoji_name in {*EMOJI_UNICODE_ENGLISH, *EMOJI_ALIAS_UNICODE_ENGLISH}:
      emoji_name = emoji_name.strip(':')
      if query in emoji_name.lower():
          echo.normal(f'{emoji_name}: !!{emoji_name}!!')
  ```

  ```
  sweat_smile: 😅
  cat_face_with_wry_smile: 😼
  smile: 😄
  smiley: 😃
  smiley_cat: 😺
  smile_cat: 😸
  ```


pkgId: adc3f23be767e5f7e1b08ee9bc0ebe3e214d467f5cbcbde6ad711408b8efa5ce
name: python-coveo-systools
arch: src
version: 2.0.18
epoch: 0
release: 1
summary: Filesystem, language and OS related tools.
url: https://github.com/coveooss/coveo-python-oss/tree/main/coveo-systools
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coveo-systools-2.0.18-1.src.rpm
checksum_type: sha256
description:
  Language and OS related utilities.


  Content in a nutshell:

  - enhanced subprocess calls
  - asyncio subprocess calls
  - file and app finding made easy
  - safe text write and replace-if-different
  - git-repo-root locator
  - bool platforms `if WINDOWS or LINUX or MAC or WSL:`




  ```python
  import os
  from coveo_systools.filesystem import find_paths, find_application, find_repo_root

  os.getcwd()


  find_application('git')


  find_repo_root()


  list(find_paths('pyproject.toml', search_from=find_repo_root(), in_root=True, in_children=True))

  ```



  An opinionated version of `subprocess.check_call` and `subprocess.check_output`.

  _New in 2.0.7_: asyncio support, through `async_check_call` and `async_check_output`.

  Adds the following features:
  - command line is a variable args (instead of a list)
  - automatic conversion of output to a stripped string (instead of raw bytes)
  - automatic conversion of Path, bytes and number variables in command line
  - automatic filtering of ansi codes from the output
  - enhanced DetailedCalledProcessError on error (a subclass of the typical CalledProcessError)

  ```python
  from pathlib import Path
  from coveo_systools.subprocess import check_call

  check_call('mypy', '--config-file', Path('configs/mypy.ini'), verbose=True)
  ```




  Good programming practices requires files to be saved using a temporary filename and then renamed.
  This helper takes it a step further by skipping the write operation if the content did not change:

  ```python
  import json
  from pathlib import Path
  from coveo_systools.filesystem import safe_text_write

  safe_text_write(Path('./path/to/file.txt'), json.dumps(...), only_if_changed=True)
  ```




  Readability is important, not repeating yourself is important.
  Forget about `platform.platform()` and use bools directly:

  ```python
  from coveo_systools.platforms import WINDOWS, LINUX, IOS, WSL

  if WINDOWS or WSL:
      print("Hello Windows!")
  elif LINUX or IOS:
      print("Hello Unix!")
  ```


pkgId: 4b676351ced8d8b81a200001e26a4fb5d561b6ae995d2f1fd0777df22403e7b9
name: python-coveo-testing-extras
arch: src
version: 2.1.12
epoch: 0
release: 1
summary: Dependency-hungry testing helpers
url: https://github.com/coveooss/coveo-python-oss/tree/main/coveo-testing-extras
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coveo-testing-extras-2.1.12-1.src.rpm
checksum_type: sha256
description:
  Contains extra testing tools without dependency restrictions.




  The docker container temporary resource can be used to prepare short-lived containers.

  - Supports building from a dockerfile
  - Supports pulling images
  - Can signal on AWS ECR logout
  - Dynamic port mapping retrieval
  - Saves log output before removing the container




  Here's how you can enhance `TemporaryDockerContainerResource` with automatic ECR login:

  ```python
  from base64 import b64decode

  import boto3
  from coveo_testing_extras.temporary_resource.docker_container import (
      TemporaryDockerContainerResource,
      ECRLogoutException,
      get_docker_client
  )

  class WithECR(TemporaryDockerContainerResource):
      def obtain_image(self) -> None:
          try:
              super().obtain_image()
          except ECRLogoutException:
              self._do_ecr_login()
              super().obtain_image()

      def _do_ecr_login(self) -> None:
          """ Performs an ecr login through awscli. """
          assert self.ecr_region
          ecr = boto3.client('ecr')
          account_id, *_ = self.image_name.split('.')
          assert account_id.isdigit()
          authorization_data = ecr.get_authorization_token(registryIds=[account_id])['authorizationData'][0]
          username, password = b64decode(authorization_data['authorizationToken']).decode().split(':')
          with get_docker_client() as client:
              login = client.login(username=username, password=password, registry=authorization_data['proxyEndpoint'])
          assert login['Status'] == 'Login Succeeded'
  ```


pkgId: ad3409d84e6896b22ee2709dfe53e3afd3c9db52c93dfc6446f3cc63eaea6bac
name: python-coverage-badge
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Generate coverage badges for Coverage.py.
url: https://github.com/dbrgn/coverage-badge
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coverage-badge-1.1.2-1.src.rpm
checksum_type: sha256
description:
  |buildstatus| |downloads|
     ⚠️ coverage-badge is in maintenance mode. I might still do occasional updates
     and fixes from time to time, but there will be no added features. Most
     people using coverage-badge might want to use genbadge_ instead, which has
     more features (e.g. test badges, flake8 reports, etc).
  A small script to generate coverage badges using Coverage.py.
  Example of a generated badge: |example|
  The badge template has been taken from shields.io_, therefore it should look
  mostly good. (The spec is a bit stricter on the margins, but I can't easily do
  text width calculations in Python so the margins might not always be 4px.)


pkgId: fd041823fdb3987e9bebb6ddc4111bed17ae4ad1a56023f75077759344e0a360
name: python-coverage-conditional-plugin
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Conditional coverage based on any rules you define!
url: https://github.com/wemake-services/coverage-conditional-plugin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coverage-conditional-plugin-0.9.0-1.src.rpm
checksum_type: sha256
description:
  [![wemake.services](https://img.shields.io/badge/%20-wemake.services-green.svg?label=%20&logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAABGdBTUEAALGPC%2FxhBQAAAAFzUkdCAK7OHOkAAAAbUExURQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP%2F%2F%2F5TvxDIAAAAIdFJOUwAjRA8xXANAL%2Bv0SAAAADNJREFUGNNjYCAIOJjRBdBFWMkVQeGzcHAwksJnAPPZGOGAASzPzAEHEGVsLExQwE7YswCb7AFZSF3bbAAAAABJRU5ErkJggg%3D%3D)](https://wemake.services)
  [![Build Status](https://github.com/wemake-services/coverage-conditional-plugin/workflows/test/badge.svg?branch=master&event=push)](https://github.com/wemake-services/coverage-conditional-plugin/actions?query=workflow%3Atest)
  [![codecov](https://codecov.io/gh/wemake-services/coverage-conditional-plugin/branch/master/graph/badge.svg)](https://codecov.io/gh/wemake-services/coverage-conditional-plugin)
  [![Python Version](https://img.shields.io/pypi/pyversions/coverage-conditional-plugin.svg)](https://pypi.org/project/coverage-conditional-plugin/)
  [![wemake-python-styleguide](https://img.shields.io/badge/style-wemake-000000.svg)](https://github.com/wemake-services/wemake-python-styleguide)

  Conditional coverage based on any rules you define!

  Some projects have different parts that relies on different environments:

  - Python version, some code is only executed on specific versions and ignored on others
  - OS version, some code might be Windows, Mac, or Linux only
  - External packages, some code is only executed when some 3rd party package is installed

  Current best practice is to use `# pragma: no cover` for this places in our project.
  This project allows to use configurable pragmas
  that include code to the coverage if some condition evaluates to true,
  and fallback to ignoring this code when condition is false.

  Read [the announcing post](https://sobolevn.me/2020/02/conditional-coverage).




  ```bash
  pip install coverage-conditional-plugin
  ```

  Then you will need to add to your `setup.cfg` or `.coveragerc` file
  some extra configuration:

  ```ini
  [coverage:run]

  plugins =
    coverage_conditional_plugin

  [coverage:coverage_conditional_plugin]

  omit =
    "sys_platform == 'win32'":
        "my_project/omit*.py"
        "my_project/win.py"

  rules =
    "sys_version_info >= (3, 8)": py-gte-38
    "is_installed('mypy')": has-mypy

  ```

  Or to your `pyproject.toml`:

  ```toml
  [tool.coverage.run]

  plugins = ["coverage_conditional_plugin"]

  [tool.coverage.coverage_conditional_plugin.omit]

  "my_project/omit*.py" = "sys_platform == 'win32'"

  [tool.coverage.coverage_conditional_plugin.rules]

  py-gte-38 = "sys_version_info >= (3, 8)"
  has-mypy = "is_installed('mypy')"
  ```


  Adapt rules to suit your needs!




  Imagine that we have this code:

  ```python
  try:  # pragma: has-django
      import django
  except ImportError:  # pragma: has-no-django
      django = None

  def run_if_django_is_installed():
      if django is not None:  # pragma: has-django
          ...
  ```

  And here's the configuration you might use:

  ```ini
  [coverage:coverage_conditional_plugin]
  rules =
    "is_installed('django')": has-django
    "not is_installed('django')": has-no-django

  ```

  When running tests with and without `django` installed
  you will have `100%` coverage in both cases.

  But, different lines will be included.
  With `django` installed it will include
  both `try:` and `if django is not None:` conditions.

  When running without `django` installed,
  it will include `except ImportError:` line.




  Format for pragma rules is:

  ```
  "pragma-condition": pragma-name
  ```

  Code inside `"pragma-condition"` is evaluted with `eval`.
  Make sure that the input you pass there is trusted!
  `"pragma-condition"` must return `bool` value after evaluation.

  We support all environment markers specified in [PEP-496](https://www.python.org/dev/peps/pep-0496/).
  See [Strings](https://www.python.org/dev/peps/pep-0496/#strings)
  and [Version Numbers](https://www.python.org/dev/peps/pep-0496/#version-numbers)
  sections for available values. Also, we provide a bunch of additional markers:

  - `sys_version_info` is the same as [`sys.version_info`](https://docs.python.org/3/library/sys.html#sys.version_info)
  - `os_environ` is the same as [`os.environ`](https://docs.python.org/3/library/os.html#os.environ)
  - `is_installed` is our custom function that tries to import the passed string, returns `bool` value
  - `package_version` is our custom function that tries to get package version from `pkg_resources` and returns its [parsed version](https://packaging.pypa.io/en/latest/version/#packaging.version.parse)

  Use `get_env_info` to get values for the current environment:

  ```python
  from coverage_conditional_plugin import get_env_info

  get_env_info()
  ```




  Omits allow entire files to be conditionally omitted from coverage measurement.

  The TOML format for omits is:

  ```toml
  [tool.coverage.coverage_conditional_plugin.omit]
  "pragma-condition" = ["project/prefix*.py", "project/filename.py"]

  "pragma-condition" = "project/filename.py"
  ```

  **Note**: `ini` format is not supported for `omit` configuration option,
  because there's no easy way to parse `ini` complex configuration.
  PRs with the fix are welcome!

  File name patterns should follow coverage.py's `[run] omit` syntax.
  See [coverage.py](https://coverage.readthedocs.io/en/stable/source.html).




  [MIT](https://github.com/wemake.services/coverage-conditional-plugin/blob/master/LICENSE)


pkgId: 3bda51664e9036b0bf268e1ec91fa6dfb1fb0dc9eded9b1c585f88ec4f6f9e09
name: python-coverage-lcov
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A simple .coverage to LCOV converter
url: https://github.com/TheCleric/coverage-lcov
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coverage-lcov-0.3.0-1.src.rpm
checksum_type: sha256
description:
  `coverage-lcov` is a simple CLI for converting `.coverage` files generated by [Coverage.py](https://github.com/nedbat/coveragepy) to the `LCOV` format.



  - This tools is based on code from [Coverage.py](https://github.com/nedbat/coveragepy/blob/master/coverage/report.py)
  - This tool is forked from [coveragepy-lcov](https://github.com/chaychoong/coveragepy-lcov) by [Chay Choong](https://github.com/chaychoong) to add support for older python versions.



  Using pip:

  ```bash
  pip install coverage-lcov
  ```



  ```bash

  coverage-lcov


  coverage-lcov --data_file_path example/.coverage


  coverage-lcov --output_file_path build/lcov.info


  coverage-lcov --relative_path
  ```



  ```text
  Usage: coverage-lcov [OPTIONS]

  Options:
    --data_file_path TEXT    Path to .coverage file
    --output_file_path TEXT  lcov.info output file path
    --config_file TEXT       Path to .coveragerc file
    --relative_path          Use relative path in LCOV output
    --preview                Preview LCOV output
    --help                   Show this message and exit.
  ```



  - [LCOV format](http://ltp.sourceforge.net/coverage/lcov/geninfo.1.php)
  - https://github.com/nedbat/coveragepy/issues/587
  - https://github.com/chaychoong/coveragepy-lcov


pkgId: fe9d86f4cc7d6ae7db1c3ab2c5e976e98f4746cf925c0aad858a2d12f9c1cf2a
name: python-coverage-plot
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Library to plot Python code coverage results
url: https://github.com/imankulov/coverage-plot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coverage-plot-0.3.2-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/imankulov/coverage-plot/branch/master/graph/badge.svg)](https://codecov.io/gh/imankulov/coverage-plot)
  [![Coverage Status](https://coveralls.io/repos/github/imankulov/coverage-plot/badge.svg)](https://coveralls.io/github/imankulov/coverage-plot)
  [![Maintainability](https://api.codeclimate.com/v1/badges/0f758ae06864812dce12/maintainability)](https://codeclimate.com/github/imankulov/coverage-plot/maintainability)
  [![Documentation Status](https://readthedocs.org/projects/coverage-plot/badge/?version=latest)](https://coverage-plot.readthedocs.io/en/latest/?badge=latest)

  A library and a script to plot Python code coverage results.



  Run the tests for your project with the test coverage, and convert the coverage results to a JSON or XML format. As a result, you should find a coverage.json or coverage.xml file in your current working directory.

  ```
  coverage run -m pytest
  coverage xml  # or coverage json
  ```

  Install the package.

  ```
  pip install coverage-plot
  ```

  Run the coverage visualization. The script opens the browser with the visualization results.

  ```
  coverage-plot coverage.xml
  ```


pkgId: 3ef5c89fff3cbfdc02148fb2357daf484675bece8d4145685909993d81669259
name: python-coverage-threshold
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Tools for coverage threshold limits
url: https://github.com/DeanWay/coverage-threshold
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coverage-threshold-0.5.0-1.src.rpm
checksum_type: sha256
description:
  A command line tool for checking coverage reports against configurable coverage minimums.
  Currently built for use around python's [coverage](https://pypi.org/project/coverage/)



  `pip install coverage-threshold`

  also recommended:

  `pip install coverage`


  Typical execution:
  ```bash
  coverage run -m pytest tests/  # or any test runner here
  coverage json
  coverage-threshold
  ```

  cli command options:

  ```
  > coverage-threshold --help
  usage: coverage-threshold [-h] [--line-coverage-min LINE_COVERAGE_MIN]
                            [--branch-coverage-min BRANCH_COVERAGE_MIN]
                            [--combined-coverage-min COMBINED_COVERAGE_MIN]
                            [--file-line-coverage-min FILE_LINE_COVERAGE_MIN]
                            [--file-branch-coverage-min FILE_BRANCH_COVERAGE_MIN]
                            [--file-combined-coverage-min FILE_COMBINED_COVERAGE_MIN]
                            [--coverage-json COVERAGE_JSON] [--config CONFIG]

  A command line tool for checking coverage reports against configurable coverage minimums

  optional arguments:
    -h, --help            show this help message and exit
    --line-coverage-min LINE_COVERAGE_MIN
                          minimum global average line coverage threshold
    --branch-coverage-min BRANCH_COVERAGE_MIN
                          minimum global average branch coverage threshold
    --combined-coverage-min COMBINED_COVERAGE_MIN
                          minimum global average combined line and branch coverage threshold
    --file-line-coverage-min FILE_LINE_COVERAGE_MIN
                          the line coverage threshold for each file
    --file-branch-coverage-min FILE_BRANCH_COVERAGE_MIN
                          the branch coverage threshold for each file
    --file-combined-coverage-min FILE_COMBINED_COVERAGE_MIN
                          the combined line and branch coverage threshold for each file
    --coverage-json COVERAGE_JSON
                          path to coverage json (default: ./coverage.json)
    --config CONFIG       path to config file (default: ./pyproject.toml)
  ```




  the current expected config file format is [toml](https://toml.io/en/)
  the default config file used is `pyproject.toml` but and alternative path can be specified with `--config`

  example config:
  ```toml
  [coverage-threshold]
  line_coverage_min = 95
  file_line_coverage_min = 95
  branch_coverage_min = 50

      [coverage-threshold.modules."src/cli/"]
      file_line_coverage_min = 40

      [coverage-threshold.modules."src/cli/my_command.py"]
      file_line_coverage_min = 100

      [coverage-threshold.modules."src/lib/"]
      file_line_coverage_min = 100
      file_branch_coverage_min = 100

      [coverage-threshold.modules."src/model/"]
      file_line_coverage_min = 100

      [coverage-threshold.modules."src/__main__.py"]
      file_line_coverage_min = 0
  ```

  Each string key in `config.modules` is treated as a path prefix, where the longest matching prefix is used to configure the coverage thresholds for each file


pkgId: d6af43c158ddc599908601f7f86f1cf9e3203cdcbdb0587357e806ad5d3d7ea1
name: python-coverage2clover
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: A tool to convert python-coverage xml report to Atlassian Clover xml report format
url: https://github.com/tumb1er/coverage2clover
rpm_license: Beer License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coverage2clover-4.0.0-1.src.rpm
checksum_type: sha256
description:
  A tool to convert python-coverage xml report to Atlassian Clover xml report
  format.
  [![Build Status](https://github.com/tumb1er/coverage2clover/workflows/Build/badge.svg?branch=master&event=push)](https://github.com/tumb1er/coverage2clover/actions?query=event%3Apush+branch%3Amaster+workflow%3ABuild)
  [![PyPI version](https://badge.fury.io/py/coverage2clover.svg)](http://badge.fury.io/py/coverage2clover)
  [![Python Versions](https://img.shields.io/pypi/pyversions/coverage2clover.svg)](https://pypi.python.org/pypi/coverage2clover)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


pkgId: fc248dc19ce01b1f019e58a12facd82bee7cfee2d5a97e8d81f99868860cf0f6
name: python-coveragepy-lcov
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A simple .coverage to LCOV converter
url: https://github.com/chaychoong/coveragepy-lcov
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coveragepy-lcov-0.1.2-1.src.rpm
checksum_type: sha256
description:
  `coveragepy-lcov` is a simple CLI for converting `.coverage` files generated by [Coverage.py](https://github.com/nedbat/coveragepy) to the `LCOV` format.



  This tools is based on code from [Coverage.py](https://github.com/nedbat/coveragepy/blob/master/coverage/report.py).



  Using pip:

  ```bash
  pip install coveragepy-lcov
  ```



  ```bash

  coveragepy-lcov


  coveragepy-lcov --data_file_path example/.coverage


  coveragepy-lcov --output_file_path build/lcov.info


  coveragepy-lcov --relative_path
  ```



  ```text
  Usage: coveragepy-lcov [OPTIONS]

  Options:
    --data_file_path TEXT    Path to .coverage file
    --output_file_path TEXT  lcov.info output file path
    --config_file TEXT       Path to .coveragerc file
    --relative_path          Use relative path in LCOV output
    --preview                Preview LCOV output
    --help                   Show this message and exit.
  ```



  - [LCOV format](http://ltp.sourceforge.net/coverage/lcov/geninfo.1.php)
  - https://github.com/nedbat/coveragepy/issues/587


pkgId: bef693129c42b0350acd3c75e39f2d834e0e834ae982688909c87d7e273dfef0
name: python-coveragespace
arch: src
version: 6.1
epoch: 0
release: 1
summary: A place to track your code coverage metrics.
url: https://coverage.space/client/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coveragespace-6.1-1.src.rpm
checksum_type: sha256
description:
  The official command-line client for [The Coverage Space](http://coverage.space).

  [![Build Status](https://img.shields.io/github/actions/workflow/status/jacebrowning/coverage-space-cli/main.yml?branch=main&label=build)](https://github.com/jacebrowning/coverage-space-cli/actions)
  [![Coverage Status](https://img.shields.io/coveralls/jacebrowning/coverage-space-cli/main.svg)](https://coveralls.io/r/jacebrowning/coverage-space-cli)
  [![Scrutinizer Code Quality](https://img.shields.io/scrutinizer/g/jacebrowning/coverage-space-cli.svg)](https://scrutinizer-ci.com/g/jacebrowning/coverage-space-cli/?branch=main)
  [![PyPI Version](https://img.shields.io/pypi/v/coveragespace.svg)](https://pypi.org/project/coveragespace)
  [![PyPI License](https://img.shields.io/pypi/l/coveragespace.svg)](https://pypi.org/project/coveragespace)





  - Python 3.7+



  Install this tool globally with [pipx](https://pipxproject.github.io/pipx/) (or pip):

  ```text
  $ pipx install coveragespace
  ```
  or add it to your [Poetry](https://python-poetry.org/docs/) project:

  ```text
  $ poetry add coveragespace
  ```



  To update the value for a test coverage metric:

  ```text
  $ coveragespace update <metric>
  ```

  where `<metric>` is one of:

  - **unit**
  - **integration**
  - **overall**

  For example, after running unit tests with code coverage enabled:

  ```text
  $ coveragespace update unit
  ```

  which will attempt to extract the current coverage data from your project directory and compare that with the last known value. The coverage value can also be manually specified:

  ```text
  $ coveragespace update <metric> <value>
  ```


pkgId: 5846d55cda2896f945d2f36cf55a36687e78e09aea86655b1eb0733a75e287da
name: python-covid
arch: src
version: 3.0.0
epoch: 0
release: 1
url: https://nf1s.github.io/covid/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covid-3.0.0-1.src.rpm
checksum_type: sha256
summary:
  Python package to get information regarding the novel corona virus provided by Johns Hopkins university and worldometers.info

description:
  [![CircleCI](https://circleci.com/gh/nf1s/covid.svg?style=shield)](https://circleci.com/gh/nf1s/covid) [![codecov](https://codecov.io/gh/nf1s/covid/branch/master/graph/badge.svg)](https://codecov.io/gh/nf1s/covid) ![Pypi locked Python version](https://img.shields.io/pypi/pyversions/covid) [![Downloads](https://pepy.tech/badge/covid)](https://pepy.tech/project/covid) ![GitHub](https://img.shields.io/github/license/nf1s/covid)



  Python package to get information regarding the novel corona virus provided
  by Johns Hopkins university and worldometers.info

  Full Documentation can be found [here](https://nf1s.github.io/covid/)

  ![corona.jpeg](docs/img/corona.jpeg)



      python >= 3.10



      pip install covid



      pydantic
      requests





  ![worldometers](docs/img/worldometers.png)

  ```python
  covid = Covid()
  ```



  ```python
  covid.get_data()
  ```



  ```python
  [
      {
          'country': 'USA',
          'confirmed': 311637,
          'new_cases': 280,
          'deaths': 8454,
          'recovered': 14828,
          'active': 288355,
          'critical': 8206,
          'new_deaths': 2,
          'total_tests': 1656897,
          'total_tests_per_million': Decimal('0'),
          'total_cases_per_million': Decimal('941'),
          'total_deaths_per_million': Decimal('26')
      },
      {
          'active': 1376,
          'confirmed': 81669,
          'country': 'China',
          'critical': 295,
          'deaths': 3329,
          'new_cases': 30,
          'new_deaths': 3,
          'recovered': 76964,
          'total_cases_per_million': Decimal('57'),
          'total_deaths_per_million': Decimal('2'),
          'total_tests': 0,
          'total_tests_per_million': Decimal('0')
      }
      ...
  ]

  ```



  ```python
  covid.get_status_by_country_name("italy")
  ```



  ```python
  {
      'active': 88274,
      'confirmed': 124632,
      'country': 'Italy',
      'critical': 3994,
      'deaths': 15362,
      'new_cases': 0,
      'new_deaths': 0,
      'recovered': 20996,
      'total_cases_per_million': Decimal('2061'),
      'total_deaths_per_million': Decimal('254'),
      'total_tests': 657224,
      'total_tests_per_million': Decimal('0')
   }
  ```



  ```python
  countries = covid.list_countries()
  ```



  ```python
  [
      'china',
      'italy',
      'usa',
      'spain',
      'germany',
  ...
  ]
  ```



  ```python
  active = covid.get_total_active_cases()
  ```



  ```python
  confirmed = covid.get_total_confirmed_cases()
  ```



  ```python
  recovered = covid.get_total_recovered()
  ```



  ```python
  deaths = covid.get_total_deaths()
  ```



  ```bash
  covid --help
  ```




  ```bash
  covid
  ```

  or

  ```bash
  covid -s worldometers
  ```



  ```bash
  covid -s john_hopkins
  ```




  This comes in handy when you need to know the available names of countries
  when using `covid -s 'source' -c 'country_name'`, eg. "The Republic of Moldova" or just "Moldova"
  So use this when you need to know the country exact name that you can use.

  ```bash
  covid -s worldometers --list-countries
  ```



  ```bash
  covid -s worldometers -c sweden
  ```



  ```bash
  covid -s worldometers -o active
  ```



  ```bash
  covid -s worldometers -o confirmed
  ```



  ```bash
  covid -s worldometers -o recovered
  ```



  ```bash
  covid -s worldometers -o deaths
  ```



  ![john_hopkins](docs/img/john_hopkins.png)



  ```python
  from covid import Covid

  covid = Covid()
  covid.get_data()
  ```



  ```python
  [
      {
          'id': '53',
          'country': 'China',
          'confirmed': 81020,
          'active': 9960,
          'deaths': 3217,
          'recovered': 67843,
          'latitude': 30.5928,
          'longitude': 114.3055,
          'last_update': 1584097775000
      },
      {
          'id': '115',
          'country': 'Italy',
          'confirmed': 24747,
          'active': 20603,
          'deaths': 1809,
          'recovered': 2335,
          'latitude': 41.8719,
          'longitude': 12.5674,
          'last_update': 1584318130000
      },
      ...
  ]
  ```



  This comes in handy when you need to know the available names of countries
  when using `get_status_by_country_name`, eg. "The Republic of Moldova" or just "Moldova"
  So use this when you need to know the country exact name that you can use.

  ```python
  countries = covid.list_countries()
  ```



  ```python
  [
      {'id': '53', 'country': 'China'},
      {'id': '115', 'country': 'Italy'}
      ...
  ]
  ```



  ```python
  italy_cases = covid.get_status_by_country_id(115)
  ```



  ```python
  {
      'id': '115',
      'country': 'Italy',
      'confirmed': 24747,
      'active': 20603,
      'deaths': 1809,
      'recovered': 2335,
      'latitude': 41.8719,
      'longitude': 12.5674,
      'last_update': 1584318130000
  }
  ```



  ```python
  italy_cases = covid.get_status_by_country_name("italy")
  ```



  ```python
  {
      'id': '115',
      'country': 'Italy',
      'confirmed': 24747,
      'active': 20603,
      'deaths': 1809,
      'recovered': 2335,
      'latitude': 41.8719,
      'longitude': 12.5674,
      'last_update': 1584318130000
  }
  ```



  ```python
  confirmed = covid.get_total_confirmed_cases()
  ```



  ```python
  deaths = covid.get_total_deaths()
  ```


pkgId: ae7e9969f8ab505a50cf4c7a978230e3e0b141489935f17e3f30194e8e130769
name: python-covid-surge
arch: src
version: 0.0.41
epoch: 0
release: 1
url: https://github.com/dpploy/covid-surge
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covid-surge-0.0.41-1.src.rpm
checksum_type: sha256
summary:
  Covid-Surge is a utility for computing and comparing mortality surge periods of communities afflicted by the COVID-19 virus pandemic.

description:
  [![NBViewer](https://raw.githubusercontent.com/jupyter/design/master/logos/Badges/nbviewer_badge.svg)](https://nbviewer.jupyter.org/github/dpploy/covid-surge/tree/master/notebooks/)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/dpploy/covid-surge/master)
  [![Azure Notebooks](https://notebooks.azure.com/launch.svg)](https://notebooks.azure.com/dealmeidavf/projects/covid-surge)
  [![PyPI Version](https://img.shields.io/pypi/v/covid-surge)](https://pypi.org/project/covid-surge/)
  [![PyPI Python Version](https://img.shields.io/pypi/pyversions/covid-surge)](https://pypi.org/project/covid-surge/)
  [![Repo Size](https://img.shields.io/github/repo-size/dpploy/covid-surge)](https://github.com/dpploy/covid-surge)
  [![CircleCI](https://img.shields.io/circleci/build/github/dpploy/covid-surge/master)](https://circleci.com/gh/dpploy/covid-surge)
  [![codecov](https://codecov.io/gh/dpploy/covid-surge/branch/master/graph/badge.svg)](https://codecov.io/gh/dpploy/covid-surge)


pkgId: 995a912df373c3a516a1e5d81c62b9410829de22be85e3920cb3819f1dbea1a6
name: python-covid19-outbreak-simulator
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Population-based Forward-time Simulator for the Outbreak of COVID-19
url: https://github.com/ictr/covid19-outbreak-simulator
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covid19-outbreak-simulator-0.5.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/covid19-outbreak-simulator.svg)](https://pypi.python.org/pypi/covid19-outbreak-simulator)
  [![PyPI version](https://img.shields.io/pypi/pyversions/covid19-outbreak-simulator.svg)](https://pypi.python.org/pypi/covid19-outbreak-simulator)
  [![Documentation Status](https://readthedocs.org/projects/covid19-outbreak-simulator/badge/?version=latest)](https://covid19-outbreak-simulator.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://travis-ci.org/ictr/covid19-outbreak-simulator.svg?branch=master)](https://travis-ci.org/ictr/covid19-outbreak-simulator)
  [![Coverage Status](https://coveralls.io/repos/github/ictr/covid19-outbreak-simulator/badge.svg?branch=master&service=github)](https://coveralls.io/github/ictr/covid19-outbreak-simulator?branch=master)
  [![Documentation Status](https://readthedocs.org/projects/covid19-outbreak-simulator/badge/?version=latest)](https://covid19-outbreak-simulator.readthedocs.io/en/latest/?badge=latest)



  COVID-19 Outbreak Simulator is a population-based simulator that simulates the spread of SARS-CoV-2 virus in a dynamic and heterogeneous population, subject to preventative measures and post-outbreak action plans such as quarantine, testing, and removal of symptomatic cases. Outputs from the simulator can be used to obtain quantitative measures of the effectiveness of these actions.

  Please refer to our [homepage](https://ictr.github.io/covid19-outbreak-simulator/) for details and cite

  > Bo Peng, Rowland W Pettit, Christopher I Amos, Population simulations of COVID-19  outbreaks provide tools for risk assessment and continuity planning, JAMIA Open, 2021;, ooaa074, https://doi.org/10.1093/jamiaopen/ooaa074

  if you have used the simulator for your work. You can also have a look at

  > Peng B, Zhou W, Pettit RW, et al, Reducing COVID-19 quarantine with SARS-CoV-2 testing: a simulation study BMJ Open 2021;11:e050473. https://doi.org/10.1136/bmjopen-2021-050473

  for an example for the application of the simulator.


pkgId: b8d7d59ff58ca27a145700a0b7d4ba8012693a7beb5f3e904be709a61082f007
name: python-covid19dh
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Unified data hub for a better understanding of COVID-19 https://covid19datahub.io
url: https://www.covid19datahub.io
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covid19dh-2.3.1-1.src.rpm
checksum_type: sha256
description:
  <a href="https://covid19datahub.io"><img src="https://storage.covid19datahub.io/logo.svg" align="right" height="128"/></a>



  [![](https://img.shields.io/pypi/v/covid19dh.svg?color=brightgreen)](https://pypi.org/pypi/covid19dh/) [![](https://img.shields.io/pypi/dm/covid19dh.svg?color=blue)](https://pypi.org/pypi/covid19dh/) [![DOI](https://joss.theoj.org/papers/10.21105/joss.02376/status.svg)](https://doi.org/10.21105/joss.02376) [![](https://github.com/covid19datahub/Python/workflows/utests_on_commit/badge.svg)](https://github.com/covid19datahub/Python)

  Download COVID-19 data across governmental sources at national, regional, and city level, as described in [Guidotti and Ardia (2020)](https://www.doi.org/10.21105/joss.02376). Includes the time series of vaccines, tests, cases, deaths, recovered, hospitalizations, intensive therapy, and policy measures by [Oxford COVID-19 Government Response Tracker](https://www.bsg.ox.ac.uk/research/research-projects/coronavirus-government-response-tracker). Please agree to the [Terms of Use](https://covid19datahub.io/LICENSE.html) and cite the following reference when using it:

  **Reference**

  Guidotti, E., Ardia, D., (2020).
  COVID-19 Data Hub
  _Journal of Open Source Software_, **5**(51):2376
  [https://doi.org/10.21105/joss.02376](https://doi.org/10.21105/joss.02376)



  Install from [pip](https://pypi.org/project/covid19dh/) with

  ```python
  pip install covid19dh
  ```

  Importing the main function `covid19()`

  ```python
  from covid19dh import covid19
  x, src = covid19()
  ```

  Package is regularly updated. Update with

  ```bash
  pip install --upgrade covid19dh
  ```



  The function `covid19()` returns 2 pandas dataframes:
  * the data and
  * references to the data sources.





  List of country names (case-insensitive) or ISO codes (alpha-2, alpha-3 or numeric). The list of ISO codes can be found [here](https://github.com/covid19datahub/COVID19/blob/master/inst/extdata/db/ISO.csv).

  Fetching data from a particular country:

  ```python
  x, src = covid19("USA") # Unites States
  ```

  Specify multiple countries at the same time:

  ```python
  x, src = covid19(["ESP","PT","andorra",250])
  ```

  If `country` is omitted, the whole dataset is returned:

  ```python
  x, src = covid19()
  ```



  Logical. Skip data cleaning? Default `True`. If `raw=False`, the raw data are cleaned by filling missing dates with `NaN` values. This ensures that all locations share the same grid of dates and no single day is skipped. Then, `NaN` values are replaced with the previous non-`NaN` value or `0`.

  ```python
  x, src = covid19(raw = False)
  ```



  Date can be specified with `datetime.datetime`, `datetime.date` or as a `str` in format `YYYY-mm-dd`.

  ```python
  from datetime import datetime
  x, src = covid19("SWE", start = datetime(2020,4,1), end = "2020-05-01")
  ```



  Integer. Granularity level of the data:

  1. Country level
  2. State, region or canton level
  3. City or municipality level

  ```python
  from datetime import date
  x, src = covid19("USA", level = 2, start = date(2020,5,1))
  ```



  Logical. Memory caching? Significantly improves performance on successive calls. By default, using the cached data is enabled.

  Caching can be disabled (e.g. for long running programs) by:

  ```python
  x, src = covid19("FRA", cache = False)
  ```



  Logical. Retrieve the snapshot of the dataset that was generated at the `end` date instead of using the latest version. Default `False`.

  To fetch e.g. US data that were accessible on *22th April 2020* type

  ```python
  x, src = covid19("USA", end = "2020-04-22", vintage = True)
  ```

  The vintage data are collected at the end of the day, but published with approximately 48 hour delay,
  once the day is completed in all the timezones.

  Hence if `vintage = True`, but `end` is not set, warning is raised and `None` is returned.

  ```python
  x, src = covid19("USA", vintage = True) # too early to get today's vintage
  ```

  ```
  UserWarning: vintage data not available yet
  ```



  The data sources are returned as second value.

  ```python
  from covid19dh import covid19
  x, src = covid19("USA")
  print(src)
  ```



  Find out more at https://covid19datahub.io



  Developed and maintained by [Martin Benes](https://pypi.org/user/martinbenes1996/).



  *Guidotti, E., Ardia, D., (2020), "COVID-19 Data Hub", Journal of Open Source Software 5(51):2376, doi: 10.21105/joss.02376.*

  A BibTeX entry for LaTeX users is

  ```latex
  @Article{,
      title = {COVID-19 Data Hub},
      year = {2020},
      doi = {10.21105/joss.02376},
      author = {Emanuele Guidotti and David Ardia},
      journal = {Journal of Open Source Software},
      volume = {5},
      number = {51},
      pages = {2376}
  }
  ```


pkgId: 400430fce6ac4ad92f7a1d6f6ed1bd2e53ea7afd8a32e5400e9c245f69ad4109
name: python-covid19poland
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Web Scraper for Poland COVID19 data.
url: https://github.com/martinbenes1996/covid19poland
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covid19poland-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Python package [covid19poland](https://pypi.org/project/covid19poland/) is part of MFRatio project.

  It provides access to death data in Poland due to COVID-19 as well as overall deaths data.



  Install from [pip](https://pypi.org/project/covid19poland/) with

  ```python
  pip install covid19poland
  ```

  Several data sources are in current version
  * Covid-19 deaths in Poland (offline) - manually checked
  * Parser of Twitter of Polish Ministery of Health
  * Covid-19 deaths from Wikipedia


  Package is regularly updated. Update with

  ```bash
  pip install --upgrade covid19poland
  ```



  Deaths can be acquired as dataframe of separate death cases with attributes

  ```python
  import covid19poland as PL

  x = PL.covid_death_cases()
  ```

  or as death counts aggregated over 5y age groups, sex and region.

  ```python
  x = PL.covid_deaths()
  ```

  Granularity of the region is parametrizable as 0 (whole Poland), 2 (NUTS-2) or 3 (NUTS-3, default).

  ```python
  x = PL.covid_deaths(level = 2) # setting region to be NUTS-2
  ```

  The NUTS-2 and NUTS-3 classification is done using offline clone of file from
  https://ec.europa.eu/eurostat/web/nuts/local-administrative-units.

  **Online reading**

  It is recommended to use the offline data, since they have been acquired
  this way and manually checked. The data is offline acquirable with the package `covid19poland`.

  If online data from Twitter is wanted, it can be downloaded and parsed as well.


  ```python
  data,filtered,checklist = PL.twitter(start = "2020-06-01", end = "2020-07-01")
  ```

  Turn on logs by typing following code before the `twitter()` function call.

  ```python
  import logging
  logging.basicConfig(level = logging.INFO)
  ```

  The result of the `twitter()` call are three values

  * data - containing the deceased people with their place and date of death
  * filtered - tweets, that were filtered out. Just for validation that nothing was missed.
  * checklist - list of dates that the parser is not sure about

  The data can be saved to output files with

  ```python
  with open("data/6_in.json", "w") as fd:
      json.dump(data, fd)
  with open("data/6_out.json", "w") as fd:
      json.dump(filtered, fd)
  print(checklist)
  ```

  Offline data can be validated towards deaths from `covid19dh` package,
  the mismatching days are acquired by

  ```python
  x = PL.mismatching_days()
  ```



  The test counts come from two sources and are merged together:

  * Parsed from Polish Ministery of Health ([@MZ_GOV_PL](https://twitter.com/MZ_GOV_PL))
  * Wayback Machine (NUTS-3 data) from government pages. (*not connected yet*)


  Fetch the data with

  ```python
  x = PL.covid_tests()
  ```

  Local copy of the data in the package is used.
  To live-parse the data from the source

  ```python
  x = PL.covid_tests(offline = False)
  ```




  The `covid19poland` can also fetch death data from GUS (*Główny Urząd Statystyczny*
  or Central Statistical Office of Poland). The data is taken from http://demografia.stat.gov.pl/bazademografia/Tables.aspx
  and it is deaths per month and gender in years 2010 - 2018.


  ```python
  x = PL.deaths()
  ```

  Local copy of the data in the package is used. To live-parse the data from the source, type

  ```python
  x = PL.deaths(offline = False)
  ```



  *Obsolete*

  The table comes from version from beginning of June on Wikipedia page
  https://en.wikipedia.org/wiki/COVID-19_pandemic_in_Poland

  ```python
  x = PL.wiki()
  ```

  Once better tabular source is found, it will replace the current one.

  Level is a setting for granularity of data

  1. Country level (default)
  2. State level

  ```python

  x1 = PL.fetch(level = 1)

  x2 = PL.fetch(level = 2)
  ```



  Developed by [Martin Benes](https://github.com/martinbenes1996).

  Join on [GitHub](https://github.com/martinbenes1996/covid19poland).


pkgId: 98cdfc2bdcfcdb055ddfc501b030cbba6086c64b44f9bb8dc3afee7d51ebdb25
name: python-covidactnow
arch: src
version: 1.1.76
epoch: 0
release: 1
url: https://pypi.org/project/covidactnow/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covidactnow-1.1.76-1.src.rpm
checksum_type: sha256
summary:
  A wrapper allowing users to get specific state-based COVID statistics from the Covid Act Now database.

description:
  For more information on how the wrapper works, particularly how it was redesigned to be package-friendly, read the "Updated for Distribution" section of this [page](https://covidinfo.preritdas.com). Note that this version has been updated to get data from within a `User` class allowing individual API keys to be used (as opposed to defining a state as an object and defining statistics as object attributes).


pkgId: f282455fa982f2de1b3e66d53bfdfa1f1394d6daaca1bab54fb4c3432245a9e7
name: python-covidcast
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Access COVID-19 data through the Delphi COVIDcast API
url: https://cmu-delphi.github.io/covidcast/covidcast-py/html/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covidcast-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Provides Python access to the [COVIDcast
  API](https://cmu-delphi.github.io/delphi-epidata/api/covidcast.html) published
  by the [Delphi group](https://delphi.cmu.edu/) at [Carnegie Mellon
  University](https://www.cmu.edu). This API provides daily access to a range of
  COVID-related signals Delphi collects from a variety of sources, including
  cases, deaths, symptom surveys, healthcare data, and other information. This
  package also provides convenient tools for mapping and analyzing the API's data.

  For installation instructions, documentation, and examples, consult the [package
  documentation](https://cmu-delphi.github.io/covidcast/covidcast-py/html/).


pkgId: 4656ea738cdcd8d14fb4880f48acf35e16d591882e861647cc615498e3012821
name: python-covimerage
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Generate coverage information for Vim scripts.
url: https://github.com/Vimjas/covimerage
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covimerage-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Generates code coverage information for Vim scripts.

  It parses the output from Vim's `:profile` command, and generates data
  compatible with [Coverage.py](http://coverage.readthedocs.io/).

  [![Build Status](https://circleci.com/gh/Vimjas/covimerage/tree/master.svg?style=shield)](https://circleci.com/gh/Vimjas/covimerage)
  [![codecov](https://codecov.io/gh/Vimjas/covimerage/branch/master/graph/badge.svg)](https://codecov.io/gh/Vimjas/covimerage/branch/master)
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/548eb25f726646fbbe660dc9fb6d392a)](https://www.codacy.com/app/blueyed/covimerage)



  You can install covimerage using pip:

  ```sh
  pip install covimerage
  ```



  You can use `covimerage run` to wrap the call to Neovim/Vim with necessary
  boilerplate:

  ```sh
  covimerage run vim -Nu test/vimrc -c 'Vader! test/**'
  ```

  This will write the file `.coverage_covimerage` by default (use `--data-file`
  to configure it), which is compatible with Coverage.py.
  A report is automatically generated (on stdout).

  You can then call `covimerage xml` to create a `coverage.xml` file
  (Cobertura-compatible), which tools like [Codecov](https://codecov.io/)'s
  `codecov` tool can consume, e.g. via `codecov -f coverage.xml`.





  You have to basically add the following to your tests vimrc:

  ```vim
  profile start /tmp/vim-profile.txt
  profile! file ./*
  ```

  This makes Neovim/Vim then write a file with profiling information.



  ```sh
  covimerage write_coverage /tmp/vim-profile.txt
  ```

  This will create a file `.coverage_covimerage` (the default for `--data-file`),
  with entries marked for processing by a
  [Coverage.py](http://coverage.readthedocs.io/) plugin (provided by
  covimerage)).



  When using `coverage` on the generated output (data file), you need to add
  the `covimerage` plugin to the `.coveragerc` file (which Coverage.py uses).
  This is basically all the `.coveragerc` you will need, but you could use
  other settings here (for Coverage.py), e.g. to omit some files:

  ```
  [run]
  plugins = covimerage
  data_file = .coverage_covimerage
  ```



  You can now call e.g. `coverage report -m`, and you should be able to use
  coverage reporting platforms like <https://codecov.io/> or
  <https://coveralls.io>, which are basically using `coverage xml`.



  - [Neomake](https://github.com/neomake/neomake) is the first adopter of this.
    It has an advanced test setup (including Docker based builds), and looking at
    tis setup could be helpful when setting up covimerage for your
    plugin/project.

    - [Neomake's coverage report on codecov.io](https://codecov.io/gh/neomake/neomake/tree/master)
    - [PR/change to integrate it in
      Neomake](https://github.com/neomake/neomake/pull/1600) (Neomake's test
      setup is rather advanced, so do not let that scare you!)



  Coverage information for a function may get wiped if the function is re-defined
  after testing it. This is a known limitation that does not depend on the
  implementation of covimerage, but on the vim profiler itself, since profiling
  data for a function, used to extract coverage data, is reset when the function
  is re-defined, even if the definition is identical.

  This can be an issue if the source files being checked for coverage are
  reloaded with `runtime` between tests for some reasons, e.g. when mocking some
  function. To prevent coverage information from being lost, one solution is to
  write such tests in a different suite that is run separately, and combine the
  coverage results with `covimerage run --append`.



  - Discussion in Coverage.py's issue tracker:
    [coverage issue 607](https://bitbucket.org/ned/coveragepy/issues/607/)



  - Line hit counts: known to covimerage, but not supported by Coverage.py
    (<https://bitbucket.org/ned/coveragepy/issues/607/#comment-40048034>).


pkgId: 8c34d08ea15df0126cc40840eca7b3a5231674e224076d8bb07a85d6ae07c45e
name: python-covizpy
arch: src
version: 1.0.24
epoch: 0
release: 1
url: https://github.com/UBC-MDS/covizpy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covizpy-1.0.24-1.src.rpm
checksum_type: sha256
summary:
  Provides access to Covid-19 data from Our World in Data, and functions to generate relevant charts and summaries.

description:
  [![codecov](https://codecov.io/gh/ubc-mds/covizpy/branch/main/graph/badge.svg?token=bCRbU4Axjx)](https://codecov.io/gh/ubc-mds/covizpy)
  [![ci-cd](https://github.com/UBC-MDS/covizpy/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/UBC-MDS/covizpy/actions/workflows/ci-cd.yml)
  [![Documentation Status](https://readthedocs.org/projects/covizpy/badge/?version=latest)](https://covizpy.readthedocs.io/en/latest/?badge=latest)

  `covizpy` is a Python package that provides easy access to Covid-19 data from [Our World in Data](https://ourworldindata.org/coronavirus), as well as functions to generate relevant Covid-19 charts and summaries easily. We aim to make `covizpy` simple and easy to use. Our goal is to enable anyone with basic Python programming knowledge to access and visualize Covid-19 data, and make their own informed decisions and conclusions.

  There are existing Python packages that allow users to download and generate Covid-19 charts. For example, [covid19pandas](https://github.com/PayneLab/covid19pandas) is a package that presents COVID-19 data from Johns Hopkins University and The New York Times in pandas dataframes, to make analysis and visualization easier in a Python environment.

  While other packages have more advanced plotting capabilities, we provide simpler functions that allow users to answer questions regarding the Covid-19 pandemic as quickly as possible.



  This package contains four functions: `plot_metric`, `plot_spec`, `get_data` and `plot_summary`.

  * `plot_metric`: Create a line chart presenting COVID total new cases versus another metric within a time period

  * `plot_spec`: Create a line chart presenting specific country/countries COVID information within a time period

  * `get_data`: User can retrieve the COVID data from the source as a pandas dataframe. Specific data can be retrieved by passing the date range and the list of countries

  * `plot_summary`: Create a horizontal bar chart summarising a specified variable and value within a time period



  Before installing the package, following packages must be installed:

  - python = "^3.9"
  - pandas = "^1.3.5"
  - altair = "^4.2.0"
  - altair-saver = "^0.5.0"



  ```bash
  pip install covizpy
  ```



  To use the package, import the package with following commands:

  ```python
  from covizpy.get_data import get_data
  from covizpy.plot_summary import plot_summary
  from covizpy.plot_metric import plot_metric
  from covizpy.plot_spec import plot_spec
  ```

  To use the functions, see below examples:



  ```python
  df = get_data(date_from="2022-01-01", date_to="2022-01-21")
  ```



  ```python
  plot_summary(df, var="location", val="new_cases", fun="sum", date_from="2022-01-01", date_to="2022-01-15", top_n=10)
  ```

  ![Summary graph](https://github.com/UBC-MDS/covizpy/raw/main/img/plot_summary.png)



  ```python
  plot_spec(df, location=["Canada", "Turkey"], val="new_cases", date_from="2022-01-01", date_to="2022-01-07")
  ```

  ![New COVID-19 specific graph](https://github.com/UBC-MDS/covizpy/raw/main/img/plot_spec.png)



  ```python
  plot_metric(location="Canada", metric="positive_rate", date_from="2022-01-01", date_to="2022-01-15")
  ```

  ![New COVID-19 case metric graph](https://github.com/UBC-MDS/covizpy/raw/main/img/plot_metric.png)




  * Rohit Rawat
  * Rong Li
  * Thomas Siu
  * Ting Zhe Yan



  Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.



  `covizpy` was created by Rohit Rawat, Rong Li, Thomas Siu, Ting Zhe Yan . It is licensed under the terms of the MIT license.



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


pkgId: 687ddf975a544e749ae43005011c9958bd1471df2112fe7b2b480597c4c25b73
name: python-covsirphy
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: COVID-19 data analysis with phase-dependent SIR-derived ODE models
url: https://github.com/lisphilar/covid19-sir/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covsirphy-3.1.2-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/lisphilar/covid19-sir/main/docs/logo/covsirphy_headline.png" width="390" alt="CovsirPhy: COVID-19 analysis with phase-dependent SIRs">

  [![PyPI version](https://badge.fury.io/py/covsirphy.svg)](https://badge.fury.io/py/covsirphy)
  [![Downloads](https://static.pepy.tech/badge/covsirphy)](https://pepy.tech/project/covsirphy)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/covsirphy)](https://badge.fury.io/py/covsirphy)
  [![GitHub license](https://img.shields.io/github/license/lisphilar/covid19-sir)](https://github.com/lisphilar/covid19-sir/blob/master/LICENSE)
  [![Quality Check](https://github.com/lisphilar/covid19-sir/actions/workflows/test.yml/badge.svg)](https://github.com/lisphilar/covid19-sir/actions/workflows/test.yml)
  [![Test Coverage](https://codecov.io/gh/lisphilar/covid19-sir/branch/master/graph/badge.svg?token=9Z8Z1UHY3I)](https://codecov.io/gh/lisphilar/covid19-sir)



  [<strong>Documentation</strong>](https://lisphilar.github.io/covid19-sir/index.html)
  | [<strong>Installation</strong>](https://lisphilar.github.io/covid19-sir/markdown/INSTALLATION.html)
  | [<strong>Tutorial</strong>](<https://lisphilar.github.io/covid19-sir/01_data_preparation.html>)
  | [<strong>API reference</strong>](https://lisphilar.github.io/covid19-sir/covsirphy.html)
  | [<strong>GitHub</strong>](https://github.com/lisphilar/covid19-sir)
  | [<strong>Qiita (Japanese)</strong>](https://qiita.com/tags/covsirphy)

  <strong>CovsirPhy is a Python library for infectious disease (COVID-19: Coronavirus disease 2019, Monkeypox 2022) data analysis with phase-dependent SIR-derived ODE models. We can download datasets and analyze them easily. Scenario analysis with CovsirPhy enables us to make data-informed decisions. </strong>

  <img src="https://raw.githubusercontent.com/lisphilar/covid19-sir/main/docs/dfd/covsirphy_dfd.png" width="800" alt="Data flow diagram: data science for infectious diseases with CovsirPhy Python library">



  * Monitor the spread of COVID-19/Monkeypox with SIR-derived ODE models
  * Predict the number of cases in each country/province
  * Find the relationship of reproductive number and measures taken by each country

  <strong>If you have ideas or need new functionalities, please join this project.
  Any suggestions with [Github Issues](https://github.com/lisphilar/covid19-sir/issues/new/choose) and [Twitter: @lisphilar](https://twitter.com/lisphilar) are always welcomed. Questions are also great. Please refer to [Guideline of contribution](https://lisphilar.github.io/covid19-sir/CONTRIBUTING.html).</strong>



  The latest stable version of CovsirPhy is available at [PyPI (The Python Package Index): covsirphy](https://pypi.org/project/covsirphy/) and supports Python 3.8 or newer versions. Details are explained in [Documentation: Installation](https://lisphilar.github.io/covid19-sir/markdown/INSTALLATION.html).

  ```Bash
  pip install --upgrade covsirphy
  ```



  Quickest tour of CovsirPhy is here. The following codes analyze the records in Japan.

  ```Python
  import covsirphy as cs

  snr = cs.ODEScenario.auto_build(geo="Japan", model=cs.SIRFModel)

  snr.simulate(name=None);

  snr.to_dynamics(name="Baseline").detect();

  snr.simulate(name="Baseline");

  snr.build_with_template(name="Predicted", template="Baseline");
  snr.predict(days=30, name="Predicted");

  snr.simulate(name="Predicted");

  snr.append();

  snr.summary()

  snr.compare_param("Rt");

  snr.compare_cases("Confirmed");

  snr.describe()
  ```

  Output of `snr.simulate(name="Predicted");`

  <img src="https://raw.githubusercontent.com/lisphilar/covid19-sir/main/example/output/demo_jpn/04_predicted.png" width="600">



  Tutorials of functionalities are included in the [CovsirPhy documentation](https://lisphilar.github.io/covid19-sir/index.html).

  * [Data preparation](https://lisphilar.github.io/covid19-sir/01_data_preparation.html)
  * [Data Engineering](https://lisphilar.github.io/covid19-sir/02_data_engineering.html)
  * [SIR-derived ODE models](https://lisphilar.github.io/covid19-sir/03_ode.html)
  * [Phase-dependent SIR models](https://lisphilar.github.io/covid19-sir/04_phase_dependent.html)
  * [Scenario analysis](https://lisphilar.github.io/covid19-sir/05_scenario_analysis.html)
  * [ODE parameter prediction](https://lisphilar.github.io/covid19-sir/06_prediction.html)



  Release notes are [here](https://github.com/lisphilar/covid19-sir/releases). Titles & links of issues are listed with acknowledgement.

  We can see the release plan for the next stable version in [milestone page of the GitHub repository](https://github.com/lisphilar/covid19-sir/milestones). If you find a highly urgent matter, please let us know via [issue page](https://github.com/lisphilar/covid19-sir/issues).



  CovsirPhy library is developed by a community of volunteers. Please see the full list [here](https://github.com/lisphilar/covid19-sir/graphs/contributors).

  This project started in Kaggle platform. Hirokazu Takaya ([@lisphilar](<https://www.kaggle.com/lisphilar>)) published [Kaggle Notebook: COVID-19 data with SIR model](https://www.kaggle.com/lisphilar/covid-19-data-with-sir-model) on 12Feb2020 and developed it, discussing with Kaggle community. On 07May2020, "covid19-sir" repository was created. On 10May2020, `covsirphy` version 1.0.0 was published in GitHub. The first release in PyPI (version 2.3.0) was on 28Jun2020. Many APIs were reviewed via 2.x series and version 3.0.0 was released on 12May2023.



  Please support this project as a developer (or a backer).
  [![Become a backer](https://opencollective.com/covsirphy/tiers/backer.svg?avatarHeight=36&width=600)](https://opencollective.com/covsirphy)



  Please refer to [LICENSE](https://github.com/lisphilar/covid19-sir/blob/master/LICENSE) file.



  Please cite this library as follows with version number (`import covsirphy as cs; cs.__version__`).

  **Hirokazu Takaya and CovsirPhy Development Team (2020-2024), CovsirPhy version [version number]: Python library for COVID-19 analysis with phase-dependent SIR-derived ODE models, [https://github.com/lisphilar/covid19-sir](https://github.com/lisphilar/covid19-sir)**

  This is the output of `covsirphy.__citation__`.

  ```Python
  import covsirphy as cs
  cs.__citation__
  ```

  **We have no original papers the author and contributors wrote, but note that some scientific approaches, including SIR-F model, S-R change point analysis, phase-dependent approach to SIR-derived models, were developed in this project.**


pkgId: 0c1c9762391bce747a1355516798d33f197221aeb2a80eee2347f9b757a8613d
name: python-covvfit
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/covvfit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-covvfit-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)
  [![build](https://github.com/cbg-ethz/covvfit/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/cbg-ethz/covvfit/actions/workflows/test.yml)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/charliermarsh/ruff)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  Fitness estimates of SARS-CoV-2 variants.

    - **Documentation:** [https://cbg-ethz.github.io/covvfit](https://cbg-ethz.github.io/covvfit)
    - **Source code:** [https://github.com/cbg-ethz/covvfit](https://github.com/cbg-ethz/covvfit)
    - **Bug reports:** [https://github.com/cbg-ethz/covvfit/issues](https://github.com/cbg-ethz/covvfit/issues)





  Create a new environment, e.g., using [Micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html):
  ```bash
  $ micromamba create -n covvfit -c conda-forge python=3.11
  ```

  Then, install the package.

  For a machine where development happens it comes with developer utilities:

  ```bash
  $ pip install poetry
  $ poetry install --with dev
  $ pre-commit install
  ```



    - [V-pipe](https://cbg-ethz.github.io/V-pipe/): a bioinformatics pipeline for viral sequencing data.
    - [cojac](https://github.com/cbg-ethz/cojac): command-line tools for the analysis of co-occurrence of mutations on amplicons.


pkgId: 0f40cdb8e98c1edaa956bf5069af77d8078cdb4ce47e2961bbd5b4d7fd643921
name: python-cow-csvw
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Integrated CSV to RDF converter, using CSVW and nanopublications
url: https://github.com/CLARIAH/COW
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cow-csvw-2.0.0-1.src.rpm
checksum_type: sha256
description:
  > CoW is a tool to convert a .csv file into Linked Data. Specifically, CoW is an integrated CSV to RDF converter using the W3C standard [CSVW](https://www.w3.org/TR/tabular-data-primer/) for rich semantic table specificatons, producing [nanopublications](http://nanopub.org/) as an output RDF model. CoW converts any CSV file into an RDF dataset.





  - Expressive CSVW-compatible schemas based on the [Jinja](https://github.com/pallets/jinja) template enginge.
  - Highly efficient implementation leveraging multithreaded and multicore architectures.
  - Available as a [Docker image](#docker-image), [command line interface (CLI) tool](command-line-interface), and [library](#library).


  For user documentation see the [basic introduction video](https://t.co/SDWC3NhWZf) and the  [GitHub wiki](https://github.com/clariah/cow/wiki/). [Technical details](#technical-details) are provided below. If you encounter an issue then please [report](https://github.com/CLARIAH/COW/issues/new/choose) it. Also feel free to create pull requests.



  There are two ways to run CoW. The quickest is via Docker, the more flexible via PIP.



  Several data science tools, including CoW, are available via a [Docker image](https://github.com/CLARIAH/datalegendtools).



  First, install the Docker virtualisation engine on your computer. Instructions on how to accomplish this can be found on the [official Docker website](https://docs.docker.com/get-docker). Use the following command in the Docker terminal:

  ```

  ```
  Here, the #-symbol refers to the terminal of a user with administrative privileges on your machine and is not part of the command.

  After the image has successfully been downloaded (or 'pulled'), the container can be run as follows:

  ```

  ```
  The virtual system can now be accessed by opening [http://localhost:3000/wetty](http://localhost:3000/wetty) in your preferred browser, and by logging in using username **datalegend** and password **datalegend**.

  For detailed instructions on this Docker image, see [DataLegend Playground](https://github.com/CLARIAH/datalegendtools). For instructions on how to use the tool, see  [usage](#usage) below.





  The Command Line Interface (CLI) is the recommended way of using CoW for most users.



  > Check whether the latest version of Python is installed on your device. For Windows/MacOS we recommend to install Python via the [official distribution page](https://www.python.org/downloads/).

  The recommended method of installing CoW on your system is `pip3`:

  ```
  pip3 install cow-csvw
  ```

  You can upgrade your currently installed version with:

  ```
  pip3 install cow-csvw --upgrade
  ```

  Possible installation issues:

  - Permission issues. You can get around them by installing CoW in user space: `pip3 install cow-csvw --user`.
  - Cannot find command: make sure your binary user directory (typically something like `/Users/user/Library/Python/3.7/bin` in MacOS or `/home/user/.local/bin` in Linux) is in your PATH (in MacOS: `/etc/paths`).
  - Please [report your unlisted issue](https://github.com/CLARIAH/CoW/issues/new).



  Start the graphical interface by entering the following command:

  ```
  cow_tool
  ```

  Select a CSV file and click `build` to generate a file named `myfile.csv-metadata.json` (JSON schema file) with your mappings. Edit this file (optional) and then click `convert` to convert the CSV file to RDF. The output should be a `myfile.csv.nq` RDF file (nquads by default).



  The straightforward CSV to RDF conversion is done by entering the following commands:

  ```
  cow_tool_cli build myfile.csv
  ```

  This will create a file named `myfile.csv-metadata.json` (JSON schema file). Next:

  ```
  cow_tool_cli convert myfile.csv
  ```
  This command will output a `myfile.csv.nq` RDF file (nquads by default).

  You don't need to worry about the JSON file, unless you want to change the metadata schema. To control the base URI namespace, URIs used in predicates, virtual columns, etcetera, edit the `myfile.csv-metadata.json` file and/or use CoW commands. For instance, you can control the output RDF serialization (with e.g. ``--format turtle``). Have a look at the [options](#options) below, the examples in the [GitHub wiki](https://github.com/CLARIAH/CoW/wiki), and the [technical documentation](http://csvw-converter.readthedocs.io/en/latest/).



  Check the ``--help`` for a complete list of options:

  ```
  usage: cow_tool_cli [-h] [--dataset DATASET] [--delimiter DELIMITER]
                      [--quotechar QUOTECHAR] [--encoding ENCODING] [--processes PROCESSES]
                      [--chunksize CHUNKSIZE] [--base BASE]
                      [--format [{xml,n3,turtle,nt,pretty-xml,trix,trig,nquads}]]
                      [--gzip] [--version]
                      {convert,build} file [file ...]

  Not nearly CSVW compliant schema builder and RDF converter

  positional arguments:
    {convert,build}       Use the schema of the `file` specified to convert it
                          to RDF, or build a schema from scratch.
    file                  Path(s) of the file(s) that should be used for
                          building or converting. Must be a CSV file.

  optional arguments:
    -h, --help            show this help message and exit
    --dataset DATASET     A short name (slug) for the name of the dataset (will
                          use input file name if not specified)
    --delimiter DELIMITER
                          The delimiter used in the CSV file(s)
    --quotechar QUOTECHAR
                          The character used as quotation character in the CSV
                          file(s)
    --encoding ENCODING   The character encoding used in the CSV file(s)

    --processes PROCESSES
                          The number of processes the converter should use
    --chunksize CHUNKSIZE
                          The number of rows processed at each time
    --base BASE           The base for URIs generated with the schema (only
                          relevant when `build`ing a schema)
    --gzip 				Compress the output file using gzip
    --format [{xml,n3,turtle,nt,pretty-xml,trix,trig,nquads}], -f [{xml,n3,turtle,nt,pretty-xml,trix,trig,nquads}]
                          RDF serialization format
    --version             show program's version number and exit
  ```





  Once installed, CoW can be used as a library as follows:

  ```
  from cow_csvw.csvw_tool import COW
  import os

  COW(mode='build', files=[os.path.join(path, filename)], dataset='My dataset', delimiter=';', quotechar='\"')

  COW(mode='convert', files=[os.path.join(path, filename)], dataset='My dataset', delimiter=';', quotechar='\"', processes=4, chunksize=100, base='http://example.org/my-dataset', format='turtle', gzipped=False)
  ```







  The [GitHub wiki](https://github.com/CLARIAH/COW/wiki) provides more hands-on examples of transposing CSVs into Linked Data.



  Technical documentation for CoW are maintained in this GitHub repository (under <docs>), and published through [Read the Docs](http://readthedocs.org) at <http://csvw-converter.readthedocs.io/en/latest/>.

  To build the documentation from source, change into the `docs` directory, and run `make html`. This should produce an HTML version of the documentation in the `_build/html` directory.



  MIT License (see [license.txt](license.txt))



  **Authors:**    Albert Meroño-Peñuela, Roderick van der Weerdt, Rinke Hoekstra, Kathrin Dentler, Auke Rijpma, Richard Zijdeman, Melvin Roest, Xander Wilcke

  **Copyright:**  Vrije Universiteit Amsterdam, Utrecht University, International Institute of Social History


  CoW is developed and maintained by the [CLARIAH project](https://www.clariah.nl) and funded by NWO.


pkgId: 7180a50c61ea28c0d11b0e412fdcda905077106ca6f5e296802fcab4f4ee6c37
name: python-cowgirl-ai-auto-code
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: Cowgirl AI - Auto Code
url: https://github.com/Cowgirl-AI/auto-code
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cowgirl-ai-auto-code-1.5.2-1.src.rpm
checksum_type: sha256
description:
  A programming CLI bot that digests Python files in a specified directory and updates them with refinements.



  To install the necessary packages, run:

  ```zsh
  pip install cowgirl-ai-core cowgirl-ai-utils cowgirl-ai-auto-code
  ```



  To refine Python files in the `src` directory, use the following command:

  ```zsh
  cowgirl-ai-auto-code refine src .py
  ```



  The "refine" command analyzes your code, suggesting improvements and optimizations to enhance readability, performance, and maintainability. It's like having a coding buddy who helps you clean up your code!



  This program is currently only compatible with OpenAI. We're looking into expanding compatibility with other open-source LLMs like Meta and Anthropic. Additionally, we're investigating the possibility of adding `.sql` refinements to the CLI tool. :)



  If you encounter issues while using the tool, consider the following:

  - Ensure that all required packages are installed correctly.
  - Check the file paths for any typos or incorrect directories.
  - Review the output logs for specific error messages that can guide you.


pkgId: 6dae56212e750a50273461dd7554a480137b631cc7601944bd12cb7423d59487
name: python-cowsay
arch: src
version: 6.1
epoch: 0
release: 1
summary: The famous cowsay for GNU/Linux is now available for python
url: https://github.com/VaasuDevanS/cowsay-python
rpm_license: GNU-GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cowsay-6.1-1.src.rpm
checksum_type: sha256
description:
             \
              \
                ^__^
                (oo)\_______
                (__)\       )\/\
                    ||----w |
                    ||     ||
  >>> print(cowsay.get_output_string('cow', 'Hello World'))
    ___________


pkgId: a4727f1277dc9d02f8f66f8e4858089ce3f4c3bdf0ad35d7416a70c54856c2c2
name: python-coxbuild
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: A tiny build automation tool.
url: https://github.com/StardustDL/coxbuild
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coxbuild-0.1.6-1.src.rpm
checksum_type: sha256
description:
  ![](https://socialify.git.ci/StardustDL/coxbuild/image?description=1&font=Bitter&forks=1&issues=1&language=1&owner=1&pulls=1&stargazers=1&theme=Light)

  [![](https://github.com/StardustDL/coxbuild/workflows/CI/badge.svg)](https://github.com/StardustDL/coxbuild/actions) [![](https://img.shields.io/github/license/StardustDL/coxbuild.svg)](https://github.com/StardustDL/coxbuild/blob/master/LICENSE) [![](https://img.shields.io/pypi/v/coxbuild)](https://pypi.org/project/coxbuild/) [![Downloads](https://pepy.tech/badge/coxbuild?style=flat-square)](https://pepy.tech/project/coxbuild) [![](https://data.jsdelivr.com/v1/package/gh/StardustDL/coxbuild/badge?style=rounded)](https://www.jsdelivr.com/package/gh/StardustDL/coxbuild)

  Coxbuild is a tiny python-script-based build automation tool, an alternative to make, psake and so on.

  > [Documents](https://stardustdl.github.io/coxbuild/)

  > [References](https://stardustdl.github.io/coxbuild/api/)

  > [Test Coverage Report](https://stardustdl.github.io/coxbuild/cov/)

  > [Extension Gallery](https://github.com/StardustDL/coxbuild-ext-gallery/)

  ![](https://raw.githubusercontent.com/StardustDL/coxbuild/master/docs/assets/images/demo.gif)

  Supported features:

  - Task
  - Dependency
  - Pre / Post condition
  - Lifecycle hooks
    - Setup / Teardown
    - Before / After
  - Event-based build as a long-run service
  - Multiple schema sources
    - File `file://`
    - Url `url://`
    - Source code `src://`
    - Module `mod://`
    - Gallery `ext://`

  Extensions:

  - Python
  - Shell
  - Git
  - Node.js
  - .NET
  - Gradle



  ```sh
  pip install coxbuild
  ```



  ```sh


  coxbuild --version



  cb -u https://raw.githubusercontent.com/StardustDL/coxbuild/master/demo/hello.py

  cb -e hello



  cb -u https://cdn.jsdelivr.net/gh/StardustDL/coxbuild@master/demo/lifecycle.py



  cb -u https://cdn.jsdelivr.net/gh/StardustDL/coxbuild@master/demo/event.py



  cb -i src://interative
  ```



  > Coxbuild build itself by itself, see [here](https://github.com/StardustDL/coxbuild/blob/master/buildcox.py) for details.

  1. Write Schema (buildcox.py)

  ```python
  @task
  def pre():
      print("pre task")

  @depend(pre)
  @task
  def default():
      pass
  ```

  2. Run

  ```sh
  coxbuild



  cb
  ```



  We provide a few extensions with coxbuild release package, in `coxbuild.extensions` module. We also provide a gallery of extensions in [exts](https://github.com/StardustDL/coxbuild-ext-gallery/).

  > Visit [here](https://stardustdl.github.io/coxbuild/#/extensions/README) for more details.


pkgId: 688463ea3a4aac81ed6d250258fd14f2d6b762386bdfa7d092b4436644ba0831
name: python-cozepy
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: OpenAPI SDK for Coze(coze.com/coze.cn)
url: https://pypi.org/project/cozepy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cozepy-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/cozepy.svg)](https://pypi.org/project/cozepy/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/cozepy)
  [![codecov](https://codecov.io/github/coze-dev/coze-py/graph/badge.svg?token=U6OKGQXF0E)](https://codecov.io/github/coze-dev/coze-py)



  The Coze API SDK for Python is a versatile tool for integrating Coze's open APIs into
  your projects.

  - Supports all Coze open APIs and authentication APIs
  - Supports both synchronous and asynchronous SDK calls
  - Optimized for streaming apis, returning Stream and AsyncStream objects
  - Optimized for list apis, returning Iterator Page objects
  - Features a simple and user-friendly API design for ease of use



  Python 3.7 or higher.



  ```shell
  pip install cozepy
  ```





  | Example                      | File                                                                         |
  |------------------------------|------------------------------------------------------------------------------|
  | pat auth                     | [examples/auth_pat.py](examples/auth_pat.py)                                 |
  | oauth by web code            | [examples/auth_oauth_web.py](examples/auth_oauth_web.py)                     |
  | oauth by jwt flow            | [examples/auth_oauth_jwt.py](examples/auth_oauth_jwt.py)                     |
  | oauth by pkce flow           | [examples/auth_oauth_pkce.py](examples/auth_oauth_pkce.py)                   |
  | oauth by device flow         | [examples/auth_oauth_device.py](examples/auth_oauth_device.py)               |
  | bot create, publish and chat | [examples/bot_publish.py](examples/bot_publish.py)                           |
  | non-stream chat              | [examples/chat_no_stream.py](examples/chat_no_stream.py)                     |
  | steam chat                   | [examples/chat_stream.py](examples/chat_stream.py)                           |
  | chat with conversation       | [examples/chat_conversation_stream.py](examples/chat_conversation_stream.py) |
  | chat with local plugin       | [examples/chat_local_plugin.py](examples/chat_local_plugin.py)               |
  | chat with image              | [examples/chat_multimodal_stream.py](examples/chat_multimode_stream.py)      |
  | chat with audio              | [examples/chat_audio.py](examples/chat_audio.py)                             |
  | non-stream workflow chat     | [examples/workflow_no_stream.py](examples/workflow_no_stream.py)             |
  | stream workflow chat         | [examples/workflow_stream.py](examples/workflow_stream.py)                   |
  | async workflow run           | [examples/workflow_async.py](examples/workflow_async.py)                     |
  | conversation                 | [examples/conversation.py](examples/conversation.py)                         |
  | workspace                    | [examples/workspace.py](examples/workspace.py)                               |
  | timeout config               | [examples/timeout.py](examples/timeout.py)                                   |
  | setup coze log config        | [examples/log.py](examples/log.py)                                           |
  | how to handle exception      | [examples/exception.py](examples/exception.py)                               |



  Firstly, you need to access https://www.coze.com/open/oauth/pats (for the cn environment,
  visit https://www.coze.cn/open/oauth/pats).

  Click to add a new token. After setting the
  appropriate name, expiration time, and permissions, click OK to generate your personal
  access token.

  Please store it in a secure environment to prevent this personal access
  token from being disclosed.

  ```python
  import os

  from cozepy import Coze, TokenAuth, COZE_COM_BASE_URL


  coze_api_token = os.getenv("COZE_API_TOKEN")


  coze_api_base = os.getenv("COZE_API_BASE") or COZE_COM_BASE_URL

  coze = Coze(auth=TokenAuth(coze_api_token), base_url=coze_api_base)
  ```

  coze api access_token can also be generated via the OAuth App. For details, refer to:

  - [web-oauth-app](https://github.com/coze-dev/coze-py?tab=readme-ov-file#web-oauth-app)
  - [jwt-oauth-app](https://github.com/coze-dev/coze-py?tab=readme-ov-file#jwt-oauth-app)
  - [pkce-oauth-app](https://github.com/coze-dev/coze-py?tab=readme-ov-file#pkce-oauth-app)
  - [device-oauth-app](https://github.com/coze-dev/coze-py?tab=readme-ov-file#device-oauth-app)



  Create a bot instance in Coze, copy the last number from the web link as the bot's ID.



  To simplify the call, the SDK provides a wrapped function to complete non-streaming chat,
  polling, and obtaining the messages of the chat. Developers can use create_and_poll to
  simplify the process.

  ```python
  import os

  from cozepy import Coze, TokenAuth, Message, ChatStatus

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))

  chat_poll = coze.chat.create_and_poll(
      
      bot_id='bot_id',
      
      
      user_id='user_id',
      
      additional_messages=[Message.build_user_question_text("How are you?")]
  )
  for message in chat_poll.messages:
      print(message.content, end="")

  if chat_poll.chat.status == ChatStatus.COMPLETED:
      print()
      print("token usage:", chat_poll.chat.usage.token_count)
  ```



  Call the coze.chat.stream method to create a chat. The create method is a streaming
  chat and will return a Chat Iterator. Developers should iterate the iterator to get
  chat event and handle them.

  ```python
  import os

  from cozepy import Coze, TokenAuth, Message, ChatEventType

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  for event in coze.chat.stream(
          
          bot_id='bot_id',
          
          
          user_id='user_id',
          
          additional_messages=[Message.build_user_question_text("How are you?")]
  ):
      if event.event == ChatEventType.CONVERSATION_MESSAGE_DELTA:
          print(event.message.content, end="")

      if event.event == ChatEventType.CONVERSATION_CHAT_COMPLETED:
          print()
          print("token usage:", event.chat.usage.token_count)
  ```



  You can create, update, publish and get the list of bots via api.

  ```python
  import os
  from cozepy import Coze, TokenAuth

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  bot = coze.bots.retrieve(bot_id='bot id')




  bots_page = coze.bots.list(space_id='workspace id', page_num=1)
  bots = bots_page.items


  bot = coze.bots.create(
      
      
      space_id='workspace id',
      
      name='bot name',
      
      description='bot description',
  )


  coze.bots.update(
      
      bot_id='bot id',
      
      name='bot name',
      
      description='bot description',
  )


  bot = coze.bots.publish(bot_id='bot id')
  ```



  Users can create conversations, and conduct conversations, inquire about messages,
  etc. on conversations.

  ```python
  import os
  from cozepy import Coze, TokenAuth, Message, MessageContentType

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))



  conversation = coze.conversations.create(
      messages=[
          
          Message.build_user_question_text('who are you?'),
          
          Message.build_assistant_answer('I am Coze Bot.')
      ],
  )


  conversation = coze.conversations.retrieve(conversation_id=conversation.id)


  message = coze.conversations.messages.create(
      
      conversation_id=conversation.id,
      content='how are you?',
      content_type=MessageContentType.TEXT,
  )


  message = coze.conversations.messages.retrieve(conversation_id=conversation.id, message_id=message.id)


  coze.conversations.messages.update(
      conversation_id=conversation.id,
      message_id=message.id,
      content='hey, how are you?',
      content_type=MessageContentType.TEXT,
  )


  coze.conversations.messages.delete(conversation_id=conversation.id, message_id=message.id)


  message_list = coze.conversations.messages.list(conversation_id=conversation.id)
  ```



  Coze enables users to upload pictures and files. The uploaded pictures and files
  can be utilized in the bot avatar and multimodal conversations.

  ```python
  import os
  from pathlib import Path
  from cozepy import Coze, TokenAuth

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  file = coze.files.upload(file=Path('/filepath'))


  coze.files.retrieve(file_id=file.id)
  ```



  Coze also enables users to directly invoke the workflow.



  ```python
  import os
  from cozepy import Coze, TokenAuth, Stream, WorkflowEvent, WorkflowEventType

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))

  result = coze.workflows.runs.create(
      
      workflow_id='workflow id',
      
      parameters={
          'input_key': 'input value',
      }
  )
  ```



  The returned result of the streaming interface is an iterator and can be directly iterated.

  When the workflow incorporates question-and-answer nodes, the streaming interface will
  return the INTERRUPT event.

  Users should call the resume interface to submit the results of the question-and-answer.

  The return value of resume remains an iterator, so recursive processing might be necessary here.

  ```python
  import os

  from cozepy import Coze, TokenAuth, Stream, WorkflowEvent, WorkflowEventType

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  def handle_workflow_iterator(stream: Stream[WorkflowEvent]):
      for event in stream:
          if event.event == WorkflowEventType.MESSAGE:
              print('got message', event.message)
          elif event.event == WorkflowEventType.ERROR:
              print('got error', event.error)
          elif event.event == WorkflowEventType.INTERRUPT:
              
              handle_workflow_iterator(coze.workflows.runs.resume(
                  workflow_id='workflow id',
                  event_id=event.interrupt.interrupt_data.event_id,
                  resume_data='hey',
                  interrupt_type=event.interrupt.interrupt_data.type,
              ))


  handle_workflow_iterator(coze.workflows.runs.stream(
      
      workflow_id='workflow id',
      
      parameters={
          'input_key': 'input value',
      }
  ))
  ```



  ```python
  import os
  from cozepy import Coze, TokenAuth, DocumentBase, DocumentSourceInfo, DocumentChunkStrategy, DocumentUpdateRule

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  documents = coze.knowledge.documents.create(
      
      dataset_id='dataset id',
      
      document_bases=[
          DocumentBase(
              name='document name',
              source_info=DocumentSourceInfo.build_local_file('local file content')
          )
      ],
      
      chunk_strategy=DocumentChunkStrategy.build_auto()
  )


  documents = coze.knowledge.documents.create(
      
      dataset_id='dataset id',
      
      document_bases=[
          DocumentBase(
              name='document name',
              source_info=DocumentSourceInfo.build_web_page('https://example.com')
          )
      ],
      
      chunk_strategy=DocumentChunkStrategy.build_auto()
  )


  coze.knowledge.documents.update(
      
      document_id='document id',
      
      document_name='name',
      
      update_rule=DocumentUpdateRule.build_no_auto_update()
  )


  coze.knowledge.documents.delete(document_ids=['document id'])


  paged_documents = coze.knowledge.documents.list(
      
      dataset_id='dataset id',
      page_num=1,
      page_size=10
  )
  ```





  Firstly, users need to access https://www.coze.com/open/oauth/apps. For the cn environment,
  users need to access https://www.coze.cn/open/oauth/apps to create an OAuth App of the type
  of Web application.

  The specific creation process can be referred to in the document:
  https://www.coze.com/docs/developer_guides/oauth_code. For the cn environment, it can be
  accessed at https://www.coze.cn/docs/developer_guides/oauth_code.

  After the creation is completed, three parameters, namely the client ID, client secret,
  and redirect link, can be obtained. For the client secret, users need to keep it securely
  to avoid leakage.

  ```python
  import os
  from cozepy import Coze, TokenAuth, WebOAuthApp


  web_oauth_client_id = os.getenv("COZE_WEB_OAUTH_CLIENT_ID")

  web_oauth_client_secret = os.getenv("COZE_WEB_OAUTH_CLIENT_SECRET")

  web_oauth_app = WebOAuthApp(
      client_id=web_oauth_client_id,
      client_secret=web_oauth_client_secret,
  )
  ```

  The WebOAuth authorization process is to first generate a coze authorization link and
  send it to the coze user requiring authorization.

  Once the coze user opens the link, they can see the authorization consent button.

  ```python

  web_oauth_redirect_uri = os.getenv("COZE_WEB_OAUTH_REDIRECT_URI")


  url = web_oauth_app.get_oauth_url(redirect_uri=web_oauth_redirect_uri)
  ```

  After the user clicks the authorization consent button, the coze web page will redirect
  to the redirect address configured in the authorization link and carry the authorization
  code and state parameters in the address via the query string.

  ```python



  code = 'mock code'



  oauth_token = web_oauth_app.get_access_token(redirect_uri=web_oauth_redirect_uri, code=code)


  coze = Coze(auth=TokenAuth(oauth_token.access_token))


  oauth_token = web_oauth_app.refresh_access_token(oauth_token.refresh_token)
  ```



  Firstly, users need to access https://www.coze.com/open/oauth/apps. For the cn environment,
  users need to access https://www.coze.cn/open/oauth/apps to create an OAuth App of the type
  of Service application.

  The specific creation process can be referred to in the document:
  https://www.coze.com/docs/developer_guides/oauth_jwt. For the cn environment, it can be
  accessed at https://www.coze.cn/docs/developer_guides/oauth_jwt.

  After the creation is completed, three parameters, namely the client ID, private key,
  and public key id, can be obtained. For the client secret and public key id, users need to
  keep it securely to avoid leakage.

  ```python
  import os
  from cozepy import Coze, TokenAuth, JWTOAuthApp


  jwt_oauth_client_id = os.getenv("COZE_JWT_OAUTH_CLIENT_ID")

  jwt_oauth_private_key = os.getenv("COZE_JWT_OAUTH_PRIVATE_KEY")

  jwt_oauth_public_key_id = os.getenv("COZE_JWT_OAUTH_PUBLIC_KEY_ID")

  jwt_oauth_app = JWTOAuthApp(
      client_id=jwt_oauth_client_id,
      private_key=jwt_oauth_private_key,
      public_key_id=jwt_oauth_public_key_id,
  )
  ```

  The jwt oauth type requires using private to be able to issue a jwt token, and through
  the jwt token, apply for an access_token from the coze service.

  The sdk encapsulates this procedure, and only needs to use get_access_token to obtain
  the access_token under the jwt oauth process.

  ```python

  oauth_token = jwt_oauth_app.get_access_token(ttl=3600)


  coze = Coze(auth=TokenAuth(oauth_token.access_token))



  ```



  PKCE stands for Proof Key for Code Exchange, and it's an extension to the OAuth 2.0 authorization
  code flow designed to enhance security for public clients, such as mobile and single-page
  applications.

  Firstly, users need to access https://www.coze.com/open/oauth/apps. For the cn environment,
  users need to access https://www.coze.cn/open/oauth/apps to create an OAuth App of the type
  of Mobile/PC/Single-page application.

  The specific creation process can be referred to in the document:
  https://www.coze.com/docs/developer_guides/oauth_pkce. For the cn environment, it can be
  accessed at https://www.coze.cn/docs/developer_guides/oauth_pkce.

  After the creation is completed, three parameters, namely the client ID can be obtained.

  ```python
  import os

  from cozepy import PKCEOAuthApp


  pkce_oauth_client_id = os.getenv("COZE_PKCE_OAUTH_CLIENT_ID")

  web_oauth_redirect_uri = os.getenv("COZE_WEB_OAUTH_REDIRECT_URI")

  pkce_oauth_app = PKCEOAuthApp(client_id=pkce_oauth_client_id)
  ```

  In the pkce oauth process, first, need to select a suitable code_challenge_method.
  Coze supports two types: plain and s256.

  Then, based on the selected code_challenge_method type, hash the code_verifier into
  the code_challenge. Finally, based on the callback address,
  code_challenge, and code_challenge_method, an authorization link can be generated.

  ```python


  code_verifier = "random code verifier"
  url = pkce_oauth_app.get_oauth_url(
      redirect_uri=web_oauth_redirect_uri,
      code_verifier=code_verifier,
      code_challenge_method="S256"
  )
  ```

  Developers should lead users to open up this authorization link.

  When the user consents to the authorization, Coze will redirect with the code to the
  callback address configured by the developer, and the developer can obtain this code.

  ```python


  code = 'mock code'



  oauth_token = pkce_oauth_app.get_access_token(
      redirect_uri=web_oauth_redirect_uri, code=code, code_verifier=code_verifier
  )


  coze = Coze(auth=TokenAuth(oauth_token.access_token))


  oauth_token = pkce_oauth_app.refresh_access_token(oauth_token.refresh_token)
  ```



  The OAuth 2.0 device flow, also known as the device authorization grant, is an extension to t
  e OAuth 2.0 protocol designed for devices that have limited input capabilities or lack a suitable
  browser.

  Firstly, users need to access https://www.coze.com/open/oauth/apps. For the cn environment,
  users need to access https://www.coze.cn/open/oauth/apps to create an OAuth App of the type
  of TVs/Limited Input devices/Command line programs.

  The specific creation process can be referred to in the document:
  https://www.coze.com/docs/developer_guides/oauth_device_code. For the cn environment, it can be
  accessed at https://www.coze.cn/docs/developer_guides/oauth_device_code.

  After the creation is completed, three parameters, namely the client ID can be obtained.

  ```python
  import os
  from cozepy import Coze, TokenAuth, DeviceOAuthApp


  device_oauth_client_id = os.getenv("COZE_DEVICE_OAUTH_CLIENT_ID")

  device_oauth_app = DeviceOAuthApp(client_id=device_oauth_client_id)
  ```

  In the device oauth authorization process, developers need to first call the interface
  of Coze to generate the device code to obtain the user_code and device_code.

  Then generate the authorization link through the user_code, guide the user to open the
  link, fill in the user_code, and consent to the authorization.

  Developers need to call the interface of Coze to generate the token through the device_code.

  When the user has not authorized or rejected the authorization, the interface will throw an
  error and return a specific error code.

  After the user consents to the authorization, the interface will succeed and return the
  access_token.

  ```python

  device_code = device_oauth_app.get_device_code()




  ```

  The developers then need to use the device_code to poll Coze's interface to obtain the token.

  The SDK has encapsulated this part of the code in and handled the different returned error
  codes. The developers only need to invoke get_access_token.

  ```python
  try:
      oauth_token = device_oauth_app.get_access_token(
          device_code=device_code.device_code,
          poll=True,
      )
  except CozePKCEAuthError as e:
      if e.error == CozePKCEAuthErrorType.ACCESS_DENIED:
          
          
          pass
      elif e.error == CozePKCEAuthErrorType.EXPIRED_TOKEN:
          
          
          pass
      else:
          
          pass

      raise  # for example, re-raise the error


  coze = Coze(auth=TokenAuth(oauth_token.access_token))


  oauth_token = device_oauth_app.refresh_access_token(oauth_token.refresh_token)
  ```



  cozepy supports asynchronous calls through `httpx.AsyncClient`.

  Just replace the `Coze` client with the `AsyncCoze` client to use all the asynchronous calls of the Coze OpenAPI.

  ```python
  import os
  import asyncio

  from cozepy import TokenAuth, Message, AsyncCoze

  coze = AsyncCoze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  async def main() -> None:
      chat = await coze.chat.create(
          bot_id='bot id',
          
          user_id='user id',
          additional_messages=[
              Message.build_user_question_text('how are you?'),
              Message.build_assistant_answer('I am fine, thank you.')
          ],
      )
      print('chat', chat)


  asyncio.run(main())
  ```



  Bot chat and workflow run support running in streaming mode.

  chat streaming example:

  ```python
  import os
  from cozepy import Coze, TokenAuth, ChatEventType, Message

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))

  stream = coze.chat.stream(
      bot_id='bot id',
      
      
      user_id='user id',
      additional_messages=[
          Message.build_user_question_text('how are you?'),
          Message.build_assistant_answer('I am fine, thank you.')
      ],
  )
  for event in stream:
      if event.event == ChatEventType.CONVERSATION_MESSAGE_DELTA:
          print('got message delta:', event.message.content)
  ```

  workflow streaming example:

  ```python
  import os
  from cozepy import Coze, TokenAuth, Stream, WorkflowEvent, WorkflowEventType

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  def handle_workflow_iterator(stream: Stream[WorkflowEvent]):
      for event in stream:
          if event.event == WorkflowEventType.MESSAGE:
              print('got message', event.message)
          elif event.event == WorkflowEventType.ERROR:
              print('got error', event.error)
          elif event.event == WorkflowEventType.INTERRUPT:
              handle_workflow_iterator(coze.workflows.runs.resume(
                  workflow_id='workflow id',
                  event_id=event.interrupt.interrupt_data.event_id,
                  resume_data='hey',
                  interrupt_type=event.interrupt.interrupt_data.type,
              ))


  handle_workflow_iterator(coze.workflows.runs.stream(
      workflow_id='workflow id',
      parameters={
          'input_key': 'input value',
      }
  ))
  ```

  Asynchronous calls also support streaming mode:

  ```python
  import os
  import asyncio

  from cozepy import TokenAuth, ChatEventType, Message, AsyncCoze

  coze = AsyncCoze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  async def main():
      stream = coze.chat.stream(
          bot_id='bot id',
          
          
          user_id='user id',
          additional_messages=[
              Message.build_user_question_text('how are you?'),
              Message.build_assistant_answer('I am fine, thank you.')
          ],
      )
      async for event in stream:
          if event.event == ChatEventType.CONVERSATION_MESSAGE_DELTA:
              print('got message delta:', event.message.content)


  asyncio.run(main())
  ```



  The result returned by all list interfaces (both synchronous and asynchronous) is a paginator, which supports iteration.

  Take the example of listing the bots in a space to explain the three ways to use the paginator iterator:



  ```python
  import os
  from cozepy import Coze, TokenAuth

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))



  bots_page = coze.bots.list(space_id='workspace id', page_size=10)
  bots = bots_page.items
  total = bots_page.total
  has_more = bots_page.has_more
  ```



  ```python
  import os
  from cozepy import Coze, TokenAuth

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))



  bots_page = coze.bots.list(space_id='workspace id', page_size=10)
  for bot in bots_page:
      print('got bot:', bot)
  ```

  Asynchronous methods also support:

  ```python
  import os
  import asyncio

  from cozepy import TokenAuth, AsyncCoze

  coze = AsyncCoze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  async def main():
      
      
      bots_page = await coze.bots.list(space_id='workspace id', page_size=10)
      async for bot in bots_page:
          print('got bot:', bot)


  asyncio.run(main())
  ```



  ```python
  import os
  from cozepy import Coze, TokenAuth

  coze = Coze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))



  bots_page = coze.bots.list(space_id='workspace id', page_size=10)
  for page in bots_page.iter_pages():
      print('got page:', page.page_num)
      for bot in page.items:
          print('got bot:', bot)
  ```

  Asynchronous methods also support:

  ```python
  import asyncio
  import os

  from cozepy import TokenAuth, AsyncCoze

  coze = AsyncCoze(auth=TokenAuth(os.getenv("COZE_API_TOKEN")))


  async def main():
      
      
      bots_page = await coze.bots.list(space_id='workspace id', page_size=10)
      async for page in bots_page.iter_pages():
          print('got page:', page.page_num)
          for bot in page.items:
              print('got bot:', bot)


  asyncio.run(main())
  ```





  coze support config logging level

  ```python
  import logging

  from cozepy import setup_logging


  setup_logging(level=logging.DEBUG)
  ```



  Coze client is built on httpx, and supports passing a custom httpx.Client when initializing
  Coze, and setting a timeout on the httpx.Client

  ```python
  import os

  import httpx

  from cozepy import COZE_COM_BASE_URL, Coze, TokenAuth, SyncHTTPClient



  http_client = SyncHTTPClient(timeout=httpx.Timeout(
      
      timeout=600.0,
      
      connect=5.0
  ))


  coze = Coze(auth=TokenAuth(token=os.getenv("COZE_API_TOKEN")),
              base_url=COZE_COM_BASE_URL,
              http_client=http_client
              )
  ```


pkgId: 7659a4c65d5989c8fc0b79847e91eb9cb2241d67ee8fe1a5088f597058001ad6
name: python-cozify
arch: src
version: 0.2.36
epoch: 0
release: 1
summary: Unofficial Python3 API bindings for the (unpublished) Cozify API.
url: https://github.com/Artanicus/python-cozify
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cozify-0.2.36-1.src.rpm
checksum_type: sha256
description:
  |docs| |ci| |coverage| |pyversions| |gitter|
  Unofficial Python3 API bindings for the (unpublished) Cozify API.
  Includes high-level helpers for easier use of the APIs,
  for example an automatic authentication flow, and low-level 1:1 API functions.


pkgId: 7a95be45f01afd0a244e5283cbb438edd362fe9a98861e758e22782bfa8dd607
name: python-cozy-re
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: The Cozy Comparative Symbolic Evaluation Engine
url: https://github.com/draperlaboratory/cozy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cozy-re-1.5.2-1.src.rpm
checksum_type: sha256
description:
  cozy is a symbolic execution framework built around angr to enable comparative evaluation.
  The goal of comparative evaluation is to determine the precise changes made by software
  patches, specifically micropatches. cozy is capable of reporting observable changes
  made by a micropatch, specifically to registers, memory and stdout/stderr. The framework
  has the ability to present the behavioral changes caused by a patch in both a textual
  human-readable report and via a browser based rich user interface.



  https://github.com/user-attachments/assets/2e72575f-0074-44a9-8412-2b17839b7b71





  cozy is now available as a Python package on PyPI under the name `cozy-re`.
  Install with pip via the following command:

  ```commandline
  pip install cozy-re
  ```



  The getting started guide and API reference can be found on our Github pages!:

  https://draperlaboratory.github.io/cozy/



  cozy now comes with a Python script template generator to help you get started
  with using the framework.  To run the generator, install cozy, then run the
  following command in the console:

  ```commandline
  python3 -m cozy
  ```

  The wizard will then prompt you with a series of questions and generate the
  appropriate file with starter code. You'll need to provide:

  1. a filename for your templated script,
  2. the paths to the pre and postpatched binaries you wish to compare,
  3. the name or address of the function where symbolic execution will begin,
  4. the signature of that function (e.g. `int main(int argc, char* argv[])`)
  5. a choice of whether to use
     [concolic](https://draperlaboratory.github.io/cozy/concolic.html) execution,
     and—if conconlic is used—whether or not to explore the space of program
     states,
  6. a choice of whether to use any additional custom
     [hooks](https://draperlaboratory.github.io/cozy/hooks.html) (choosing "yes"
     will insert a stub for writing hooks into your cozy script but you'll want
     to write the hooks yourself),
  7. a choice of whether to to request output in the form of a textual report or
     by launching the visualization server, and
  8. a choice of whether to save the output in a JSON file which can be loaded
     into the visualizer in the future.

  Afterwards, the cozy script will be written to the filename you supplied, for
  example `my_script.py`. The cozy analysis can then be run, perhaps after some
  modification to the script (like supplying some custom hooks), using `python
  my_script.py`.

  https://github.com/draperlaboratory/cozy/assets/53128179/ee1edf4d-4905-425c-9675-fe110bac7376



  cozy is being developed by Draper Laboratory under the [DARPA Assured
  Micropatching (AMP)
  program](https://www.darpa.mil/program/assured-micropatching).



  The following sections are for the case where you want to use cozy directly
  from the source code in this repository, not from the `cozy-re` PyPI package.



  To get started with building cozy, run the following commands in the project
  root folder to create a virtual environment and install angr:

  ```commandline
  python3 -m venv venv
  source venv/bin/activate
  pip3 install angr sphinx sphinx-autoapi networkx claripy portion textual
  ```

  Alternatively, if you have `nix` installed and flakes enabled, run

  ```commandline
  nix develop
  ```

  To enter a nix development shell with `cozy` and its dependencies available on
  `$PYTHONPATH`.



  To run an example comparison, run one of the example scripts. In the root
  directory, run the following commands:

  ```commandline
  source venv/bin/activate
  export PYTHONPATH="${PYTHONPATH}:$PWD"
  python3 examples/cmp_null_deref.py
  ```

  Or just `python3 examples/cmp_null_deref.py` if you're in the nix development
  shell.

  If nix is available, then to run the full suite of tests used in CI, you can
  run:

  ```commandline
  nix build .#tests
  ```



  Building the docs requires the use of sphinx and sphinx-autoapi, which you
  should have previously installed via pip3. To build fresh HTML docs, run the
  following:

  ```commandline
  source venv/bin/activate
  cd docs
  make html
  ```

  The output documents should be stored in docs/build/html



  This section is mostly for the cozy developers to remind us how to push to PyPI. See the page here for a more
  advanced tutorial: https://packaging.python.org/en/latest/tutorials/packaging-projects/. Run the following commands to
  push to PyPI:

  ```
  pip3 install build

  pip3 install --upgrade twine

  python3 -m build


  python3 -m twine upload dist/cozy_re-1.5.0*

  ```


pkgId: 05160ecfef6d0e1bf612df814f559c159585a38fda5eb30e9becec2b2bdc67b2
name: python-cp-mgmt-api-sdk
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Check Point Management API SDK
url: https://github.com/CheckPointSW/cp_mgmt_api_python_sdk.git
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cp-mgmt-api-sdk-1.8.0-1.src.rpm
checksum_type: sha256
description:
  Check Point API Python Development Kit simplifies the usage of the Check Point Management APIs. The kit contains the API library project, and sample projects demonstrating the capabilities of the library. The kit is python 2 and 3 compatible code.


pkgId: 17099df241ef3bd4c976f17ce989259dcde61f89fe4e991bcb7ab089cd85d59c
name: python-cp-template
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A tool to copy templated directories
url: https://github.com/breuleux/cp-template
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cp-template-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This is a very simple utility to generate directories based on templates.





  ```bash
  pip install cp-template
  ```




  ```
  cp-template TEMPLATE_PATH DESTINATION_PATH key=value ...
  ```


  Suppose you have the following directory structure (**Note: the {{}}s are part of the filenames**)

  ```
  {{project}}/
    .gitignore
    README.md        # File contains "{{project}} by {{author}}"
    {{project}}/
      __init__.py
  ```

  Then you can run the following command:

  ```
  cp-template './{{project}}' pineapple author=me
  ```

  And it will generate this in the current directory:

  ```
  pineapple/
    .gitignore
    README.md        # File contains "pineapple by me"
    pineapple/
      __init__.py
  ```

  The template directory does not have to contain `{{...}}`. If it does not, the stem of the destination path (last part of the path minus the extension) is placed in the `STEM` variable, so you can refer to it in the files using `{{STEM}}`.

  More features will be added as I need them, but feel free to make PRs to contribute some.


pkgId: c862d6c27938ceebdd9808250a5d0367601b07b34a5eeb963ab5f7bee49e578d
name: python-cp210x-scanner
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cp210x-scanner/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cp210x-scanner-0.0.1-1.src.rpm
checksum_type: sha256
description:
  *Python scanner for CP210x devices wrapping Manufacturing DLL*

  - [Summary](#summary)
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install cp210x-scanner
  ```

  `cp210x-scanner` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 9c495aa2f59884a5d0b8a03622368d8ed4b551f67ff2bfa65da89b387f660f19
name: python-cpacspy
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: PyPI package to work with CPACS file and AeroMaps
url: https://github.com/cfsengineering/cpacspy
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpacspy-0.1.8-1.src.rpm
checksum_type: sha256
description:
  [![Pypi version](https://img.shields.io/pypi/v/cpacspy.svg)](https://pypi.python.org/pypi/cpacspy)
  [![Pytest status](https://github.com/cfsengineering/cpacspy/actions/workflows/ubuntu.yml/badge.svg?branch=main)](https://github.com/cfsengineering/cpacspy/actions/workflows/ubuntu.yml)
  [![Codecov](https://codecov.io/gh/cfsengineering/cpacspy/branch/main/graph/badge.svg?token=PFRCEGRL4N)](https://codecov.io/gh/cfsengineering/cpacspy)
  [![License](https://img.shields.io/badge/license-Apache%202-blue.svg)](https://github.com/cfsengineering/cpacspy/blob/main/LICENSE.txt)
  [![Black code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  <img align="right" width="250" height="250" src="logo/logo_white_bg.png">

  `cpacspy` is a Python package which could be used to read, write and analyse [CPACS](https://www.cpacs.de/) aerodynamics data. It simplify the handling of AeroMaps.

  CPACS is a *Common Parametric Aircraft Configuration Schema*. It is a data definition for the air transportation system which is developed by the German Aerospace Center [DLR](https://www.dlr.de/). CPACS enables engineers to exchange information between their tools.

  AeroMaps contains aerodynamic coefficients and derivatives for a specific set of aerodynamic and configurative boundary conditions.



  `cpacspy` depend mainly in DLR libraries [TIXI](https://github.com/DLR-SC/tixi) and [TIGL](https://github.com/DLR-SC/tigl), they must be installed on your computer to use `cpacspy`. The easiest way to do so, is to use a Conda environment, to create one:

  - Install [Anaconda](https://anaconda.org/) or [Miniconda](https://docs.conda.io/en/latest/miniconda.html) if you don't already have one of them installed.

  - Clone this repository and create a Conda environment with the following commands:

  ```bash
  git clone https://github.com/cfsengineering/cpacspy.git
  cd cpacspy
  conda env create -f environment.yml
  conda activate cpacspy_env
  ```

  - When it is done or if you already have TIXI and TIGL install on your computer:

  ```bash
  pip install cpacspy
  ```



  To see how to use this module, check out:

  - Python file with examples of useage:  [cpacspy_use.py](./examples/cpacspy_use.py)
  - Jupyter Notebook with examples of useage: [cpacspy_use.ipynb](./examples/cpacspy_use.ipynb)





  ```bash
  cd cpacspy
  python -m build
  pip install --user .
  ```



  ```bash
  cd cpacspy
  ./run_ci.sh
  ```

  It should run:

  - Black
  - Flake8
  - Pytest
  - Codecov



  **License:** [Apache-2.0](./LICENSE.txt)


pkgId: 6086ceaf34f3e533ccfa98336c6672ec2d06f2158e95d0d26cc33800c70005f1
name: python-cpapp
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A command-line tool to copy file contents based on extension.
url: https://github.com/HakimiX/cpapp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpapp-0.1.0-1.src.rpm
checksum_type: sha256
description:
  1. Install setuptools and wheel (if not already installed):
  ```bash
  pip install setuptools wheel
  ```

  2. Build the package:
  ```bash
  python setup.py sdist bdist_wheel
  ```

  3. Upload the package to PyPI:

  First, install `twine` if you haven't:
  ```bash
  pip install twine
  ```
  Then upload the package:
  ```bash
  twine upload dist/*
  ```
  > You'll need a PyPI account to upload your package. If you don't have one, you can create it at pypi.org.




  ```bash
  pip install cpapp
  ```
  and use it globally:
  ```bash
  cpapp --ext=py
  ```


pkgId: 7457a7952ccb49aadaebae7d7b74fe35418d2d4d025506f6ef05c1d22f6364c5
name: python-cpc-fusion
arch: src
version: 0.1.29
epoch: 0
release: 1
summary: CPC Fusion
url: https://bitbucket.org/cpchain/fusion/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpc-fusion-0.1.29-1.src.rpm
checksum_type: sha256
description:
     cpc-fusion
  |python3|\ |License: GPL v3|\ |Pull Requests|\ |Follow Twitter|
  A Python package based on
  `web3.py <https://github.com/ethereum/web3.py>`__ to interact with
  cpchain.
  -  Python 3.5+ support


pkgId: aed8ca65d79e74e4fdf5cc906d36b1ba7b4f9201b4a620597fe8ba234856696a
name: python-cpc.geofiles
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: CPC geospatial file interaction (reading, writing, etc.)
url: https://github.com/noaa-nws-cpc/cpc.geofiles
rpm_license: CC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpc.geofiles-0.4.3-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/cpc.geofiles.svg)](https://pypi.python.org/pypi/cpc.geofiles)
  [![Build Status](https://travis-ci.org/noaa-nws-cpc/cpc.geofiles.svg?branch=master)](https://travis-ci.org/noaa-nws-cpc/cpc.geofiles)
  CPC geospatial file interaction (reading, writing, etc.)
  - Free software: Creative Commons license


pkgId: fca02e8f4c310f90d39d978d883b4525ff2ae3da90fe6a4863616951413ea1b6
name: python-cpct
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Chipys PathOfExile Chaos Tool
url: https://pypi.org/project/cpct/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpct-0.2.1-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Installation](#installation)
  - [Why Chaos Recipe](#Why_Chaos_Recipe)
  - [Features](#Features)
  - [Features Requests](#FeaturesRequests)
  - [License](#license)
  - [chipy.dev](https://chipy.dev)

  *PIP install method*
  ```console
  pip install cpct --upgrade -t c:/chipy-scripts/
  run C:/chipy-scripts/cpct/cpct.py OR C:/chipy-scripts/cpct/_START_HERE.cmd
  ```
  *GitHub download*
  ```console
  Download from [GitHub](https://github.com/iamchipy/chipys-pathofexile-chaos-tool)
  Unzip to a desired location
  run _install_requirements.py (to install needed packages to global env)
  run cpct.py OR _START_HERE.cmd
  ```
  **You will need to request a Client Secrect from me (PLEASE keep this private, if client secrects get shared it'll invalidate the whole app on GGG's side)**
  - Go to Settings > Request client secrect > Enter your DiscordName#1234 (this is how I'll reach you)
  - Enter the client secrect and then attempt to log-in (top left)
  - One logged in select your Chaos Recipe tab from the dropdown menus (only supports a single tab right now)
  - Then select how many recipe sets you are aiming for before turning them in (I recommend 4-8 but NO less than 2)

  As many wealthy players have already said; the chaos recipe is a trap. They suggest that it's simply not time efficient. If you spend 30 minutes just farming unidentified items to complete 2x chaos recipes then thats roughly 8chaos/hour. The argument is that in an hour of running T1 rolled maps you should easily make more than that. *WHICH IS TRUE*
  However, there are some cases where I'd venture to ammend that sentiment. There are definitely times when chaos recipe is still helpful. For these edge cases there are things you should and shouldn't do to make it worth your time:
  **You should NOT . . .**
  - **Do NOT** have chaos recipe as your only/primary objective as you play *(As a rule of thumb)*
  - **Do NOT** waste your time selling identified sets ( 1c instead of 2c is almost NEVER worth it in trade leagues )
  - **Do NOT** waste your time selling recipe in single sets
  **You SHOULD . . .**
  - **Do** passively collect choas recipe items and just toss them in a dump tab
  - **Do** keep your jewlery unidentified in trade leagues ( Statistically 2c is almost ALWAYS able to buy you a better ring/amulet than what you will ID )
  - **Do** collect a minimum of 2x complete recipe sets before selling them as you can fit 2x complete sets in your inventory
  **Edge cases . . .**
  - You may need to continue chaos recipe if you play SSF (Solo Self Found) and you need chaos for crafting or map device
  - Early in every league the trade value of chaos is still relatively strong (good value for invested time) so for the first week it's still worth your time if you do it efficiently and passively
  - If you are a new player and you aren't fast or efficient and some basic currency to improve your gear would help you progress (remeber to aim to outgrow chaos recipe as your income source)

  [![GUI](https://chipy.dev/res/ctcp_gui.png)](#)
  **OAuth2 permissions**
  - The is the appropriate way to get correct permissions and access
  - No need to dig out and reuse your webbrowser's sessionID token (which is against ToC)
  - Can be easily revoked from your [PoE Profile](https://www.pathofexile.com/my-account/applications) at any time
  **Automated itemfilter updating**
  - Works with existing items filters to modify/overlay recipe highlights
  - Only affects item backgrouns so your existing border and text colors will be unaffected
  - It can also update those when you enter a new zone to high items types that you have enough of
  **Itemfilter color selection**
  - In app filter customization now allows you to select any color you like for each slot
  - *PLANNED* Filters boarders/text/size will be customizable too
  **Itemfilter mode selection**
  - Default will add it's recipe items colors to existing filter
  - Disabled will no affect your filter at all
  - *PLANNED* FilterBlade will edit the chaos recipe section of a filterblade filter

  [ ] Integration with FilterBlade filters (rather than just added it's own)
  [ ] Integration with Online filters (if possible)
  [ ] Additional filter color/font/size customization options
  [ ] Add alpha slider to picker
  [ ] Rebuild item reading system into ENUM to easy class changes
  [ ] Add 2-H weapon options to filter
  [ ] Add league and tab memory
  [ ] Add never hide rings/ammy options
  [ ] Add sets ready counters (with ilvl checking)
  [ ] Add feature to indicate next items
  [ ] Fix auto refresh not renewing the list in the GUI display
  [ ] Add auto check limiter to read and log last checked zone entry
  [ ] Fix GUI and regal filter to be i75 (not 70)
  [ ] Write for Steam Version and path options!

  `cpct` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

  This product isn't affiliated with or endorsed by Grinding Gear Games in any way.


pkgId: f9579449ff9dd4fb0bad338531c539f14c02937f9512e97ebc8173c960f59411
name: python-cpeparser
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: CPE - Common platform enumeration parser in Python
url: https://github.com/sabuhish/cpe-parser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpeparser-0.0.2-1.src.rpm
checksum_type: sha256
description:
  The cpe-parser libray is a parses for CPE value. This cpe value can be either uri biding cpe or formatted binding value.




  ```sh
   $ pip install cpe-parser
  ```





  ```python
  from cpeparser import CpeParser
  cpe = CpeParser()
  result = cpe.parser("cpe:2.3:a:ipython:ipython:*:*:*:*:*:*:*:*")
  print(result)
  {
      'part': 'a',
      'vendor': 'ipython',
      'product': 'ipython',
      'version': '*',
      'update': '*',
      'edition': '*',
      'language': '*',
      'sw_edition': '*',
      'target_sw': '*',
      'target_hw': '*',
      'other': '*'
  }
  ```
  Default values are returned as asterisks '*' that represent ANY.


  This library follows the guidelines outline here:
  https://nvlpubs.nist.gov/nistpubs/Legacy/IR/nistir7695.pdf


pkgId: 9bcb7c085155822fc5f069dac59eeaeee4bb078b9a9115ff2baa51104c103ca6
name: python-cpf-cnpj-validate
arch: src
version: 1.4
epoch: 0
release: 1
url: https://github.com/andrersp/pycpfcnpj
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpf-cnpj-validate-1.4-1.src.rpm
checksum_type: sha256
summary:
  Python module for brazilian register numbers for persons (CPF) and companies (CNPJ) and mask generator to string or int CPF/CNPJ.


pkgId: ab810e57cb7d9a70b0dbc2ea92d4cdafaada51671e054e8d5711e9746ab1cb07
name: python-cpf-generator
arch: src
version: 2.1.4
epoch: 0
release: 1
summary: Generate, Validate and Format brazilian CPF
url: https://github.com/matalmeida/cpf-generator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpf-generator-2.1.4-1.src.rpm
checksum_type: sha256
description:
  ![License](https://img.shields.io/pypi/l/cpf-generator.svg?style=flat)
  ![PyPI](https://img.shields.io/pypi/v/cpf-generator.svg)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cpf-generator.svg)
  [![Downloads](https://pepy.tech/badge/cpf-generator)](https://pepy.tech/project/cpf-generator)



  ```sh
  $ pip install cpf-generator
  ```



  ```py
  from cpf_generator import CPF

  cpf = CPF.generate() # Will generate a random CPF # EX: 46064927240
  formatedCpf = CPF.format(cpf) # Will format the CPF to be printed in some place # EX: 460.649.272-40
  CPF.unformat(formatedCPF) # Works with formated CPF # EX: 46064927240
  CPF.validate(cpf) # Will return True if the CPF is valid or False if not # EX: True
  CPF.validate(formatedCPF) # Works with formated CPF # EX: True
  ```



  Work with braziian CPF easily


pkgId: 4a22f877e95520221849cccad032a8c78c46573dbb7ec5494f1881f223f40121
name: python-cpg-utils
arch: src
version: 5.1.1
epoch: 0
release: 1
summary: Library of convenience functions specific to the CPG
url: https://github.com/populationgenomics/cpg-utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpg-utils-5.1.1-1.src.rpm
checksum_type: sha256
description:
  This is a Python library containing convenience functions that are specific to the CPG.

  In order to install the library in a conda environment, run:

  ```bash
  conda install -c cpg cpg-utils
  ```

  To use the library, import functions like this:

  ```python
  from cpg_utils.cloud import email_from_id_token

  _email_string = email_from_id_token(id_token_jwt='TOKEN_STRING')
  ```

  We use `bumpversion` for incrementing the library's semantic version. A new conda package gets published automatically in the `cpg` conda channel whenever a version bump commit is merged with the `main` branch.




  - [Methods to facilitate cloud computing](documentation/cloud.md)
  - [Helper functions for Hail Batch jobs](documentation/hail_batch.md)
  - [Cloning git repositories inside Hail Batch jobs](documentation/git.md)


pkgId: d010ff4dd40eea07f4fc7ee9968367f91ef2f4fb477830c482e5627de0624a8d
name: python-cpg-workflows
arch: src
version: 1.29.6
epoch: 0
release: 1
summary: CPG workflows for Hail Batch
url: https://github.com/populationgenomics/production-pipelines
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpg-workflows-1.29.6-1.src.rpm
checksum_type: sha256
description:
  Key: ['i', 'j']
  ```
  `gs://cpg-fewgenomes-test/large-cohort/v0-1/relateds_to_drop.ht` is a sample-level table which contains related samples to drop, with top ranking sample selected from each family. Sets of unrelated individuals are determined using Hail's [`maximal_independent_set`](https://hail.is/docs/0.2/methods/misc.html?highlight=maximal_independent_set#hail.methods.maximal_independent_set).
  ```
  Row fields:
      's': str


pkgId: 4196ab685e8f78ca10a47aab4dc7520b7d9af6c88751a18a40c6aa05eb2cf6c9
name: python-cpgclientlib
arch: src
version: 0.11.321
epoch: 0
release: 1
summary: A client library for CPG servers
url: https://github.com/ShiftLeftSecurity/codepropertygraph
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpgclientlib-0.11.321-1.src.rpm
checksum_type: sha256
description:
  A library to script code analyzers based on code property graphs
  (e.g., Joern/Ocular) via Python.




  * Python 3 and Pip(we do _not_ support Python 2.7)
    see (https://packaging.python.org/tutorials/installing-packages/)



  To download and install the latest version, issue the following command:

  ```
  pip install cpgclientlib
  ```



  Assuming that `joernd` is running locally, the following short scripts creates a code property graph and runs a query to retrieve all methods in JSON format.

  ```python


  from cpgclient.CpgClient import CpgClient

  server = '127.0.0.1'
  port = 8080
  client = CpgClient(server, port)
  client.create_cpg('/path/to/cpg')
  methods = client.query('cpg.method.toJson')
  print(methods)
  ```



  * Code Property Graph specification and tools
    https://github.com/ShiftLeftSecurity/codepropertygraph/
  * The open source code analyze joern: https://joern.io
  * ShiftLeft Ocular: https://ocular.shiftleft.io


pkgId: 93562f327da98275cfe5e2d22ffec946bbc36a53553968f1379687ddcd56c8fc
name: python-cpgtools
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Tools to analyze and visualize DNA methylation data
url: https://pypi.org/project/cpgtools/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpgtools-2.0.3-1.src.rpm
checksum_type: sha256
description:
  1. (Optional) Create Virtual Environments (Note: `venv` is available in Python 3.3 and later. You can also use [virtualenv](https://packaging.python.org/en/latest/key_projects/#virtualenv))

   `$ python3 -m venv my_env` (will create a directory called my_env)

   `$ source my_env/bin/activate`

  2. Install CpGtools

   `$ pip install cpgtools`

   or

   `$ pip install git+https://github.com/liguowang/cpgtools.git`

  3. Upgrade

   `$ pip install cpgtools --upgrade`

  4. Uninstall

   `pip -y uninstall cpgtools`



  https://cpgtools.readthedocs.io/en/latest/

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


pkgId: fd3e79eb549627bf3e58c65abc7ac17784d40c06f412a3e85ca55344d1674adf
name: python-cpi-tools
arch: src
version: 0.3.28
epoch: 0
release: 1
summary: Repository of functions used across CPI
url: https://github.com/climatepolicydata/cpi_tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpi-tools-0.3.28-1.src.rpm
checksum_type: sha256
description:
  A repository of commonly used tools across CPI



  1. Install:

  ```
  pip install cpi_tools
  ```

  AWS Tools

  ```python
  from cpi_tools import aws_tools


  bucket = 'YOUR_BUCKET'

  path = 'PATH_IN_BUCKET'

  file_name = 'FILE_NAME'


  df = aws_tools.read_from_s3(bucket, path, file_name)


  aws_tools.write_to_s3(df, bucket, path, file_name)
  ```


pkgId: 14f0b9a38d2899b67bcf1c5133b6fcb30936aa1e56f1e06c5ae6c92e8a62fbb6
name: python-cping
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Concurrent multi-host ping (ICMP and TCP)
url: https://github.com/hSaria/cPing
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cping-0.1.11-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://img.shields.io/github/workflow/status/hSaria/cPing/CI/main)](https://github.com/hSaria/cPing/actions?query=workflow%3ACI)
  [![Coverage status](https://coveralls.io/repos/github/hSaria/cPing/badge.svg)](https://coveralls.io/github/hSaria/cPing)
  [![Downloads](https://static.pepy.tech/personalized-badge/cping?period=total&units=international_system&left_color=grey&right_color=brightgreen&left_text=downloads)](https://pepy.tech/project/cping)
  [![Maintainability](https://img.shields.io/codeclimate/maintainability/hSaria/cPing)](https://codeclimate.com/github/hSaria/cPing)
  [![PyPI version](https://badge.fury.io/py/cping.svg)](https://badge.fury.io/py/cping)

  cPing concurrently checks if hosts are responding using ICMP echo or TCP SYN.



      pip3 install cping



  cPing uses unprivileged sockets; no need for root privileges.

      cping host1 host2

  ![alt text](https://github.com/hSaria/cPing/raw/main/.github/example_1.png "Example output")

  > Tip: When you launch cPing, look at the footer; it's got some useful actions.



  See the available arguments to adjust the behavior of cPing or use a different protocol.

      cping -h

  If you found a bug, or just have a question/suggestion, please open an [issue](https://github.com/hSaria/cPing/issues/new/choose) (greatly appreciated).



  The sparkline (right part of the screenshot) is simplified on Windows as it doesn't support the required [block characters](https://w.wiki/zKh). If you know of any substitutes, let me know.



  If you're getting a `Permission denied` exception, it is likely that your OS is
  too old to have [unprivileged ICMP sockets](https://fedoraproject.org/wiki/Changes/EnableSysctlPingGroupRange#Detailed_Description) enabled by default. You can enable
  this with:

  ```shell
  sudo sh -c 'echo net.ipv4.ping_group_range = 0 2147483647 >> /etc/sysctl.conf'
  sudo sysctl -p
  ```


pkgId: 030aa1f8cbf6cd7eb561f827b3a0eb0e594e63c6e0c65534b24499fbf37b7e8b
name: python-cpix
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: CPIX
url: https://github.com/unifiedstreaming/pycpix
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpix-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Python library for working with CPIX 2.2 (DASH-IF Content Protection Information Exchange) documents

  For more details on CPIX see:

  * https://dashif.org/guidelines/
  * https://dash-industry-forum.github.io/docs/CPIX2.2/Cpix.html



  * Creation of CPIX documents
  * Content keys
  * Usage rules
  * DRM systems
  * Parsing of CPIX documents
  * Validation against CPIX XSD



  * Validation of document correctness (e.g. kid referenced by usage rule matches a content key)



  * Encryption, decryption and signing are not supported.



  Install using [pip](https://pip.pypa.io/):

  ```
  pip install cpix
  ```





  Example scripts which can be used with Widevine and Playready test servers to
  get or create keys and produce CPIX documents are available in `example`.



  To create a simple CPIX document with a single key:

  ```python
  import cpix

  full_cpix = cpix.CPIX(
      content_keys=cpix.ContentKeyList(
          cpix.ContentKey(
              kid="0DC3EC4F-7683-548B-81E7-3C64E582E136",
              cek="WADwG2qCqkq5TVml+U5PXw=="
          )
      ),
      drm_systems=cpix.DRMSystemList(
          cpix.DRMSystem(
              kid="0DC3EC4F-7683-548B-81E7-3C64E582E136",
              system_id="EDEF8BA9-79D6-4ACE-A3C8-27DCD51D21ED",
              pssh=("AAAAxnBzc2gBAAAA7e+LqXnWSs6jyCfc1R0h7QAAAAINw+xPdoNUi4HnPGT"
                    "lguE2FEe37S9mVyu9EwbOfPNhDQAAAIISEBRHt+0vZlcrvRMGznzzYQ0SEF"
                    "rGoR6qL17Vv2aMQByBNMoSEG7hNRbI51h7rp9+zT6Zom4SEPnsEqYaJl1Hj"
                    "4MzTjp40scSEA3D7E92g1SLgec8ZOWC4TYaDXdpZGV2aW5lX3Rlc3QiEXVu"
                    "aWZpZWQtc3RyZWFtaW5nSOPclZsG")
          )
      )
  )
  ```

  This can then be printed as a formatted XML document:

  ```python
  print(str(full_cpix.pretty_print(xml_declaration=True), "utf-8'"))
  ```

  ```xml
  <?xml version='1.0' encoding='utf-8'?>
  <CPIX xmlns:pskc="urn:ietf:params:xml:ns:keyprov:pskc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="urn:dashif:org:cpix" xsi:schemaLocation="urn:dashif:org:cpix cpix.xsd">
    <ContentKeyList>
      <ContentKey kid="0dc3ec4f-7683-548b-81e7-3c64e582e136">
        <Data>
          <pskc:Secret>
            <pskc:PlainValue>WADwG2qCqkq5TVml+U5PXw==</pskc:PlainValue>
          </pskc:Secret>
        </Data>
      </ContentKey>
    </ContentKeyList>
    <DRMSystemList>
      <DRMSystem kid="0dc3ec4f-7683-548b-81e7-3c64e582e136" systemId="edef8ba9-79d6-4ace-a3c8-27dcd51d21ed">
        <PSSH>AAAAxnBzc2gBAAAA7e+LqXnWSs6jyCfc1R0h7QAAAAINw+xPdoNUi4HnPGTlguE2FEe37S9mVyu9EwbOfPNhDQAAAIISEBRHt+0vZlcrvRMGznzzYQ0SEFrGoR6qL17Vv2aMQByBNMoSEG7hNRbI51h7rp9+zT6Zom4SEPnsEqYaJl1Hj4MzTjp40scSEA3D7E92g1SLgec8ZOWC4TYaDXdpZGV2aW5lX3Rlc3QiEXVuaWZpZWQtc3RyZWFtaW5nSOPclZsG</PSSH>
      </DRMSystem>
    </DRMSystemList>
  </CPIX>
  ```


pkgId: 4eedd8af864ee73001ca4b880cc908c635ae42ad55dbb00274688d019bf7c2a6
name: python-cpkg
arch: src
version: 0.4.21
epoch: 0
release: 1
summary: A package that creates a package
url: https://github.com/seoul2k/cPkg
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpkg-0.4.21-1.src.rpm
checksum_type: sha256
description:
  >## install
  >>```shell
  >>pip install cpkg
  >>```
  >## use
  >>```python
  >>import cpkg
  >>cpkg.create(
  >>    path='',
  >>    dirName='',
  >>    pkgName='',
  >>    author='',
  >>    author_email='',
  >>    description='',
  >>    url='',
  >>    project_urls={},
  >>    classifiers=[],
  >>    python_requires=3.6,
  >>    install_requires=[]
  >>)
  >>```

  ```shell
  createpkg optional
  ```
  For more information, see
  ```shell
  createpkg -h
  ```

  >### 0.0.6 2021 1 19
  >>1. Update command:
  >>>See details:
  >>>```shell
  >>>python3 -m cpkg -h
  >>>```
  >>
  >### 0.0.7 2021 1 19
  >>Update Info
  >### 0.0.8 2021 1 19
  >>Repair Bug
  >### 0.0.9 2021 1 19
  >>Repair Bug
  >### 0.0.13 2021 1 24
  >>Repair Bug
  >### 0.0.18 2022 3 27
  >>Convert module to command line tool
  >### 0.1.9 2022 3 27
  >>Updata README.md
  >### 0.1.10 2022 4 9
  >>Repair Bug
  >### 0.1.11 2022 4 19
  >>Add new elements from setup.py
  >### 0.2.14 2022 5 19
  >>Repair Bug
  >### 0.3.19 2022 7 7
  >>Add the functions of creating templates and identifying templates(Command is not supported temporarily)
  >### 0.4.19 2022 7 13
  >>Add The createmod command supports the functions of creating and identifying templates
  >### 0.4.21 2022 7 13
  >>Repair Bug


pkgId: 51a860047e4a8d69ff93fd4f116e281c496f0b101f54a89b6a0f148149130164
name: python-cpmpy
arch: src
version: 0.9.23
epoch: 0
release: 1
summary: A numpy-based library for modeling constraint programming problems
url: https://github.com/CPMpy/cpmpy
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpmpy-0.9.23-1.src.rpm
checksum_type: sha256
description:
  ![Github Version](https://img.shields.io/github/v/release/CPMpy/cpmpy?label=Github%20Release&logo=github)
  ![PyPI version](https://img.shields.io/pypi/v/cpmpy?color=blue&label=Pypi%20version&logo=pypi&logoColor=white)
  ![PyPI downloads](https://img.shields.io/pypi/dm/cpmpy?label=Pypi%20Downloads&logo=pypi&logoColor=white)
  ![Tests](https://github.com/CPMpy/cpmpy/actions/workflows/python-test.yml/badge.svg)
  ![Licence](https://img.shields.io/github/license/CPMpy/cpmpy?label=Licence)

  CPMpy is a Constraint Programming and Modeling library in Python, based on numpy, with direct solver access.

  * Easy to integrate with machine learning and visualisation libraries, because decision variables are numpy arrays.
  * Solver-independent: transparently translating to CP, MIP, SMT, SAT
  * Incremental solving and direct access to the underlying solvers
  * and much more...

  **Documentation: [https://cpmpy.readthedocs.io/](https://cpmpy.readthedocs.io/)**

  CPMpy is still in Beta stage, and bugs can occur. If so, please report the issue on Github!



  CPMpy has the open-source [Apache 2.0 license]( https://github.com/cpmpy/cpmpy/blob/master/LICENSE) and is run as an open-source project. All discussions happen on Github, even between direct colleagues, and all changes are reviewed through pull requests.

  Join us! We welcome any feedback and contributions. You are also free to reuse any parts in your own project. A good starting point to contribute is to add your models to the examples folder.


  Are you a solver developer? We are keen to integrate solvers that have a python API on pip. If this is the case for you, or if you want to discuss what it best looks like, do contact us!



  CPMpy can be a good library for courses and projects on **modeling constrained optimisation problems**, because its usage is similar to that of other data science libraries, and because it translates to the fundamental languages of SAT, SMT, MIP, and CP transparently.

  Contact Prof. Tias Guns if you are interested in, or are going to develop, teaching material using CPMpy. For example we have CPMpy snippets of part of Pierre Flener's excellent ["Modelling for Combinatorial Optimisation [M4CO]"](https://user.it.uu.se/~pierref/courses/COCP/slides/).



  Part of the development received funding through Prof. Tias Guns his European Research Council (ERC) Consolidator grant, under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 101002802, [CHAT-Opt](https://people.cs.kuleuven.be/~tias.guns/chat-opt.html)).

  You can cite CPMpy as follows: "Guns, T. (2019). Increasing modeling language convenience with a universal n-dimensional array, CPpy as python-embedded example. The 18th workshop on Constraint Modelling and Reformulation at CP (ModRef 2019).

  ```
  @inproceedings{guns2019increasing,
      title={Increasing modeling language convenience with a universal n-dimensional array, CPpy as python-embedded example},
      author={Guns, Tias},
      booktitle={Proceedings of the 18th workshop on Constraint Modelling and Reformulation at CP (Modref 2019)},
      volume={19},
      year={2019}
  }
  ```


pkgId: c362ba75a528d42157032c6d1f174de8414c86f2230dafebda687db58e89c835
name: python-cpp-runner
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A simple, small command line utility to run cpp files.
url: https://github.com/macaquedev/cpp-runner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpp-runner-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A simple cpp file runner for competitive programmers with no external dependencies.
  To install, simply type:
      pip install cpp-runner
  To run a cpp file, type this:
      crun <filename> [-q]
  To create a file with the USACO training template, type this:
      crun <filename> -u [-q]
  The filename argument is mandatory. The -q argument switches off console output.


pkgId: c7d3558d3d9e82f5078f204a3ef47db76f171d276f4a277c05d182e2af790542
name: python-cppbuiltins
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Alternative implementation of python builtins based on C++ `std` library.
url: https://github.com/lycantropos/cppbuiltins/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cppbuiltins-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![](https://dev.azure.com/lycantropos/cppbuiltins/_apis/build/status/lycantropos.cppbuiltins?branchName=master)](https://dev.azure.com/lycantropos/cppbuiltins/_build/latest?definitionId=31&branchName=master "Azure Pipelines")
  [![](https://codecov.io/gh/lycantropos/cppbuiltins/branch/master/graph/badge.svg)](https://codecov.io/gh/lycantropos/cppbuiltins "Codecov")
  [![](https://img.shields.io/github/license/lycantropos/cppbuiltins.svg)](https://github.com/lycantropos/cppbuiltins/blob/master/LICENSE "License")
  [![](https://badge.fury.io/py/cppbuiltins.svg)](https://badge.fury.io/py/cppbuiltins "PyPI")
  In what follows `python` is an alias for `python3.5`
  or any later version (`python3.6` and so on).


pkgId: 8b51225d732491510da77c51e12d570782d84d9859024782266037c1f3ca93fa
name: python-cppcheck-codequality
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Convert a CppCheck XML report to a GitLab-compatible Code Quality JSON report.
url: https://gitlab.com/ahogen/cppcheck-codequality
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cppcheck-codequality-1.4.1-1.src.rpm
checksum_type: sha256
description:
  [![badge-pypi](https://img.shields.io/pypi/v/cppcheck-codequality.svg?logo=pypi)](https://pypi.python.org/pypi/cppcheck-codequality/)
  &nbsp;
  [![badge-pypi-downloads](https://img.shields.io/pypi/dm/cppcheck-codequality)](https://pypistats.org/packages/cppcheck-codequality)


  [![badge-pipeline](https://gitlab.com/ahogen/cppcheck-codequality/badges/main/pipeline.svg)](https://gitlab.com/ahogen/cppcheck-codequality/-/pipelines?scope=branches)
  &nbsp;
  [![badge-coverage](https://gitlab.com/ahogen/cppcheck-codequality/badges/main/coverage.svg)](https://gitlab.com/ahogen/cppcheck-codequality/-/pipelines?scope=branches)
  &nbsp;
  [![badge-pylint](https://gitlab.com/ahogen/cppcheck-codequality/-/jobs/artifacts/main/raw/badge.svg?job=pylint)](https://gitlab.com/ahogen/cppcheck-codequality/-/pipelines?scope=branches)
  &nbsp;
  [![badge-formatting](https://gitlab.com/ahogen/cppcheck-codequality/-/jobs/artifacts/main/raw/badge.svg?job=format_black)](https://gitlab.com/ahogen/cppcheck-codequality/-/pipelines?scope=branches)
  &nbsp;
  [![badge-issues-cnt](https://img.shields.io/badge/dynamic/json?label=issues&query=statistics.counts.opened&url=https%3A%2F%2Fgitlab.com%2Fapi%2Fv4%2Fprojects%2F19114200%2Fissues_statistics%3Fscope%3Dall)](https://gitlab.com/ahogen/cppcheck-codequality/-/issues)




  I wanted reports from CppCheck to appear in GitLab Merge Requests as [Code
  Quality reports](https://docs.gitlab.com/ee/user/project/merge_requests/code_quality.html#implementing-a-custom-tool),
  which is a JSON file defined by the Code Climate team/service.

  That's all this does: convert CppCheck XML to Code Climate JSON.



  It is primarily used as a console script. As such, ensure you have Python 3's "scripts" directory in your `PATH` variable.
  For example, on Linux, that might be `$HOME/.local/bin`.

  To test, try the `--help` or `--version` flags:
  ```bash
  cppcheck-codequality --help
  ```

  CppCheck already has a script to convert its XML report to HTML for easy
  human reading. See "Chapter 11 HTML Report" in the [CppCheck Manual](http://cppcheck.sourceforge.net/manual.pdf)

  This script follows that example and provides similar command-line options.
  A typical workflow might look like this:

  ```bash

  cppcheck --xml --enable=warning,style,performance ./my_src_dir/ 2> cppcheck_out.xml

  cppcheck-codequality --input-file cppcheck_out.xml --output-file cppcheck.json
  ```

  If you wanted, you could invoke the script directly as a module, like this:

  ```bash

  python -m cppcheck_codequality --input-file=cppcheck_out.xml --output-file=cppcheck.json
  ```

  Now, in your GitLab CI script, [upload this file](https://docs.gitlab.com/ee/ci/pipelines/job_artifacts.html#artifactsreportscodequality)
  as a Code Quality report.

  ```yaml
  my-code-quality:
    script:
      - [...]
    artifacts:
      reports:
        codequality: cppcheck.json
  ```



  * Sign the contributor agreement (coming soon)
  * Format with [black](https://pypi.org/project/black/)
  * Check with [pylint](https://pypi.org/project/pylint/)



  CppCheck is an open-source project with a GPL v3.0 license.
  * http://cppcheck.sourceforge.net
  * https://github.com/danmar/cppcheck

  "Code Climate" may be a registered trademark of Code Climate, Inc. which provides
  super-cool free and paid services to the developer community.
  * https://codeclimate.com
  * https://github.com/codeclimate

  "GitLab" is a trademark of GitLab B.V.
  * https://gitlab.com
  * https://docs.gitlab.com/ee/user/project/merge_requests/code_quality.html

  All other trademarks belong to their respective owners.


pkgId: 05db651fc277e903ab0caae992a8bc3e4eb7545406e9e8f0e9529c230873c719
name: python-cpplint
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Automated checker to ensure C++ files follow Google's style guide
url: https://github.com/cpplint/cpplint
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpplint-1.6.1-1.src.rpm
checksum_type: sha256
description:
  Cpplint is a command-line tool to check C/C++ files for style issues following `Google's C++ style guide <http://google.github.io/styleguide/cppguide.html>`_.
  Cpplint is developed and maintained by Google Inc. at `google/styleguide <https://github.com/google/styleguide>`_, also see the `wikipedia entry <http://en.wikipedia.org/wiki/Cpplint>`_
  While Google maintains cpplint, Google is not (very) responsive to issues and pull requests, this fork aims to be (somewhat) more open to add fixes to cpplint to enable fixes, when those fixes make cpplint usable in wider contexts.
  Also see discussion here https://github.com/google/styleguide/pull/528.


pkgId: 72715d151f6c68ca1db098e28ccb0c1f32efd21be2843d7b09fec12e6e76170e
name: python-cpppo
arch: src
version: 4.4.3
epoch: 0
release: 1
summary: Cpppo is a Communication Protocol Python Parser and Originator
url: https://github.com/pjkundert/cpppo
rpm_license: Dual License; GPLv3 and Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpppo-4.4.3-1.src.rpm
checksum_type: sha256
description:
  Cpppo is used to create event-driven state machines which consume a stream
  of input and generate a series of state changes, or an indication that no
  progress is possible due to (for example) exhaustion of input symbols.

  This is useful for creating parsers for complex grammars describing
  languages, including binary computer protocols.

  An example included with cpppo is an implementation of a subset of the
  EtherNet/IP CIP language used by some industrial control equipment, such as
  Rockwell's ControlLogix Controllers.  The cpppo.server.enip package can be used
  to create Python programs which can parse requests in this protocol (eg. as a
  server, to implement something like a simulated Controller) or originate
  requests in this protocol (eg. as a client, sending commands to a Controller).

  In addition, the ability to read, write and poll remote PLCs of
  various types including Modbus/TCP is provided.


pkgId: da331d0c64d691b22d0e1277cba2a3f14e205a9c9cea262dd6f25ada36acf667
name: python-cppy
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/nucleic/cppy
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cppy-1.2.1-1.src.rpm
checksum_type: sha256
description:
  A small C++ header library which makes it easier to write Python extension
  modules. The primary feature is a PyObject smart pointer which automatically
  handles reference counting and provides convenience methods for performing
  common object operations.

rpm_license:
  Copyright (c) 2014, Nucleic All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 264fe08788350410d6eaa57f91d8a214c8fb7cf535606fbaee2c7394b8ff4aac
name: python-cppy
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cppy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cppy-1.3.0-1.src.rpm
checksum_type: sha256
description:
  A small C++ header library which makes it easier to write Python extension
  modules. The primary feature is a PyObject smart pointer which automatically
  handles reference counting and provides convenience methods for performing
  common object operations.

rpm_license:
  Copyright (c) 2014, Nucleic All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: f7d0b8d2ba02d14ef10ad4f3adee39a4641a63d5daaae3d8e1a6c53f11337ba6
name: python-cppyy
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: Cling-based Python-C++ bindings
url: http://cppyy.readthedocs.org
rpm_license: LBNL BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cppyy-3.1.2-1.src.rpm
checksum_type: sha256
description:
  cppyy provides fully automatic, dynamic Python-C++ bindings by leveraging
  the Cling C++ interpreter and LLVM.
  It supports both PyPy (natively), CPython, and C++ language standards
  through C++17 (and parts of C++20).
  Details and performance are described in
  `this paper <http://cern.ch/wlav/Cppyy_LavrijsenDutta_PyHPC16.pdf>`_,
  originally presented at PyHPC'16, but since updated with improved performance
  numbers.
  Full documentation: `cppyy.readthedocs.io <http://cppyy.readthedocs.io/>`_.
  Notebook-based tutorial: `Cppyy Tutorial <https://github.com/wlav/cppyy/blob/master/doc/tutorial/CppyyTutorial.ipynb>`_.


pkgId: 1d300700fabe58c51fde0574027fc1efdfbfec2f76d7e2c81c41b9c8d84edf6d
name: python-cpr_sdk
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cpr_sdk/
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpr_sdk-1.9.1-1.src.rpm
checksum_type: sha256
description:
  Internal library for persistent access to text data.

  > **Warning**
  > This library is heavily under construction and doesn't work with any of our open data yet. We're working on making it usable for anyone.



  The base document model of this library is `BaseDocument`, which contains only the metadata fields that are used in the parser.



  The `Dataset` class is automatically configured with the Huggingface repos we use. You can optionally provide a document limit, a dataset version, and override the repo that the data is loaded from.

  If the repository is private you must provide a [user access token](https://huggingface.co/docs/hub/security-tokens), either in your environment as `HUGGINGFACE_TOKEN`, or as an argument to `from_huggingface`.

  ```py
  from cpr_sdk.models import Dataset, GSTDocument

  dataset = Dataset(GSTDocument).from_huggingface(
      version="d8363af072d7e0f87ec281dd5084fb3d3f4583a9", # commit hash, optional
      limit=1000,
      token="my-huggingface-token", # required for private repos if not in env
  )
  ```

  The following flag is used for the passage level and flat dataset.

  ```py
  dataset = Dataset(
      document_model=BaseDocument
  ).from_huggingface(
      dataset_name="ClimatePolicyRadar/passage-level-flat-dataset",
      passage_level_and_flat=True
  )
  ```



  ```py


  document = BaseDocument.load_from_local(folder_path="path/to/data/", document_id="document_1234")

  document = BaseDocument.load_from_remote(dataset_key"s3://cpr-data", document_id="document_1234")
  ```

  To manage metadata, documents need to be loaded into a `Dataset` object.

  ```py
  from cpr_sdk.models import Dataset, CPRDocument, GSTDocument

  dataset = Dataset().load_from_local("path/to/data", limit=1000)
  assert all([isinstance(document, BaseDocument) for document in dataset])

  dataset_with_metadata = dataset.add_metadata(
      target_model=CPRDocument,
      metadata_csv="path/to/metadata.csv",
  )

  assert all([isinstance(document, CPRDocument) for document in dataset_with_metadata])
  ```

  Datasets have a number of methods for filtering and accessing documents.

  ```py
  len(dataset)
  >>> 1000

  dataset[0]
  >>> CPRDocument(...)


  dataset.filter("document_id", "1234")
  >>> Dataset()

  dataset.filter_by_language("en")
  >>> Dataset()


  dataset.filter("document_id", lambda x: x in ["1234", "5678"])
  >>> Dataset()
  ```



  This library can also be used to run searches against CPR documents and passages in Vespa.

  ```python
  from src.cpr_sdk.search_adaptors import VespaSearchAdapter
  from src.cpr_sdk.models.search import SearchParameters

  adaptor = VespaSearchAdapter(instance_url="YOUR_INSTANCE_URL")

  request = SearchParameters(query_string="forest fires")

  response = adaptor.search(request)
  ```

  The above example will return a `SearchResponse` object, which lists some basic information about the request, and the results, arranged as a list of Families, which each contain relevant Documents and/or Passages.



  By default, results are sorted by relevance, but can be sorted by date, or name, eg

  ```python
  request = SearchParameters(
      query_string="forest fires",
      sort_by="date",
      sort_order="descending",
  )
  ```



  Matching documents can also be filtered by keyword field, and by publication date

  ```python
  request = SearchParameters(
      query_string="forest fires",
      filters={
          "language": ["English", "French"],
          "category": ["Executive"],
      },
      year_range=(2010, 2020)
  )
  ```



  A subset of families or documents can be retrieved for search using their ids

  ```python
  request = SearchParameters(
      query_string="forest fires",
      family_ids=["CCLW.family.10121.0", "CCLW.family.4980.0"],
  )
  ```

  ```python
  request = SearchParameters(
      query_string="forest fires",
      document_ids=["CCLW.executive.10121.4637", "CCLW.legislative.4980.1745"],
  )
  ```



  The default search approach uses a nearest neighbour search ranking.

  Its also possible to search for exact matches instead:

  ```python
  request = SearchParameters(
      query_string="forest fires",
      exact_match=True,
  )
  ```

  Or to ignore the query string and search the whole database instead:

  ```python
  request = SearchParameters(
      year_range=(2020, 2024),
      sort_by="date",
      sort_order="descending",
  )
  ```



  The response objects include continuation tokens, which can be used to get more results.

  For the next selection of families:

  ```python
  response = adaptor.search(SearchParameters(query_string="forest fires"))

  follow_up_request = SearchParameters(
      query_string="forest fires"
      continuation_tokens=[response.continuation_token],

  )
  follow_up_response = adaptor.search(follow_up_request)
  ```

  It is also possible to get more hits within families by using the continuation token on the family object, rather than at the responses root

  Note that `this_continuation_token` is used to mark the current continuation of the families, so getting more passages for a family after getting more families would look like this:

  ```python
  follow_up_response = adaptor.search(follow_up_request)

  this_token = follow_up_response.this_continuation_token
  passage_token = follow_up_response.families[0].continuation_token

  follow_up_request = SearchParameters(
      query_string="forest fires"
      continuation_tokens=[this_token, passage_token],
  )
  ```



  Users can also fetch single documents directly from Vespa, by document ID

  ```python
  adaptor.get_by_id(document_id="id:YOUR_NAMESPACE:YOUR_SCHEMA_NAME::SOME_DOCUMENT_ID")
  ```

  All of the above search functionality assumes that a valid set of vespa credentials is available in `~/.vespa`, or in a directory supplied to the `VespaSearchAdapter` constructor directly. See [the docs](docs/vespa-auth.md) for more information on how vespa expects credentials.



  Some tests rely on a local running instance of vespa.

  This requires the [vespa cli](https://docs.vespa.ai/en/vespa-cli.html) to be installed.

  Setup can then be run with:

  ```
  poetry install --all-extras --with dev
  poetry shell
  make vespa_dev_setup
  make test
  ```

  Alternatively, to only run non-vespa tests:

  ```
  make test_not_vespa
  ```

  For clean up:

  ```
  make vespa_dev_down
  ```



  - Make updates to the package.
  - Bump the package version in the `cpr_sdk/version.py` module.
  - Make a PR.
    - In CI/CD we will check that the version is greater than the latest release.
  - Merge.
  - Tag a release manually in github with a version that matches the latest on main that you just merged.
    - In CI/CD we will check that the latest release matches the versions defined in code.
  - Check in `pypi`.


pkgId: e9d5f181d6c64d0ef19aafe2df11e1812623b00df2da077007c8f13cc1200b00
name: python-cprint
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Printing and debugging with color
url: https://github.com/EVasseure/cprint
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cprint-1.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/EVasseure/cprint.svg?branch=master)](https://travis-ci.org/EVasseure/cprint)



  Do you find it annoying when you have to search for a certain debug, or error, line in your console? Have you ever dreamed of a simple and quick way to make your debug print truly visible? Well here is your solution!
  cprint is a minimalist python library which gives you the possibility to print in color.



  `pip install cprint`



  ```python
  from cprint import *

  cprint(arg) 							# WHITE
  cprint.ok(arg)							# BLUE
  cprint.info(arg)						# GREEN
  cprint.warn(arg)						# YELLOW
  cprint.err(arg, interrupt=False)		# BROWN
  cprint.fatal(arg, interrupt=False)		# RED
  ```

  ![Demo](/img/screen.png)

  In case you have issues under Windows, try installing colorama with `pip install colorama`.


pkgId: e7fd5a6ec4f73ad89adfe8f402a8014167928661497417a7f86a5f9acb15650e
name: python-cprint-jianjun
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Colorful Print 彩色文本格式化, 彩色文本输出, 控制打印字符颜色样式!
url: https://github.com/EVA-JianJun/cprint
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cprint-jianjun-1.7.0-1.src.rpm
checksum_type: sha256
description:
  **彩色文本格式化, 彩色文本输出, 控制打印字符颜色样式!**

  ![main][1]



      pip install -U cprint-jianjun



  让你的终端输出各式各样的彩色文本, 以一种非常简便的方式嵌入到程序中!

  ```

  print("{0}  {1}".format("Hello", "World!"))


  import cprint
  print("@56056{0}@45031{1}".cformat("Hello ", " World!"))


  import cprint
  cprint.custom_style = {1: 612, 2: 1224}
  print("@1{0}@2{1}".iformat("Hello ", " World!"))


  print("@56056{0}@45031[ World!]".cformat("Hello "))
  ```

  ![use][2]

  只需要在 `{}` 前加上`@样式id`, 然后把 `format` 改为 `cformat` 就可以按照样式id输出彩色文本



  **命令行输入 `cpshow` 查看所有的样式id**

  颜色样式ID为 `@` 后面的数字, 现在一共有 **70943** 个不同的样式可以选择, 不同的终端效果不一样, 有些终端可能不支持, 请自行测试.

  ![style][3]



  * `cpshoww` : 显示各个 id 的详细信息
  * `cpdemo` : Hello World! 样例
  * `cpdemoid` : Hello World! 样例并显示样式ID

  可以多次调用 `cpdemoid` 查看样式配色, 选择喜欢的ID.


  可以通过赋值 `cprint.custom_style` 来自定义配置自己的id映射表, 这样可以提前配置几套不同的 `id theme` id主题, 然后可以根据喜好或者根据不同的终端配色切换主题配色

  ```

  import cprint


  cprint.custom_style = {1: 612, 2: 1224}
  print("@1{0}@2{1}".iformat("Hello ", " World!"))


  cprint.custom_style = {1: 5547, 2: 66795}
  print("@1{0}@2{1}".iformat("Hello ", " World!"))
  ```

  也可以提前把配色序列写入 `.py` 文件中, 然后在程序启动的时候导入赋值就行.



  在字符串中使用 `@NOW`, `@DATE`, `@TIME` 可以获取到对应的时间字符串
  ```
  print(" NOW: @NOW ".cformat())
  print("DATE: @DATE ".cformat())
  print("TIME: @TIME ".cformat())
  ```
  ```
   NOW: 2023-02-23 10:23:35
  DATE: 2023-02-23
  TIME: 10:23:35
  ```



  [How to Print Colored Text in Python](https://stackabuse.com/how-to-print-colored-text-in-python/)

  ![how][4]
  ![how][5]

  除了输出颜色字符外, 这种方式还可以控制光标移动、清屏、控制终端更改背景颜色等操作.


  最新版本: **cprint-jianjun v1.3.0**
  * 20221116: 1.更新新的常量 `@NOW`, `@DATE`, `@TIME` 的功能 2.更新文档
  * 20230223: 1.更新文档 2.增加 `cpdemoid` 命令行.
  * 20230303: 1.更新 `iformat` 函数.
  * 20230315: 1.更新 `[]` 功能.
  * 20241129: 1.`cpshoww` 显示详细的转义序列信息

    [1]: https://raw.githubusercontent.com/EVA-JianJun/cprint/master/img/1.png
    [2]: https://raw.githubusercontent.com/EVA-JianJun/cprint/master/img/2.png
    [3]: https://raw.githubusercontent.com/EVA-JianJun/cprint/master/img/3.png
    [4]: https://raw.githubusercontent.com/EVA-JianJun/cprint/master/img/4.jpg
    [5]: https://raw.githubusercontent.com/EVA-JianJun/cprint/master/img/5.jpg


pkgId: ddf54ec7f829d5be44dc793fb3be23ae3899119dfd550bea62c98693dd727d55
name: python-cprinter
arch: src
version: 0.12
epoch: 0
release: 1
summary: Terminal Color Printer with dot notation for Python (works with any IDE) - no requirements
url: https://github.com/hansalemaos/cprinter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cprinter-0.12-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><a href="https://twitter.com/Aprender_alemao"><img src="https://cdn.jsdelivr.net/gh/dmhendricks/signature-social-icons/icons/round-flat-filled/50px/twitter.png" alt="Twitter" title="Twitter" width="50"/></a><a href="https://www.facebook.com/estudaralemao/"><img src="https://cdn.jsdelivr.net/gh/dmhendricks/signature-social-icons/icons/round-flat-filled/50px/facebook.png" alt="Facebook" title="Facebook" width="50"/></a><a href="https://www.instagram.com/estudaralemao/"><img src="https://cdn.jsdelivr.net/gh/dmhendricks/signature-social-icons/icons/round-flat-filled/50px/instagram.png" alt="Instagram" title="Instagram" width="50"/></a><a href="https://www.youtube.com/c/wwwqueroestudaralemaocombr"><img src="https://cdn.jsdelivr.net/gh/dmhendricks/signature-social-icons/icons/round-flat-filled/50px/youtube.png" alt="YouTube" title="YouTube" width="50"/></a><a href="https://api.whatsapp.com/send?phone=5511989782756&text=I%20want%20to%20know%20..."><img src="https://cdn.jsdelivr.net/gh/dmhendricks/signature-social-icons/icons/round-flat-filled/50px/whatsapp.png" alt="WhatsApp" title="WhatsApp" width="50"/></a><a href="https://www.queroestudaralemao.com.br"><img src="https://cdn.jsdelivr.net/gh/dmhendricks/signature-social-icons/icons/round-flat-filled/50px/website.png" alt="WWW" title="WWW" width="50"/></a><a href="https://br.pinterest.com/chucrutehans/"><img src="https://cdn.jsdelivr.net/gh/dmhendricks/signature-social-icons/icons/round-flat-filled/50px/pinterest.png" alt="Pinterest" title="Pinterest" width="50"/></a><a href="mailto:aulasparticularesdealemaosp@gmail.com?subject=I%20want%20to%20know%20...%20"><img src="https://cdn.jsdelivr.net/gh/dmhendricks/signature-social-icons/icons/round-flat-filled/50px/mail.png" alt="E-Mail" title="E-Mail" width="50"/>

  </a>



  <p align="center">

  <a href=https://github.com/hansalemaos/TerminalColorPrinter><img src="https://img.shields.io/badge/author-hansalemaos-black"/></a>

  <a href=https://www.queroestudaralemao.com.br><img src="https://img.shields.io/badge/from-queroestudaralemao.com.br-darkgreen"/></a>

  <a href=#><img src="https://img.shields.io/badge/for-Windows-black"/></a>

  <a href=https://codeload.github.com/liangjingkanji/DrakeTyporaTheme/zip/refs/heads/master><img src="https://img.shields.io/badge/Theme-Drake-black"/></a>

  <a href=https://github.com/dmhendricks/signature-social-icons><img src="https://img.shields.io/badge/Social-Icons-darkgreen"/></a>

  </p><br><!--  -->







  Terminal Color Printer with dot notation for Python (works with any IDE) - no requirements (MIT)

  Just download use ```pip install cprinter```



  Everything is self explaining:

  <img src="https://github.com/hansalemaos/TerminalColorPrinter/raw/main/screenshot0.png"/>



  <img src="https://github.com/hansalemaos/TerminalColorPrinter/raw/main/screenshot1.png"/>


pkgId: a07a637424cdaba1d21816a83b0bcab5e6c3c2285e7f1d1b8539ecc9db38ed39
name: python-cproto
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Chrome Debugging Protocol client
url: https://github.com/asyne/cproto
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cproto-0.7.2-1.src.rpm
checksum_type: sha256
description:
  **CProto** is a Debugging Protocol client that supports Chrome, Chromium
  and Blink based browsers.
  **CProto** provides you an advanced interface to interact with Chrome
  (or another supported browser) instance from your Python code. It's
  greatly useful for automated testing, debugging, profiling or even
  complicated page crawling.
  -  `Getting Started`_
  -  `API Docs`_
  -  `Roadmap`_
  -  `Chrome Headless`_
  -  `Examples`_
  *This project is under development. More updates are coming soon.*


pkgId: dd7a51198b7b235d92f3ddcaa02dc4bd689ee1fee4b5026db29967affcfc2ee3
name: python-cpsk
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: an unofficial api for grabbing data from cp.sk
url: https://github.com/Adman/python-cpsk-api
rpm_license: The MIT License (MIT)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpsk-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Simple python api for grabbing data from cp.sk



  Available on [pypi](https://pypi.org/project/cpsk/)

  Running `$ pip install cpsk` will get the package installed



  ```python
  import cpsk
  drive = cpsk.get_routes('Bratislava', 'Praha', **kwargs)
  ```



  | parameter | type    | description                                                                        |
  | --------- | ------- | ---------------------------------------------------------------------------------- |
  | `vehicle` | string  | Vehicle to travel with. Default `vlakbus`. Available: `vlak`, `bus`, `vlakbusmhd`. |
  | `time`    | string  | Departure time. Defaults to current time.                                          |
  | `date`    | string  | Departure date. Defaults to current date.                                          |
  | `direct`  | boolean | Whether to look only for direct routes. Defaults to `False`.                       |


  *Beware that by using this you might be violating cp.sk ToS*


pkgId: 2b3a47b7cb3ec3616441d1d5dceb16c82d072dd64c198694afa3d50e1611e021
name: python-cpstools
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: CPStools is a package for analyzing chloroplast genome sequences.
url: https://pypi.org/project/cpstools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpstools-2.0.3-1.src.rpm
checksum_type: sha256
description:
  ```sh

  pip install biopython

  pip install cpstools -i  https://pypi.tuna.tsinghua.edu.cn/simple
  ```



  ```python
  cpstools -h
  ```





  gbcheck subcommand accepts two parameters:

   `-i, --test_file`

   `-r, --ref_file`

  The parameter of -i/--test_file is required, and -r/--ref_file is optional.

  If only -i/--TEST_FILE, the gbcheck.py will check the annotation of the input file. The script will check the gene name in each gene, CDS, tRNA and rRNA. For CDS, tRNA and rRNA, it will also check the 'product' label.

  For CDS, the codon amino acids will be check, if start codon, stop codon and internal codon was wrong, it will print out the location of CDS.

  ```python

  cpstools gbcheck -i input_file

  cpstools gbcheck -i input_file -r ref_file
  ```





  info subcommand accepts one parameter:

   `-i, --input_file`

  The parameter of -i/-input_file

  This subcommand is used to statistic the gene types and gene numbers

  ```python
  cpstools info -i input_file
  ```





  IR subcommand accepts one parameter:

   `-i, --input_file`

  The parameter of -i/--input_file is required, and the input file can be genbank/fasta format. It will find the four regions in the chloroplast sequences, which the IR region will be identified if length surpass 1,000 bp.

  ```python
  cpstools IR -i input_file
  ```





  The Seq subcommand can be used to adjust the start to the 1st bp in LSC region and the SSC forward. This analysis should combine with the co-linearity.

  Seq subcommand accepts four parameter:

   `-d, --work_dir`

  The parameter of -i/--work_dir is required, and the input directory is fasta format of all need adjusted sequences.

  `-f, --info_file`
  The parameter offile of -f/--info_file is required, This file can be generated from IR subcommand.

  -m {SSC,LSC,RP}, --mode {SSC,LSC,RP}

  The parameter of -m is also required, And three choices was supported:
      `Mode: SSC for adjust_SSC_forward,
            LSC foradjust_start_to_LSC,
            RP for adjust sequence to reverse_complement`

  ```python

  cpstools Seq -d work_dir  -f info.txt -m LSC


  cpstools Seq -d work_dir  -f info.txt -m SSC


  cpstools Seq -d work_dir  -f info.txt -m RP
  ```





  The Pi subcommand accepts a required parameter `-d/--work_dir` and an optional parameter `-m/--mafft_path`. It automatically extracts shared gene regions and shared intergenic sequences from gb files in the work_dir, performs multiple sequence alignments, and calculates Pi values. Finally, it outputs the results sorted according to the chloroplast genome order.

  ```python

  cpstools Pi -d work_dir


  cpstools Pi -d work_dir -m mafft_path
  ```





  The RSCU subcommand accepts a required parameter `-d/--work_dir` and an optional parameter `-l/--filter_length`. It automatically extracts shared coding regions from GenBank files in the work_dir, removes duplicates, filters out short sequences, and calculates their RSCU values.

  ```python

  cpstools RSCU -d work_dir

  cpstools RSCU -d work_dir -l n
  ```



  The SSRs subcommand accepts a required parameter `-i/--input_file` and an optional parameter `-k/--kmer_length`. It automatically identifies and locates SSRs in the GenBank files.

  ```python

  cpstools SSRs -i input_file

  cpstools SSRs -i input_file -k 10,5,4,3,3,3
  ```



  The converse subcommand accepts two required parameter `-d/--input_dir` and  `-m/--mode {fasta,mVISTA,tbl}`. It automatically converse genbank format file into fasta/mVISTA/tbl format.

  ```python

  cpstools converse -d input_dir -m fasta


  cpstools converse -d input_dir -m tbl


  cpstools converse -d input_dir -m mVISTA
  ```



  The LSRs subcommand accepts one required parameter `-i/--input_file` . It automatically reads the output results from Reputer, sorts, and locates them.

  ```
  cpstools LSRS -i input_file
  ```



  The phy subcommand accepts two required parameter `-d/--input_dir` and  `-m/--mode {cds,pro}`. It automatically extracts shared CDS or protein sequences from GenBank files in the input_dir, sorts, and merges them.

  ```python

  cpstools phy -d input_dir -m cds


  cpstools phy -d input_dir -m pro
  ```


pkgId: 9a04b878732cbc4cba9454075bd778566b8f72168e7ed29b8d47c0297c940fdf
name: python-cptv
arch: src
version: 1.5.4
epoch: 0
release: 1
summary: Python library for handling Cacophony Project Thermal Video (CPTV) files
url: https://github.com/TheCacophonyProject/python-cptv
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cptv-1.5.4-1.src.rpm
checksum_type: sha256
description:
  This is Python package provides for quick parsing and generation of
  Cacophony Project Thermal Video (CPTV) files. It works with Python
  3.5+ only.


pkgId: 064cfb29d677437452b412f4d1df684c4d59e8dc2c6176062e310fb0be8161d0
name: python-cpu-load-generator
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: CPU load generator
url: https://github.com/sirtyman/CPULoadGenerator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpu-load-generator-1.2.0-1.src.rpm
checksum_type: sha256
description:
  This package allows to generate a fixed CPU load for a finite time period.
  The script takes in input the desired CPU load, the duration of the experiment and
  the CPU core or all cores on which the load has to be generated.
  **Python versions**
  This master branch refers to Python versions 3.x
  **Dependencies**
  Installment of psutil is required (it is already set as dependency in the setup.py)
  Install psutil:
      pip install psutil
  **Other dependencies for unit tests and linters**:
      pip install mock pytest flake8 tox
  *Usage*
  To generate 20% of load on core 0 for 20 seconds run:
      python -m cpu_load_generator -l 0.2 -d 20 -c 0
  To generate 50% of load on all logical cores for 20 seconds run:
      python -m cpu_load_generator -l 0.5 -d 20 -c -1
  There is an option to run CPU load based on profile file. An exemplary profile is under
  load_profiles/default_profile.json. In order to run generator based on a profile issue
  the following command:
      python -m cpu_load_generator -p <path_to_profile_json>
  To use the package features from python code:
  Install the package from PyPi by issuing the following command:
      python -m pip instal cpu-load-generator
  To use its features from your code:
  ```python
  from cpu_load_generator import load_single_core, load_all_cores, from_profile
  load_single_core(core_num=0, duration_s=20, target_load=0.4)  # generate load on single core (0)
  load_all_cores(duration_s=30, target_load=0.2)  # generates load on all cores
  from_profile(path_to_profile_json=r"c:\profiles\profile1.json")
  ```


pkgId: aed6d9bb1a1ae254217d5933d58c26457f00d5ad2409a6de85f6f46c30148542
name: python-cpuid
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: cpuid Pythonic API
url: https://github.com/fpelliccioni/cpuid-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpuid-0.0.11-1.src.rpm
checksum_type: sha256
description:
  > cpuid Pythonic API






  ```
      $ pip install --upgrade cpuid
  ```



  ```
      $ pip install --upgrade --index-url https://test.pypi.org/pypi/ cpuid
  ```

  <!-- Links -->
  [badge.Appveyor]: https://ci.appveyor.com/api/projects/status/github/fpelliccioni/cpuid-py?svg=true&branch=master
  [badge.Travis]: https://travis-ci.org/fpelliccioni/cpuid-py.svg?branch=master


pkgId: 85002a0499c8622d8719b6ca88281b7621e3bf3b3d9e5d40c73409b2ec9f9ea3
name: python-cputils
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Utilities for Competitive Programming
url: https://github.com/Dih5/cputils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cputils-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![license MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)

  Utilities for Competitive Programming.

  Features:
  - Download samples from [kattis](https://open.kattis.com/), [aceptaelreto](https://aceptaelreto.com/).
  - Test in c, cpp, python, java, rust, ruby, bash, nim.
  - Submit to kattis.
  - Interactive CLI menu.

  Tests only for complete textual match, ignoring leading and trailing whistespaces.


  Assuming you have a [Python3](https://www.python.org/) distribution with [pip](https://pip.pypa.io/en/stable/installing/), install the package running:

  ```bash
  pip3 install cputils
  ```



  To create a config file, run
  ```bash
  cpconfig
  ```


  To download the samples of a problem run
  ```bash
  cpsamples <problem>
  ```


  To test a solution or set of solutions run
  ```bash
  cptest <problem>/<solution(s)>
  ```
  Pro-tip: you can use glob patterns like ```problem/code*``` or ```problem/*.py```.


  To submit a solution (only kattis)
  ```bash
  cpsubmit <problem>/<solution(s)>
  ```


  To run an interactive CLI
  ```bash
  cpmenu
  ```

  Yo can also provide the problem and language with the arguments, or change it in the menu. See help (h) for more info.





  Testing requires installing the test extra. Furthermore, some tests require the languages to be installed and available.

  To run all tests:
  ```bash
  make test
  ```

  To run a single test module:
  ```bash
  pytest tests/test_<test_name>.py
  ```


pkgId: 44809b0de703095ad139e4a43cd05cd41b69574d400a2aa9435fa5d9b19d367b
name: python-cputils
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Utilities for Competitive Programming
url: https://github.com/Dih5/cputils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cputils-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![license MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)

  Utilities for Competitive Programming.

  Features:
  - Download samples from [kattis](https://open.kattis.com/), [aceptaelreto](https://aceptaelreto.com/), adventofcode[https://adventofcode.com/].
  - Test in c, cpp, python, java, rust, ruby, bash, nim.
  - Submit to kattis.
  - Interactive CLI menu.

  Tests only for complete textual match, ignoring leading and trailing whistespaces.


  Assuming you have a [Python3](https://www.python.org/) distribution with [pip](https://pip.pypa.io/en/stable/installing/), install the package running:

  ```bash
  pip3 install cputils
  ```



  To create a config file, run
  ```bash
  cpconfig
  ```


  To download the samples of a problem run
  ```bash
  cpsamples <problem>
  ```


  To test a solution or set of solutions run
  ```bash
  cptest <problem>/<solution(s)>
  ```
  Pro-tip: you can use glob patterns like ```problem/code*``` or ```problem/*.py```.


  To submit a solution (only kattis)
  ```bash
  cpsubmit <problem>/<solution(s)>
  ```


  To run an interactive CLI
  ```bash
  cpmenu
  ```

  Yo can also provide the problem and language with the arguments, or change it in the menu. See help (h) for more info.





  Testing requires installing the test extra. Furthermore, some tests require the languages to be installed and available.

  To run all tests:
  ```bash
  make test
  ```

  To run a single test module:
  ```bash
  pytest tests/test_<test_name>.py
  ```


pkgId: d75e2ea6626b09d768187801515e35a5b4dccafac75da5e725504932f21fefbc
name: python-cpython-lldb
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: LLDB extension for debugging Python programs
url: https://github.com/malor/cpython-lldb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cpython-lldb-0.3.2-1.src.rpm
checksum_type: sha256
description:
  ![build status](https://github.com/malor/cpython-lldb/actions/workflows/tests.yml/badge.svg)
  `cpython_lldb` is an LLDB extension for debugging Python programs.
  It can be useful for troubleshooting stuck threads and crashes in the interpreter
  or external libraries. Unlike most Python debuggers, LLDB allows attaching to a
  running process without instrumenting it in advance, as well as loading a process
  coredump to perform an offline (or post-mortem) analysis of a problem.
  When analyzing the state of a Python process, normally you would only have
  access to *intepreter-level* information: most variables would be of type
  `PyObject*`, and stack traces would only contain CPython internal calls and
  calls to library functions. Unless you are a CPython developer troubleshooting
  the interpreter implementation, that is typically not very useful. This extension,
  however, allows you to extract *application-level* information about execution of
  a program: print the values of variables, list the source code, display Python
  stack traces, etc.
  While CPython already provides a similar extension for gdb [out of the box](
  https://github.com/python/cpython/blob/master/Tools/gdb/libpython.py),
  LLDB might be the debugger of choice on some operating systems, e.g.
  on Mac OS.
  This extension requires CPython to be built with debugging symbols enabled, which
  is not the case for some Linux distros (notably Arch Linux). CPython official
  [Docker images](https://hub.docker.com/_/python) are known to work correctly, as they
  are used for integration testing.


pkgId: 330e9c7c1709d0e13fee473dc3eb3ea14f7514c3bb488658758b5a59b0f67627
name: python-cq-queryabolt
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://pypi.org/project/cq-queryabolt/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cq-queryabolt-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  A quick way to create nutcatches, screw holes and countersinks in CadQuery, according to fastener standards

description:
  A quick way to create nutcatches, screw holes and countersinks in CadQuery, according to fastener standards.

  ![Nutcatches, screw holes and countersinks](docs/img/simple.png).



  ```py
  poetry add cq-queryabolt
  ```



  To create a simple box with a bolt hole and a nutcatch:
  ```py
  import queryabolt
  import cadquery as cq

  class Workplane(queryabolt.WorkplaneMixin, cq.Workplane):
      pass

  box = Workplane().box(25, 10, 10)


  result = box.faces("<Z").workplane().tag("center").nutcatchParallel("M3")


  result = result.faces(">Z").workplane().boltHole("M3")

  show_object(result, name="simple")
  ```

  Or check out the example [showcasing all the features](./examples/simple.py), or [using a `cadquery.Assembly`](./examples/assembly.py).






  Make a bolt hole (`cadquery.Workplane.hole` for named fasteners)

  Args:
  * `bolt` (`str`): name of the bolt (e.g. `"M3"`)
  * `depth` (`float >= 0` or `None` to cut through the entire part): how deep to make the hole


  Make a counterbored hole (`cadquery.Workplane.cboreHole` for named fasteners)

  Args:
  * `bolt` (`str`): name of the bolt (e.g. `"M3"`)
  * `depth` (`float >= 0` or `None` to cut through the entire part): how deep to make the hole
  * `headClearance` (`float >= 0`, optional): additional bolt head clearance. Defaults to 0.1.


  Make a countersunk hole (`cadquery.Workplane.cskHole` for named fasteners)

  Args:
  * `bolt` (`str`): name of the bolt (e.g. `"M3"`)
  * `depth` (`float > 0` or `None` to cut through the entire part): how deep to make the hole


  Make a parallel (surface) nutcatch

  Args:
  * `options` (`str`): name of the nut (e.g. `"M3"`)
  * `kind` (`str`, optional): kind of the nut (e.g. `"hexagon"`). Defaults to `"hexagon"`.
  * `heightClearance` (float, optional): height clearance for the nut. Defaults to 0.


  Make a side-cut nutcatch

  Args:
  * `options` (`str`): name of the nut (e.g. `"M3"`)
  * `kind` (`str`, optional): kind of the nut (e.g. `"hexagon"`). Defaults to `"hexagon"`.
  * `heightClearance` (`float >= 0`, optional): additional height clearance for the nut. Defaults to 0.
  * `depth` (`float > 0` or `None` to cut through the entire part): how deep to make the sidecut. Defaults to `None`.


  * The [authors](https://github.com/boltsparts/boltsparts/graphs/contributors) of the [BOLTS](https://github.com/boltsparts/boltsparts) library


  The following turned out too verbose for the simpler end of the spectrum of my projects:
  * [`cqparts_fasteners`](https://cqparts.github.io/cqparts/doc/cqparts_fasteners/index.html)
  * [`cq_warehouse`'s `fastener` module](https://cq-warehouse.readthedocs.io/en/latest/fastener.html)

  Similar library for OpenSCAD, by yours truly:
  * [`catchnhole`](https://github.com/mmalecki/catchnhole)


pkgId: def8e5cdbca1b4899fe8c73707353b603b7490e0ff1f564c790940d5ecbbe63d
name: python-cq23
arch: src
version: 2.6.1
epoch: 0
release: 1
summary: CLI Tools for CodeQuest 23
url: https://github.com/CALED-Team/cq23-cli-utilities
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cq23-2.6.1-1.src.rpm
checksum_type: sha256
description:
  ```shell
  pip install cq23
  ```

  ```shell
  cq23 run
  cq23 run map=<map name>
  cq23 zip
  cq23 check
  cq23 cleanup
  ```


pkgId: 518dcc51f2b38d5c6dc1f9aa53854070edf5492f2c16326e238f35313cc9c32f
name: python-cqc
arch: src
version: 3.2.3
epoch: 0
release: 1
summary: The CQC interface
url: https://github.com/SoftwareQuTech/CQC-Python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cqc-3.2.3-1.src.rpm
checksum_type: sha256
description:
  The classical-quantum combiner (CQC) interface is an interface between higher layers and hardware in a Quantum Internet. It comes with a Python, C and Rust library for constructing CQC messages. The Python library is definitely the best place to get started.

  Documentation of CQC can be found at https://softwarequtech.github.io/CQC-Python/

  The CQC can be used to either program hardware which supports the interface or the simulator [https://github.com/SoftwareQuTech/SimulaQron](SimulaQron).

  More information about CQC can also be found in the paper on SimulaQron at https://arxiv.org/abs/1712.08032


pkgId: e7547e1410edc47e4a9ad7747429e08ab061c4b81c9dc0fe8ee25f4d6c27c8b5
name: python-cqgridfinity
arch: src
version: 0.5.7
epoch: 0
release: 1
summary: A python library to make Gridfinity compatible objects with CadQuery.
url: https://github.com/michaelgale/cq-gridfinity
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cqgridfinity-0.5.7-1.src.rpm
checksum_type: sha256
description:
  <!-- <img src=./images/logo.png width=320> -->
  ![cq-gridfinity Logo](./images/logo.png)



  [![](https://img.shields.io/pypi/v/cqgridfinity.svg)](https://pypi.org/project/cqgridfinity/)
  ![python version](https://img.shields.io/static/v1?label=python&message=3.9%2B&color=blue&style=flat&logo=python)
  [![](https://img.shields.io/static/v1?label=dependencies&message=CadQuery%202.0%2B&color=blue&style=flat)](https://github.com/CadQuery/cadquery)
  [![](https://img.shields.io/badge/CQ--kit-blue)](https://github.com/michaelgale/cq-kit)
  ![https://github.com/michaelgale/cq-kit/blob/master/LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)
  [![](https://img.shields.io/badge/code%20style-black-black.svg)](http://github.com/psf/black)

  This repository contains a python library to build [Gridfinity](https://gridfinity.xyz) boxes, baseplates, and other objects based on the [CadQuery](https://github.com/CadQuery/cadquery) python library.  The Gridfinity system was created by [Zach Freedman](https://www.youtube.com/c/ZackFreedman) as a versatile system of modular organization and storage modules.  A vibrant community of user contributed modules and utilities has grown around the Gridfinity system.  This repository contains python classes to create gridfinity compatible parameterized components such as baseplates and boxes.

  Examples of how I am starting to use Gridfinity to organize my tools are shown below using components built with this python library:

  <img src=./images/examples.png width=800>



  - [Installation / Usage](#installation)
  - [Shell Command Scripts](#shell-command-scripts)
    - [gridfinitybox](#gridfinitybox)
    - [gridfinitybase](#gridfinitybase)
    - [ruggedbox](#ruggedbox)
  - [Classes](#classes)
    - [GridfinityBaseplate](#gridfinitybaseplate)
    - [GridfinityBox](#gridfinitybox-1)
    - [GridfinityDrawerSpacer](#gridfinitydrawerspacer)
    - [GridfinityRuggedBox](#gridfinityruggedbox)
    - [GridfinityObject](#gridfinityobject)
  - [References](#references)



  **cq-gridfinity** has the following installation dependencies:
  - [CadQuery](https://github.com/CadQuery/cadquery)
  - [cq-kit](https://github.com/michaelgale/cq-kit)

  Assuming these dependencie are installed, you can install **cq-gridfinity** using a [PyPI package](https://pypi.org/project/cqgridfinity/) as follows:

  ```bash
  $ pip install cqgridfinity
  ```

  Alternatively, the **cq-gridfinity** package can be installed directly from the source code:

  ```bash
  $ git clone https://github.com/michaelgale/cq-gridfinity.git
  $ cd cq-gridfinity
  $ pip install .
  ```



  After installation, the package can imported:

  ```shell
  $ python
  >>> import cqgridfinity
  >>> cqgridfinity.__version__
  ```

  An example of the package can be seen below:

  ```python
  from cqgridfinity import *


  box = GridfinityBox(3, 2, 5, holes=True, no_lip=False, scoops=True, labels=True)
  box.save_stl_file()


  ```



  - [gridfinitybox](#gridfinitybox)
  - [gridfinitybase](#gridfinitybase)
  - [ruggedbox](#ruggedbox)

  This package can be used to make your own python scripts to generate Gridfinity objects.  This gives the flexibility to customize the object and combine with other code to add custom cutouts, add text labels, etc.

  However, for simple generation of standard objects such as baseplates and boxes, console scripts can be used for quick command line usage.  These console scripts are installed automatically into the path of your python environment and should be accessible from your terminal shell.



  <img src=./images/box_script.png width=600>

  Make a customized/parameterized Gridfinity compatible box with many optional features.

  ```
  usage: gridfinitybox [-h] [-m] [-u] [-n] [-s] [-l] [-e] [-d] [-r RATIO] [-ld LENGTHDIV] [-wd WIDTHDIV] [-wt WALL]
                       [-f FORMAT] [-o OUTPUT]
                       length width height

  Make a customized/parameterized Gridfinity compatible box with many optional features.

  positional arguments:
    length                Box length in U (1U = 42 mm)
    width                 Box width in U (1U = 42 mm)
    height                Box height in U (1U = 7 mm)

  options:
    -h, --help            show this help message and exit
    -m, --magnetholes     Add bottom magnet/mounting holes
    -u, --unsupported     Add bottom magnet holes with 3D printer friendly strips without support
    -n, --nolip           Do not add mating lip to the top perimeter
    -s, --scoops          Add finger scoops against each length-wise back wall
    -l, --labels          Add label strips against each length-wise front wall
    -e, --ecolite         Make economy / lite style box with no elevated floor
    -d, --solid           Make solid (filled) box for customized storage
    -r RATIO, --ratio RATIO
                          Solid box fill ratio 0.0 = minimum, 1.0 = full height
    -ld LENGTHDIV, --lengthdiv LENGTHDIV
                          Split box length-wise with specified number of divider walls
    -wd WIDTHDIV, --widthdiv WIDTHDIV
                          Split box width-wise with specified number of divider walls
    -wt WALL, --wall WALL
                          Wall thickness (default=1 mm)
    -f FORMAT, --format FORMAT
                          Output file format (STEP, STL, SVG) default=STEP
    -o OUTPUT, --output OUTPUT
                          Output filename (inferred output file format with extension)

  ```

  Examples:

  ```shell

  $ gridfinitybox 2 3 5 -m -f stl



  $ gridfinitybox 1 3 4 -s -l -ld 3 -o MyBox.step



  $ gridfinitybox 3 3 3 -d -r 0.5 -u -n



  $ gridfinitybox 3 2 3 -e -l -ld 2 -f svg

  ```



  <img src=./images/base_script.png width=600>

  Make a customized/parameterized Gridfinity compatible simple baseplate.

  ```
  usage: gridfinitybase [-h] [-f FORMAT] [-s] [-d DEPTH] [-hd HOLEDIAM] [-hc CSKDIAM] [-ca CSKANGLE] [-o OUTPUT]
                        length width

  Make a customized/parameterized Gridfinity compatible simple baseplate.

  positional arguments:
    length                Box length in U (1U = 42 mm)
    width                 Box width in U (1U = 42 mm)

  options:
    -h, --help            show this help message and exit
    -f FORMAT, --format FORMAT
                          Output file format (STEP, STL, SVG) default=STEP
    -s, --screws          Add screw mounting tabs to the corners (adds +5 mm to depth)
    -d DEPTH, --depth DEPTH
                          Extrude extended depth under baseplate by this amount
    -hd HOLEDIAM, --holediam HOLEDIAM
                          Corner mounting screw hole diameter (default=5)
    -hc CSKDIAM, --cskdiam CSKDIAM
                          Corner mounting screw countersink diameter (default=10)
    -ca CSKANGLE, --cskangle CSKANGLE
                          Corner mounting screw countersink angle (deg) (default=82)
    -o OUTPUT, --output OUTPUT
                          Output filename (inferred output file format with extension)
  ```

  Examples:

  ```shell

  $ gridfinitybase 7 4 -s -f stl

  ```



  <img src=./images/rugged_box.png width=600>

  Make a parameterized rugged storage box compatible with gridfinity. This box is based on the [superb design by Pred on Printables](https://www.printables.com/model/543553-gridfinity-storage-box-by-pred-now-parametric).  This implementation makes a few improvements and additions to Pred's design in addition to making almost all of the box's features optional and tunable.  Using either the `ruggedbox` console script or the `GridfinityRuggedBox` class, you can make vast variety of different boxes of various sizes and features.  By default, almost all of the boxes features are enabled, but by using the desired command line options you can customize your desired feature set.

  ```
  usage: ruggedbox [-h] [+l] [-l] [+p] [-p] [+w] [-w] [-wt WINDOWTHICKNESS] [+a] [-a] [+c] [-c] [+s] [-s] [+v] [-v]
                   [+e] [-e] [+b] [-b] [-r] [+r] [-f FORMAT] [-o OUTPUT] [-gb] [-gl] [-ga] [-gh] [-ge] [-gn] [-gt]
                   [-gw]
                   length width height

  Make a customized/parameterized Gridfinity compatible rugged box enclosure.
  The minimum box size is 3U x 3U x 4U.

  positional arguments:
    length                Box length in U (1U = 42 mm)
    width                 Box width in U (1U = 42 mm)
    height                Box height in U (1U = 7 mm)

  options:
    -h, --help            show this help message and exit
    +l, --label           Add label window across the front wall
    -l, --nolabel         Remove label window across the front wall
    +p, --lidbaseplate    Add baseplate to top of the lid
    -p, --nolidbaseplate  Smooth/plain lid
    +w, --lidwindow       Add window slot to the lid
    -w, --nolidwindow     Do not add window slot to the lid
    -wt WINDOWTHICKNESS, --windowthickness WINDOWTHICKNESS
                          Thickness of lid windows (mm)
    +a, --handle          Add front handle
    -a, --nohandle        No front handle
    +c, --clasps          Add clasps to the left and right side walls
    -c, --noclasps        No clasps on the left and right side walls
    +s, --stackable       Add stackable mating features to top and bottom
    -s, --notstackable    Non-stackable box
    +v, --veegroove       Add v-cut grooves to side walls
    -v, --noveegroove     No v-cut grooves (plain) side walls
    +e, --sidehandle      Add handles to side walls
    -e, --nosidehandle    No handles on side walls
    +b, --backfeet        Add standing feet to back wall
    -b, --nobackfeet      No standing feet added to back wall
    -r, --normalstyle     Make normal style box
    +r, --ribstyle        Make rib style box with exposed vertical ribs
    -f FORMAT, --format FORMAT
                          Output file format (STEP, STL, SVG) default=STEP
    -o OUTPUT, --output OUTPUT
                          Output filename (inferred output file format with extension)
    -gb, --box            Generate box
    -gl, --lid            Generate lid
    -ga, --acc            Generate accessory components
    -gh, --hinge          Generate hinge element
    -ge, --genlabel       Generate label panel insert
    -gn, --genhandle      Generate front handle
    -gt, --genlatch       Generate latch component
    -gw, --genwindow      Generate lid window component

  example usage:

    5 x 4 x 6 rugged box shell and lid saved to STL files:
    $ ruggedbox 5 4 6 --box --lid -f stl
  ```
  Examples:

  5 x 4 x 6 rugged box component saved to STL file:

  ```shell
  $ ruggedbox 5 4 6 -gb -f stl
   ____                             _ ____
  |  _ \ _   _  __ _  __ _  ___  __| | __ )  _____  __
  | |_) | | | |/ _` |/ _` |/ _ \/ _` |  _ \ / _ \ \/ /
  |  _ <| |_| | (_| | (_| |  __/ (_| | |_) | (_) >  <
  |_| \_\\__,_|\__, |\__, |\___|\__,_|____/ \___/_/\_\
               |___/ |___/

  Version: 0.5.7
  Gridfinity rugged box: 5U x 4U x 6U
    Exterior dim: 230.0 mm x 188.0 mm x 55.0 mm
    Interior dim: 210.0 mm x 168.0 mm x 45.8 mm
    Internal volume: 1.616 L
    Wall Vgrooves      : Y
    Front Handle       : Y
    Stackable          : Y
    Side Clasps        : Y
    Lid Baseplate      : Y
    Inside Baseplate   : Y
    Side Handles       : Y
    Front Label        : Y
    Back Feet          : Y
    Rib Style          : N
    Lid Window         : N
  Rendering box...
  Component generated and saved as gf_ruggedbox_5x4x6_body_fr-hl_sd-hc_stack_lidbp.stl in STL format
  $
  ```

  ```shell

  $ ruggedbox 5 4 6 --lid -f stl



  $ ruggedbox 5 5 9 --nohandle --nolidbaseplate --notstackable



  $ ruggedbox 5 4 6 --box --lid --hinge





  $ ruggedbox 5 4 6 --acc



  $ ruggedbox 5 4 6 --genhandle --genlatch -o orange.stl


  ```



  - [GridfinityBaseplate](#gridfinitybaseplate)
  - [GridfinityBox](#gridfinitybox-1)
  - [GridfinityDrawerSpacer](#gridfinitydrawerspacer)
  - [GridfinityRuggedBox](#gridfinityruggedbox)
  - [GridfinityObject](#gridfinityobject)




  Gridfinity baseplates can be made with the `GridfinityBaseplate` class.  The baseplate style is the basic style initially proposed by Zach Freedman.  Therefore, it does not have magnet or mounting holes.  An example usage is as follows:

  ```python

  baseplate = GridfinityBaseplate(4, 3)
  baseplate.save_step_file()

  ```
  <img src=./images/baseplate4x3.png width=512>

  Baseplates can be rendered with extra depth to make a taller overall baseplate using the `ext_depth` attribute.  Furthermore, mounting screws corner tabs can be added to the baseplate with the `corner_screws` attribute.  A baseplate with this feature is shown below.

  <img src=./images/baseplate6x3.png width=512>



  ```python
  ext_depth = 0            # extended depth to extrude below baseplate
  straight_bottom = False  # add/remove 0.8 mm chamfer on bottom of baseplate
  corner_screws = False    # add corner mounting screw tabs
  corner_tab_size = 21     # size of screw mounting tab (mm)
  csk_hole = 5.0           # hole diameter of countersink mounting screw (mm)
  csk_diam = 10.0          # countersink diameter (mm)
  csk_angle = 82           # countersink angle (deg)
  ```



  Gridfinity boxes with many optional features can be created with the `GridfinityBox` class.  As a minimum, this class is initialized with basic 3D unit dimensions for length, width, and height.  The length and width are multiples of 42 mm Gridfinity intervals and height represents multiples of 7 mm.



  ```python

  box = GridfinityBox(3, 2, 5)
  box.save_step_file()


  ```
  <img src=./images/basic_box.png width=512>



  "Lite" style boxes are simplified for faster 3D printing with less material.  They remove the continuous floor at 7.2 mm and the box becomes a homogenous 1 mm thick walled shell. "lite" style boxes can include labels and dividers; however, the number of dividers must correspond to the same bottom partition ridges, i.e. `length_div` must be `length_u - 1` and `width_div` must be `width_u - 1`.  "lite" style cannot be combined with solid boxes, finger scoops, or magnet holes.

  ```python

  box = GridfinityBox(3, 2, 5, lite_style=True)
  box.save_step_file()


  ```
  <img src=./images/box_lite.png width=512>



  ```python

  box = GridfinityBox(3, 2, 5, holes=True)
  box.save_step_file()

  ```
  <img src=./images/box_holes.png width=512>

  The `unsupported_holes` attribute can specify either regular holes or modified/unsupported holes which are more suitable for 3D-printing.  These modified holes include thin filler strips which allow the slicer to avoid using supports to render the underside holes.

  ```python

  box = GridfinityBox(1, 1, 5, holes=True, unsupported_holes=True)
  box.save_step_file()

  ```
  <img src=./images/box_holetypes.png width=512>



  ```python

  box = GridfinityBox(3, 2, 5, no_lip=True)
  box.save_step_file()

  ```
  <img src=./images/box_nolip.png width=512>



  ```python

  box = GridfinityBox(3, 2, 5, scoops=True, labels=True)
  box.save_step_file()

  ```
  <img src=./images/box_options.png width=512>



  ```python

  box = GridfinityBox(3, 2, 5, length_div=2, width_div=1, scoops=True, labels=True)
  box.save_step_file()

  ```
  <img src=./images/box_div.png width=512>



  ```python

  box = GridfinityBox(3, 2, 5, solid=True, solid_ratio=0.7)
  box.save_step_file()

  ```
  <img src=./images/box_solid.png width=512>



  ```python
  length_div=0            # add dividing walls along length
  width_div=0             # add dividing walls along width
  holes=False             # add magnet holes to bottom
  unsupported_holes=False # 3D-printer friendly hole style requiring no supports
  no_lip=False            # remove top mating lip feature
  scoops=False            # add finger scoops
  scoop_rad=11            # radius of optional interior scoops
  labels=False            # add a label flange to the top
  label_width=12          # width of the label strip
  label_height=10         # thickness height of label overhang
  label_lip_height=0.8    # thickness of label vertical lip
  lite_style=False        # make a "lite" version of box without elevated floor
  solid=False             # make a solid box
  solid_ratio=1.0         # ratio of solid height range 0.0 to 1.0 (max height)
  wall_th=1.0             # wall thickness (0.5-2.5 mm)
  fillet_interior=True    # enable/disable internal fillet edges
  ```



  The `GridfinityDrawerSpacer` class can be used to make spacer components to fit a drawer with any arbitrary dimensions.  Initialize with specified width and depth of the drawer (in mm) and the best fit of integer gridfinity baseplate units is computed.  Rarely, integer multiples of 42 mm gridfinity baseplates fit perfectly inside a drawer; therefore, spacers are required to secure the baseplate snuggly inside the drawer.  Spacers consist of 4x identical corner sections, 2x spacers for the left and right sides and 2x spacers for the front and back edges.

  If the computed spacer width falls below a configurable threshold (default 4 mm), then no spacer component is made in that dimension.  The spacer components are made by default with interlocking "jigsaw" type features to assist with assembly and to secure the spacers within the drawer.  Also, alignment arrows (default but optional) are placed on the components to indicate the installation orientation in the direction of the drawer movement.

  ```python

  spacer = GridfinityDrawerSpacer(582, 481, verbose=True)





  ```
  <img src=./images/drawer_photo.png width=600>


  A full set of components (optionally including a full baseplate) can be rendered with the `render_full_set()` method.  This method is mostly used to verify the fit and placement of the spacers.

  <img src=./images/full_set.png width=600>


  Normally, the `render_half_set()` method used to render half of the components compactly arranged conveniently for 3D printing.  This set can be printed twice to make a full set for a single drawer.

  <img src=./images/half_set.png width=600>



  ```python
  thickness=GR_BASE_HEIGHT # thickness of spacers, default=5 mm
  chamf_rad=1.0            # chamfer radius of spacer top/bottom edges
  show_arrows=True         # show orientation arrows indicating drawer in/out direction
  align_features=True      # add "jigsaw" interlocking feautures
  align_tol=0.15           # tolerance of the interlocking joint
  align_min=8              # minimum spacer width for adding interlocking feature
  min_margin=4             # minimum size to make a spacer, nothing is made for smaller gaps
  tolerance=GR_TOL         # overall tolerance for spacer components, default=0.5 mm
  ```


  An example use case to make a set of spacer components for a typical IKEA narrow ALEX drawer is as follows:

  ```python
  spacers = GridfinityDrawerSpacer(INCHES(11.5), INCHES(20.5), verbose=True)
  spacers.render_full_set(include_baseplate=True)
  spacers.save_step_file("ikea_alex_full_set.step")

  spacers.render_half_set()
  spacers.save_stl_file("ikea_alex_half_set.stl")
  ```

  <img src=./images/alexdrawer.png width=600>



  <img src=./images/rugged_box.png width=600>

  The `GridfinityRuggedBox` class can be used to make gridfinity compatible rugged storage boxes. This box is based on the [superb design by Pred on Printables](https://www.printables.com/model/543553-gridfinity-storage-box-by-pred-now-parametric).

  The **cq-gridfinity** derivative version of Pred's box is completely parameterized and generated completely with code in the `GridfinityRuggedBox` class.  This lets you render the most minimalist box configuration with no added features up to a full-featured box as shown below:

  <img src=./images/min_rugged_box.png width=600>

  The desired box size and features are specified with keyword arguments/attributes such as the ones illustrated below:

  <img src=./images/rugged_box_features.png width=600>

  A alternative "rib style" rugged box is also available.  This adds vertical rib stiffeners around the perimeter of the box and it is recommended to disable the side handles to allow for ribs to be generated on all sides.

  <img src=./images/ribstylebox.png width=600>

  Lastly, the lid baseplate can be substituted with a lid window which makes the contents of the box visible.  The window consists of a seperately prepared 1 mm thick transparent acrylic sheet cut to the required dimensions.  These dimensions can be queried with the `lid_window_size()` method or will be printed to the console when using the `ruggedbox` shell script.

  <img src=./images/lid_window.png width=600>

  After the lid has been printed the process to install the lid window is as follows:
  1. Cut the lid window to the required dimensions.  It is recommended to chamfer or round off the leading edge corners with a file prior to insertion.
  2. Slide the window into the lid starting from the back and along the tapered window groove slot around the inside perimeter of the lid.
  3. The window should be inserted just past the retention slots for the hinges.
  4. Secure the lid with 3x M2 screws along the back of the lid. Carefully drill 2.5 mm clearance holes into the window in situ prior to  installation of the screws. Alternatively, the lid can be secured with a few drops of super glue along the rear edge.
  5. Install the lid hinges.  The hinges must be installed last since they act as a physical retainer along the back edge of the window.

  The lid window should nominally be 1 mm thick; however if it necessary to use a different thickness material, the `window_th` attribute can be set.  It recommended to keep the window thickness in the range of 0.8 to 1.6 mm.

  The rugged box can be rendered either as a complete assembly or as individual components.  This is useful for making individual asset files for 3D printing.  The  render methods include the `render_assembly()` method as shown above for the complete assembly, as well as individual render methods summarized below:

  `render()` - renders just the main box body shell:

  <img src=./images/rugged_box_shell.png width=600>

  `render_lid()` - renders the lid:

  <img src=./images/rugged_box_lid.png width=600>

  `render_accessories()` - renders the accessory component elements as a group in the quantities required for the desired box:

  <img src=./images/rugged_box_acc.png width=600>

  Lastly, each individual component has an individual render method.

  - `render_hinge()`
  - `render_latch()`
  - `render_label()`
  - `render_handle()`



  ```python
  lid_height = 10            # lid height (should be multiple of 10 mm for stacking)
  wall_vgrooves = True       # enable horizontal v-grooves to body shell
  front_handle = True        # enable front handle
  stackable = True           # add mating stackable features
  side_clasps = True         # add extra side latching clasps
  lid_baseplate = True       # enable top/lid baseplate
  inside_baseplate = True    # enable interior baseplate
  side_handles = True        # enable side handles to box
  front_label = True         # enable front label panel
  label_length = None        # length of front label panel, None=auto size
  label_height = None        # height of front label panel, None=auto size
  label_th = GR_LABEL_TH     # thickness of label panel, default=0.5 mm
  back_feet = True           # add rear back feet matching hinges to allow the stand box vertically
  hinge_width = GR_HINGE_SZ  # Size of hinge, default=32 mm
  hinge_bolted = False       # printed or bolted hinge construction
  box_color = cq.Color(0.25, 0.25, 0.25)    # colors for the assembly STEP file
  lid_color = cq.Color(0.25, 0.5, 0.75)
  handle_color = cq.Color(0.75, 0.5, 0.25)
  latch_color = cq.Color(0.75, 0.5, 0.25)
  hinge_color = cq.Color(0.75, 0.5, 0.25)
  label_color = cq.Color(0.7, 0.7, 0.7)
  ```



  The `GridfinityObject` is the base class for `GridfinityBox`, `GridfinityBaseplate`, etc. It has several useful methods and attributes including:



  `obj.filename(self, prefix=None, path=None)` returns a filename string with descriptive attributes such as the object size and enabled features.

  ```python
  box = GridfinityBox(3, 2, 5, holes=True)
  box.filename()

  box.filename(prefix="MyBox")

  box.filename(path="./outputfiles")

  box2 = GridfinityBox(4, 3, 3, holes=True, length_div=2, width_div=1)
  box2.filename()

  ```

  ```python

  obj.save_step_file(filename=None, path=None, prefix=None)
  obj.save_stl_file(filename=None, path=None, prefix=None)
  obj.save_svg_file(filename=None, path=None, prefix=None)
  ```

  The automatic filename assignment is aware of the last object generated with a particular class's render method.  Therefore, you can call any render method and then call any of the `save_step_file`, `save_stl_file`, `save_svg_file` methods and the filename will adapt to the last object rendered.  For example:

  ```python
  b1 = GridfinityRuggedBox(5, 4, 6)
  b1.render_accessories()
  b1.save_step_file()

  b1.render_handle()
  b1.save_stl_file()

  b1.render_hinge()
  b1.save_svg_file(path="./mystuff")

  b1.render_assembly()
  b1.save_step_file()

  ```



  ```obj.cq_obj``` returns a rendered CadQuery Workplane object
  ```obj.length``` returns length in mm
  ```obj.width``` returns width in mm
  ```obj.height``` returns height in mm
  ```obj.top_ref_height``` returns the height of the top surface of a solid box or the floor height of an empty box.  This can be useful for making custom boxes with cutouts since the reference height can be used to orient the cutting solid to the correct height.



  - add more example scripts
  - improve documentation



  - v.0.1.0 - First release on PyPI
  - v.0.1.1 - Fixed release
  - v.0.2.0 - Added new "lite" style box
  - v.0.2.1 - Added new unsupported magnet hole types
  - v.0.2.2 - Added SVG export and integrated STL exporter
  - v.0.2.3 - Updated to python build tools to make distribution
  - v.0.3.0 - Added console generator scripts: `gridfinitybox` and `gridfinitybase`
  - v.0.4.0 - Added `GridfinityRuggedBox` class and `ruggedbox` console script. Various other improvements.
  - v.0.4.1 - Fixed docstring in `__init__.py`
  - v.0.4.2 - Improved script automatic renaming
  - v.0.4.3 - Fixed regression bug with using multilevel extrusion functions from cq-kit
  - v.0.4.4 - IMPORTANT FIX: generated geometry breaks using CadQuery v.2.4+ due to changes in CadQuery's `extrude` method.  This version should work with any CQ version since it detects which CQ extrusion implementation is used at runtime.
  - v.0.4.5 - IMPORTANT FIX: fixes error in v.0.4.4 for extrusion angle
  - v.0.5.0 - Improved rugged box to make viable boxes down to 3U x 3U x 4U
  - v.0.5.1 - Increased the resolution of the gridfinity extruded base profile
  - v.0.5.2 - Adjusted geometry of box/bin floor/lip heights to exactly 7.00 mm intervals
  - v.0.5.3 - Removed a potential namespace collision for computing the height of boxes
  - v.0.5.4 - Optimized the geometry of the baseplate top height
  - v.0.5.5 - Added underside bin clearance and variable wall thickness interior radiusing
  - v.0.5.6 - Added adjustable magnet hole diameter to box. Prevent drawer spacers being rendered which fall below minimum size
  - v.0.5.7 - Added scoops to lite-style boxes. Added new "rib style" rugged box. Added a lid window feature to the rugged box.



  - [Zach Freedman's YouTube Channel](https://www.youtube.com/c/ZackFreedman)
  - [The video that started it all!](https://youtu.be/ra_9zU-mnl8?si=EOT1LFV65VZfiepi)
  - [Gridfinity Documentation repo](https://github.com/Stu142/Gridfinity-Documentation)
  - [Gridfinity Unofficial wiki](https://gridfinity.xyz)
  - Catalogs
    - [gridfinity-catalog](https://github.com/jeffbarr/gridfinity-catalog)
    - [Master Collection on Printables](https://www.printables.com/model/242711-gridfinity-master-collection)
  - Software/Tools
    - [Online Gridfinity Creator](https://gridfinity.bouwens.co)
    - [Gridfinity rebuilt OpenSCAD library](https://github.com/kennetek/gridfinity-rebuilt-openscad)
    - [Gridfinity Fusion360 generator plugin](https://github.com/Le0Michine/FusionGridfinityGenerator)
    - [FreeCAD Gridfinity Parametric Files (on Printables)](https://www.printables.com/@Stu142_524934/collections/969910)
    - [Gridfinity eco (low-cost Gridfinity resources)](https://github.com/jrymk/gridfinity-eco)
    - [Another CadQuery based Gridfinity script](https://github.com/kmeisthax/gridfinity-cadquery)
  - Videos
    - [Zach Freedman's follow-up Jul 2022](https://youtu.be/Bd4NnHvTRAY?si=rvgb9geXnq83mhOv)
    - [Zach Freedman's follow-up Dec 2022](https://youtu.be/7FCwMq-rVsY?si=tdqAe8MthGjfWEbR)
    - [The Next Layer tips video](https://youtu.be/KtbKwAuwv9s?si=1hYPjOvqf8tb5NO9)



  **cq-gridfinity** was written by [Michael Gale](https://github.com/michaelgale)


pkgId: e56cd468593409e2fd4c415b5cd6a8343583d65e0bd7c8b685cddc9fe89355fe
name: python-cqlalchemy
arch: src
version: 0.0.1
epoch: 0
release: 1
url: https://pypi.org/project/cqlalchemy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cqlalchemy-0.0.1-1.src.rpm
checksum_type: sha256
summary:
  library for constructing cql2-json queries and for generating libraries with multiple STAC extensions"

description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

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

  [![PyPI-Server](https://img.shields.io/pypi/v/cqlalchemy.svg)](https://pypi.org/project/cqlalchemy/)



  > Library to help make CQL2-json queries a little easier!

  STAC is a terrific specification for cataloging temporal/spatial data with an emphasis on providing queryable fields for searching that data. One of the ways to make complex queries is to use cql2-json. This query language can be a bit verbose and requires a good amount of memorization to make complex queries.

  This project provides to different functionalities. One is the `cqlalchemy.stac.query` module which provides query construction class (`QueryBlock`) with the most popular extensions (eo, sar, sat, view, mlm).

  The other functionality is a scriptthat allows the user to build their own `QueryBlock` class from extensions of their choosing, and allowing the opportunity to restrict the fields that can be queried (in the case where it isn't a required field and it's existence in the class might mislead the user).


pkgId: f1b1a2aebe82745260e3d142a3aeae80606aa5b972405c080255d46738324aea
name: python-cqlalchemy
arch: src
version: 0.0.5
epoch: 0
release: 1
url: https://pypi.org/project/cqlalchemy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cqlalchemy-0.0.5-1.src.rpm
checksum_type: sha256
summary:
  library for constructing cql2-json queries and for generating libraries with multiple STAC extensions"

description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

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

  [![PyPI-Server](https://img.shields.io/pypi/v/cqlalchemy.svg)](https://pypi.org/project/cqlalchemy/)



  > Library to help make CQL2-json queries a little easier!

  STAC is a terrific specification for cataloging temporal/spatial data with an emphasis on providing queryable fields for searching that data. One of the ways to make complex queries is to use cql2-json. This query language can be a bit verbose and requires a good amount of memorization to make complex queries.

  This project provides to different functionalities. One is the `cqlalchemy.stac.query` module which provides query construction class (`QueryBuilder`) with the most popular extensions (eo, sar, sat, view, mlm).

  The other functionality is a script that allows the user to build their own `QueryBuilder` class from extensions of their choosing, and allowing the opportunity to restrict the fields that can be queried (in the case where it isn't a required field and it's existence in the class might mislead the user).


pkgId: 5a0a7310f82f300679e75731b50f7da74f80e3095700026f79a2917b0eaa5fc2
name: python-cqlsh
arch: src
version: 6.2.0
epoch: 0
release: 1
summary: cqlsh is a Python-based command-line client for running CQL commands on a cassandra cluster.
url: https://github.com/jeffwidman/cqlsh
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cqlsh-6.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cqlsh.svg)](https://badge.fury.io/py/cqlsh)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cqlsh)
  [![Downloads](https://pepy.tech/badge/cqlsh)](https://pepy.tech/project/cqlsh)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)



  `cqlsh` is a Python-based command-line client for running `CQL` commands on a `cassandra` cluster.

  Normally it's packaged as part of the full Apache Cassandra™ installation. This repo repackages it into a standalone Python package for lighter-weight installs.



  Install and update using [`pip`](https://pip.pypa.io/en/stable/quickstart/):
  ```
  $ pip install -U cqlsh
  ```



  ```
  $ cqlsh --help
  ```



  Documentation is available as part of the official [Apache Cassandra™ documentation](https://cassandra.apache.org/doc/latest/tools/cqlsh.html).



  Because this is a repackaging of `cqlsh` from the official [Cassandra repo](https://gitbox.apache.org/repos/asf/cassandra.git), **only issues / PRs related to PyPI packaging should be opened against this repo**. If you would like to contribute to `cqlsh` itself, [find out more information here](https://github.com/apache/cassandra/blob/trunk/CONTRIBUTING.md).

  Steps to sanity check that the packaging works as expected:

  1. Install `cqlsh` locally (probably in a `virtualenv`):
  ```
  $ pip install -e .  # run from within the cqlsh directory
  ```
  2. Start a local copy of Cassandra:
  ```
  $ docker pull cassandra
  $ docker run -it --rm -p 9042:9042 cassandra
  ```
  3. Verify `cqlsh` successfully connects to the server:
  ```
  $ cqlsh

  Connected to Test Cluster at 127.0.0.1:9042
  [cqlsh 6.1.0 | Cassandra 4.1.0 | CQL spec 3.4.5 | Native protocol v5]
  Use HELP for help.
  cqlsh>
  ```

  This PyPI package is maintained by [Jeff Widman](https://github.com/jeffwidman) and [Brad Schoening](https://github.com/bschoening). Previous maintainers: [Spiro](https://github.com/spiside) and [Andrew Mussey](https://github.com/amussey).




  Unfortunately the Cassandra project does not always increment the `cqlsh` version number, so for every
  release we need to document not only the `cqlsh` version but also the `cassandra` version in which it
  shipped.



  This packages `cqlsh` `6.2.0` from [Cassandra 5.0.0](https://github.com/apache/cassandra/blob/cassandra-5.0.0/pylib/cqlshlib):
   * Add HISTORY command for CQLSH (CASSANDRA-15046)
   * Add CQLSH command SHOW REPLICAS (CASSANDRA-17577)
   * Cassandra 5.0 has refactored all cqlsh logic to be in cqlshlib, with the new cqlshmain.py replacing behavior formerly in bin/cqlsh.py
   * Replace 'wcwidth.py' with pypi module (CASSANDRA-17287)



  This packages `cqlsh` `6.1.0` from [Cassandra 4.1.4](https://github.com/apache/cassandra/blob/cassandra-4.1.4/bin/cqlsh.py):
   * CQLSH emits a warning when the server version doesn't match (CASSANDRA-18745)
   * Fix CQLSH online help topic link (CASSANDRA-17534)



  This packages `cqlsh` `6.1.0` from [Cassandra 4.1.1](https://github.com/apache/cassandra/blob/cassandra-4.1.1/bin/cqlsh.py):
  * Now supports Python 3.11.
  * Although this is pulled from a Cassandra `4.x` release, it is protocol compatible with Cassandra `3.x` clusters, with the exception of `DESCRIBE` keywords which require a 4.x cluster.





  This packages `cqlsh` `6.1.0` from [Cassandra 4.1](https://github.com/apache/cassandra/blob/cassandra-4.1.0/bin/cqlsh.py):
  * Requires Python 3.6+.
  * Although this is pulled from a Cassandra `4.x` release, it is protocol compatible with Cassandra `3.x` clusters, with the exception of `DESCRIBE` keywords which require a 4.x cluster.



  The actual source code is identical to the `cqlsh` `6.0.0` release, except it's now packaged as
  a module. This allows it to be used as a library, not just an executable script. It also provides
  better Windows support. Details in https://github.com/jeffwidman/cqlsh/pull/7 by @bschoening.

  Note: This release was yanked from PyPI because it [broke Python 2 compatibility](https://github.com/jeffwidman/cqlsh/issues/11).



  This packages `cqlsh` `6.0.0` from [Cassandra 4.0](https://github.com/apache/cassandra/blob/cassandra-4.0.0/bin/cqlsh.py):
  * Requires Python 3.6+ or 2.7 (although support for Python 2 is deprecated).
  * Although this is pulled from a Cassandra `4.x` release, it should generally work against Cassandra `3.x` clusters without needing to set any flags.




  This packages `cqlsh` `5.0.1` from [Cassandra 4.0-beta4](https://github.com/apache/cassandra/blob/cassandra-4.0-beta4/bin/cqlsh.py):
  * Now supports Python 3.
  * Although this is pulled from a Cassandra `4.x` release, it should generally work against Cassandra `3.x` clusters without needing to set any flags.



  This packages `cqlsh` `5.0.1` from [Cassandra 3.11.10](https://github.com/apache/cassandra/blob/cassandra-3.11.10/bin/cqlsh.py).



  This packages `cqlsh` `5.0.1` from [Cassandra 3.4.0](https://github.com/apache/cassandra/blob/cassandra-3.4/bin/cqlsh.py).




  This packages `cqlsh` `5.0.1` from [Cassandra 2.2.0](https://github.com/apache/cassandra/blob/cassandra-2.2.0/bin/cqlsh.py).




  This packages `cqlsh` `4.1.1` from [Cassandra 2.0.5](https://github.com/apache/cassandra/blob/cassandra-2.0.5/bin/cqlsh).




  This packages `cqlsh` `4.1.0` from [Cassandra 2.0.3](https://github.com/apache/cassandra/blob/cassandra-2.0.3/bin/cqlsh).




  This packages `cqlsh` `4.0.1` from [Cassandra 2.0.1](https://github.com/apache/cassandra/blob/cassandra-2.0.1/bin/cqlsh).


pkgId: b8a6f35cc91f407b9a16cbd24193ba910b406c218f20c45930fa79d9fd149c18
name: python-cqlsh-expansion
arch: src
version: 0.9.6
epoch: 0
release: 1
summary: The cqlsh-expansion utility extends native cqlsh functionality to include cloud native capabilities
url: https://github.com/aws-samples/amazon-keyspaces-toolkit/tree/master/cqlsh-expansion
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cqlsh-expansion-0.9.6-1.src.rpm
checksum_type: sha256
description:
  The Amazon Keyspaces toolkit contains common Cassandra tooling and helpers preconfigured for Amazon Keyspaces. The cqlsh-expansion utility extends native cqlsh functionality to include parameters and capabilities specific to Amazon Keyspaces without breaking compatibility with Apache Cassandra. This includes support for the Sigv4 Authentication plugin. Normally, cqlsh is packaged with the full distribution of Apache Cassandra, but since Amazon Keyspaces is a serverless database service, we only require the cqlsh scripts and not the full distribution. This repository provides a lightweight distribution of cqlsh that can be installed on platforms that support python.




  To install the cqlsh-expansion python package you can run the following pip command. The command below executes a “pip install” that will install the cqlsh-expansion scripts. It will also install a requirements file containing a list of dependencies. The --`user` flag tells pip to use the Python *user install directory* for your platform. Typically ~/.local/ on unix based systems.

  ```
  pip install --user cqlsh-expansion
  ```

  Alternatively, if you are using python3 as default you may have to use the following command to install the cqlsh-expansion package.

  ```
  python3 -m pip install --user cqlsh-expansion
  ```



  To use the cqlsh-expansion with Amazon Keyspaces you can use the following post install script or by following the instructions found in the official [Amazon Keyspaces documentation.](https://docs.aws.amazon.com/keyspaces/latest/devguide/programmatic.cqlsh.html)

  By default the cqlsh-expansion is not configured with ssl enabled, but the package includes a [post install script](https://github.com/aws-samples/amazon-keyspaces-toolkit/blob/master/cqlsh-expansion/config/post_install.py) helper to quickly setup your environment after installation. The script will place the necessary configuration and SSL certificate in the user’s *.cassandra* directory. Amazon Keyspaces only accepts secure connections using Transport Layer Security (TLS). Encryption in transit provides an additional layer of data protection by encrypting your data as it travels to and from Amazon Keyspaces. The post install script first will create the .cassandra directory if it does not exist already. Then it will copy a [preconfigure a cqlshrc file](https://github.com/aws-samples/amazon-keyspaces-toolkit/blob/master/cqlsh-expansion/config/cqlshrc_template) and the Starfield digital certificate into the .cassandra directory. The .cassandra directory will be created in the user home directory as it is the default location. As best practice, please review the [post install script](https://github.com/aws-samples/amazon-keyspaces-toolkit/blob/master/cqlsh-expansion/config/post_install.py)before executing. Modifications made by this post install script will not be undone if uninstalling the cqlsh-expansion with pip.

  ```

  cqlsh-expansion.init

  ```



  Now that you have you cqlsh-expansion installed and have setup up the configuration for SSL communication with Amazon Keyspaces, you can now connect to the Amazon Keyspaces services using your IAM access keys or Service Specific Credentials.



  To connect to Amazon Keyspaces you will need to choose one of the [service endpoints](https://docs.aws.amazon.com/keyspaces/latest/devguide/programmatic.endpoints.html). You can also connect to Amazon Keyspaces using [Interface VPC endpoints](https://docs.aws.amazon.com/keyspaces/latest/devguide/vpc-endpoints.html) to enable private communication between your virtual private cloud (VPC) running in Amazon VPC and Amazon Keyspaces. For example, to connect to the Keyspaces service in US East (N. Virginia) (us-east-1) you will want to use the [cassandra.us-east-1.amazonaws.com](http://cassandra.us-east-1.amazonaws.com/) service endpoint.  All communication with Amazon Keyspaces will be over port 9142.


  To provide users and applications with credentials for programmatic access to Amazon Keyspaces resources, you can do either of the following:



  For enhanced security, we recommend to create IAM access keys for IAM users and roles that are used across all AWS services. To use IAM access keys to connect to Amazon Keyspaces, customers can use the Signature Version 4 Process (SigV4) authentication plugin for Cassandra client drivers. To learn more about how the Amazon Keyspaces SigV4 plugin enables [IAM users, roles, and federated identities](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) to authenticate in Amazon Keyspaces API requests, see [AWS Signature Version 4 process (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).

  After you have the credentials setup with [privileges](https://docs.aws.amazon.com/keyspaces/latest/devguide/security_iam_service-with-iam.html) to access Amazon Keyspaces system tables, you can execute the following command to connect to Amazon Keyspaces with CQLSH using the Sigv4 process.

  Validate the module name and classname, region_name based on keyspaces endpoint in cqlshrc file.

  ```
  [auth_provider]
  ;; you can specify any auth provider found in your python environment
  ;; module and class will be used to dynamically load the class
  ;; all other properties found here and in the credentials file under the class name
  ;; will be passed to the constructor
  module = cassandra_sigv4.auth
  classname = SigV4AuthProvider
  region_name = us-east-1
  ```
  you can also set region as Environment variable

  ```
   export AWS_DEFAULT_REGION=us-east-1
  ```

  To connect to Amazon Keyspaces with cqlsh-expansion using Sigv4 authenticator.
  ```
  cqlsh-expansion cassandra.us-east-1.amazonaws.com 9142 --ssl
  ```



  You can create service-specific credentials that are similar to the traditional username and password that Cassandra uses for authentication and access management. AWS service-specific credentials are associated with a specific AWS Identity and Access Management (IAM) user and can only be used for the service they were created for. For more information, see [Using IAM with Amazon Keyspaces (for Apache Cassandra)](http://using%20iam%20with%20amazon%20keyspaces%20%28for%20apache%20cassandra%29/) in the IAM User Guide. To connect to Amazon Keyspaces using the cqlsh-expansion and IAM service-specific credentials you can use the command below. In this command we are connecting to us-east-1 region with service specific user *‘Sri-user-99’ *and service specific user password* ‘user-pass-01’. *You will need to replace these credentials with your own user name and password that were given to you when creating the service specific credentials.


  ```
  [auth_provider]
  ;; you can specify any auth provider found in your python environment
  ;; module and class will be used to dynamically load the class
  ;; all other properties found here and in the credentials file under the class name
  ;; will be passed to the constructor
  module = cassandra.auth
  classname = PlainTextAuthProvider
  ```

  ```
  cqlsh-expansion cassandra.us-east-1.amazonaws.com -u Sri-user-99 -p user-pass-01
  ```



  To remove the cqlsh-expansion package you can use the pip uninstall api. Additionally, if you executed the post install script ```cqlsh-expansion.init```, you may want to delete the .cassandra directory which contains the cqlshrc file and the ssl certificate. Using pip uninstall will not remove changes made by the post install script.

  ```
  pip uninstall cqlsh-expansion
  ```



  When creating a new cqlsh session with the cqlsh-expansion utility, it will show the default consistency level after establishing a new connection. We find customers using cqlsh may not be aware of the default consistency level of `ONE`, and additional transparency will lead to better operational excellence.



  When executing the `COPY FROM` import operation from the cqlsh-expansion utility, `LOCAL_QUORUM` will be strictly enforced. Executing `COPY FROM` with consistency level other than LOCAL_QUORUM will result in an SyntaxError. This restriction is to provide better experience when using `COPY FROM` with Amazon Keyspaces. Amazon Keyspaces replicates all write operations three times across multiple Availability Zones for durability and high availability. Writes are durably stored before they are acknowledged using the `LOCAL_QUORUM` consistency level.
  When executing the `COPY TO` export operation from the cqlsh-expansion utility, consistency of `ONE, LOCAL_ONE, or LOCAL_QUORUM` will be strictly enforced. Executing `COPY FROM` with consistency level other than these three will result in an SyntaxError. This restriction is to provide better experience when using `COPY FROM` with Amazon Keyspaces.



  ```



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



  This library is licensed under the MIT-0 License. See the LICENSE file.
  ```


pkgId: e597fee72bf2b61cfc435a56081533a96b7d3b7c4d3b5dd4d065b8bb8005b0ec
name: python-cqml
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Composable Query Meta Language
url: https://github.com/TheSwanFactory/cqml
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cqml-0.4.5-1.src.rpm
checksum_type: sha256
description:
  Composable Query Meta Language

  CQML is declarative data format for specifying complete data analysis pipelines.  It is most commonly implemented as YAML, but can trivially be transformed into JSON, CSON, or macOS and Java property lists.

  The initial back-end is written for the DataBrick's flavor of PySpark and Spark SQL, but should be easy to extend to other databases and warehouses.


  ```

  pip install cqml #==0.3.0
  import cqml
  ```


  From top-level directory:
  ```
  $ python3 -m pip install -r requirements.txt
  $ pip install pytest
  $ python3 -m pytest
  ```



  ```
  $ python3 -m pip install --upgrade build
  $ python3 -m pip install --upgrade twine
  $ prerelease && release && python3 -m build && python3 -m twine upload dist/* && postrelease
  ```


  ```
  awk -Fv '{printf("%sv%d\n",$1,v$2+1)}' version.txt > /tmp/version.txt && cp /tmp/version.txt version.txt && git commit -a && git push
  ```


pkgId: dff2ee381f748c2ff3b0a75f8ab5e07bf26b56a64d1ea434a86a626943b108f3
name: python-cr-checker
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A script to check for copyright headers in files.
url: https://github.com/nradakovic/copyright-checker
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cr-checker-0.1.0-1.src.rpm
checksum_type: sha256
description:
  `cr_checker.py` is a tool designed to check if files contain a specified copyright header. It provides configurable logging, color-coded console output, and can handle large file sets efficiently. The script supports reading configuration files for custom copyright templates and can utilize memory-mapped file reading for better performance with large files.



  - Checks files for specified copyright headers based on file extensions.
  - Configurable logging, including color-coded output for easy visibility of log levels.
  - Supports parameter files for flexible input handling.
  - Can use memory mapping for large file handling.
  - Customizable file encoding and offset adjustments for header text positioning.



  - Python 3.6+
  - `argparse`, `logging`, `os`, `sys`, `mmap`, and `configparser` (standard library modules)



  To use `cr_checker.py`, simply clone this repository or copy the script into your project.

  ```bash
  git clone <your_repo_url>
  ```



  The script can be run from the command line with various options to customize its behavior:

  ```bash
  python cr_checker.py -t <template_file> [options] <inputs>
  ```



  - -t, --template-file: (Required) Path to the template file that defines the copyright text for each file extension.
  - -v, --verbose: Enable debug-level logging.
  - -l, --log-file: Path to a log file where logs will be saved. If not provided, logs will print to the console.
  - -e, --extensions: List of file extensions to filter, e.g., -e .py .cpp.
  - --use_memory_map: Use memory-mapped file reading for large files.
  - --encoding: File encoding (default is utf-8).
  - --offset: Additional offset for the header length to account for lines like a shebang.
  - inputs: Directories or files to parse, or a parameter file prefixed with @ that lists files or directories.



  ```sh
  python cr_checker.py -t templates.ini -v -l logs.txt -e .py .cpp @files_to_check.txt

  python cr_checker.py -t templates.ini -e .py .cpp --offset 24 --use_memory_map @files_to_check.txt
  ```



  The template file should be in INI format, with each section representing a file extension and a template key specifying the copyright text.

  Example templates.ini:

  ```ini
  [py,sh]
  template = # Copyright (c) 2024 Nikola Radakovic

  [cpp,c,h]
  template = // Copyright (c) 2024 Nikola Radakovic
  ```



  - 0: All files contain the required copyright text.
  - 1: Some files are missing the required copyright text.
  - Other: Error encountered during file processing.



  By default, logs are printed to the console in color-coded format to indicate log levels. You can redirect logs to a file using the -l option.



  - DEBUG: Blue
  - INFO: Green
  - WARNING: Yellow
  - ERROR: Red



  MIT License


pkgId: df826256492858b1953cdb7131200c70ef349a130f401b5495a703d9e43d9de1
name: python-cr-cube
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: Crunch.io Cube library
url: https://github.com/Crunch-io/crunch-cube/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cr-cube-3.1.1-1.src.rpm
checksum_type: sha256
description:
  Open Source Python implementation of the API for working with CrunchCubes

  This package contains the implementation of the CrunchCube API. It is used to
  extract useful information from CrunchCube responses (we'll refer to them as
  _cubes_ in the subsequent text). _Cubes_ are obtained from the _Crunch.io_
  platform, as JSON responses to the specific _queries_ created by the user.
  These queries specify which data the user wants to extract from the Crunch.io
  system. The most common usage is to obtain the following:
  - Cross correlation between different variable
  - Margins of the cross tab _cube_
  - Proportions of the cross tab _cube_ (e.g. proportions of each single element to the entire sample size)
  - Percentages
  When the data is obtained from the Crunch.io platform, it needs to be
  interpreted to the form that's convenient for a user. The actual shape of the
  _cube_ JSON contains many internal details, which are not of essence to the
  end-user (but are still necessary for proper _cube_ functionality).
  The job of this library is to provide a convenient API that handles those
  intricacies, and enables the user to quickly and easily obtain (extract) the
  relevant data from the _cube_. Such data is best represented in a table-like
  format. For this reason, the most of the API functions return some form of the
  `ndarray` type, from the `numpy` package. Each function is explained in greater
  detail, uner its own section, under the API subsection of this document.

  The `cr.cube` package can be installed by using the `pip install`:
      pip install cr.cube

  For development mode, `cr.cube` needs to be installed from the local checkout
  of the `crunch-cube` repository. It is strongly advised to use `virtualenv`.
  Assuming you've created and activated a virtual environment `venv`, navigate
  to the top-level folder of the repo, on the local file system, and run:
      pip install -e .
  or
      python setup.py develop

  To setup and run tests, you will need to install `cr.cube` as well as testing
  dependencies. To do this, from the root directory, simply run:
      pip install -e .[testing]
  And then tests can be run using `py.test` in the root directory:
      pytest

  After the `cr.cube` package has been successfully installed, the usage is as
  simple as:
      >>> from cr.cube.cube import Cube
      >>> ### Obtain the crunch cube JSON payload using app.crunch.io, pycrunch, rcrunch or scrunch
      >>> ### And store it in the 'cube_JSON_response' variable
      >>> cube = Cube(cube_JSON_response)
      >>> print(cube)
      Cube(name='MyCube', dimension_types='CAT x CAT')
      >>> cube.counts
      np.array([[1169, 547],
                [1473, 1261]])


pkgId: 7c3f580addc044baee4d5f7eb36dff5068861f304b8178bfcda8a90af9566293
name: python-cr-cube
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: Crunch.io Cube library
url: https://github.com/Crunch-io/crunch-cube/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cr-cube-3.1.2-1.src.rpm
checksum_type: sha256
description:
  Open Source Python implementation of the API for working with CrunchCubes

  This package contains the implementation of the CrunchCube API. It is used to
  extract useful information from CrunchCube responses (we'll refer to them as
  _cubes_ in the subsequent text). _Cubes_ are obtained from the _Crunch.io_
  platform, as JSON responses to the specific _queries_ created by the user.
  These queries specify which data the user wants to extract from the Crunch.io
  system. The most common usage is to obtain the following:
  - Cross correlation between different variable
  - Margins of the cross tab _cube_
  - Proportions of the cross tab _cube_ (e.g. proportions of each single element to the entire sample size)
  - Percentages
  When the data is obtained from the Crunch.io platform, it needs to be
  interpreted to the form that's convenient for a user. The actual shape of the
  _cube_ JSON contains many internal details, which are not of essence to the
  end-user (but are still necessary for proper _cube_ functionality).
  The job of this library is to provide a convenient API that handles those
  intricacies, and enables the user to quickly and easily obtain (extract) the
  relevant data from the _cube_. Such data is best represented in a table-like
  format. For this reason, the most of the API functions return some form of the
  `ndarray` type, from the `numpy` package. Each function is explained in greater
  detail, uner its own section, under the API subsection of this document.

  The `cr-cube` package can be installed by using the `pip install`:
      pip install cr-cube

  For development mode, `cr.cube` needs to be installed from the local checkout
  of the `crunch-cube` repository. It is strongly advised to use `virtualenv`.
  Assuming you've created and activated a virtual environment `venv`, navigate
  to the top-level folder of the repo, on the local file system, and run:
      pip install -e .
  or
      python setup.py develop

  To setup and run tests, you will need to install `cr.cube` as well as testing
  dependencies. To do this, from the root directory, simply run:
      pip install -e .[testing]
  And then tests can be run using `py.test` in the root directory:
      pytest

  After the `cr.cube` package has been successfully installed, the usage is as
  simple as:
      >>> from cr.cube.cube import Cube
      >>> ### Obtain the crunch cube JSON payload using app.crunch.io, pycrunch, rcrunch or scrunch
      >>> ### And store it in the 'cube_JSON_response' variable
      >>> cube = Cube(cube_JSON_response)
      >>> print(cube)
      Cube(name='MyCube', dimension_types='CAT x CAT')
      >>> cube.counts
      np.array([[1169, 547],
                [1473, 1261]])


pkgId: caa6bbe015b8daee4ea4f3d29821da7a97742834b30f1c6f788b4c0391bd11f2
name: python-cr.cube
arch: src
version: 3.0.45
epoch: 0
release: 1
summary: Crunch.io Cube library
url: https://github.com/Crunch-io/crunch-cube/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cr.cube-3.0.45-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/Crunch-io/crunch-cube.png?branch=master)](https://travis-ci.org/Crunch-io/crunch-cube)
  [![Coverage Status](https://codecov.io/gh/Crunch-io/crunch-cube/branch/master/graph/badge.svg?token=C6auKOj8tZ)](https://codecov.io/gh/Crunch-io/crunch-cube)


pkgId: b1bc1b372949fb2712221fb9069daefab00d41550cb6a9d268f8ff252da22b5d
name: python-crab-lib
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A Python library for analyzing GPS data from fishing grounds.
url: https://github.com/RedGloveProductions/crab-lib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crab-lib-1.0.0-1.src.rpm
checksum_type: sha256
description:
  - **Data I/O**:
    - Load and save GPS data in CSV format.
    - Validate and handle missing or malformed data.
  - **Data Preprocessing**:
    - Remove duplicates and invalid rows.
    - Filter data based on keywords in comments.
    - Standardize comment text for consistency.
  - **Geospatial Analysis**:
    - Calculate great-circle distances using the Haversine formula.
    - Identify clusters of GPS points based on proximity.
    - Summarize datasets with averages and bounding boxes.
  - **Visualization**:
    - Plot points, clusters, and density heatmaps.
    - Create interactive and informative visualizations.
  - **Utilities**:
    - Convert coordinates from DMS to decimal degrees.
    - Calculate initial bearings between two GPS points.


pkgId: 374a808692b152abbdfda4c5c793b88b6a149fce42c611a39b065629ff495ae9
name: python-crabpy
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Interact with geographical webservices by Informatie Vlaanderen.
url: https://pypi.org/project/crabpy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crabpy-1.4.0-1.src.rpm
checksum_type: sha256
description:
  This library provides access to the CRAB and CAPAKEY webservices operated by
  the AGIV. Because connecting to these SOAP services from python can be somewhat
  complicated, this library makes it easier.

  [![docs](https://readthedocs.org/projects/crabpy/badge/?version=latest)](https://readthedocs.org/projects/crabpy/?badge=latest)
  [![pypi](https://badge.fury.io/py/crabpy.png)](http://badge.fury.io/py/crabpy)
  [![CI](https://github.com/OnroerendErfgoed/crabpy/actions/workflows/backend.yaml/badge.svg)](https://github.com/OnroerendErfgoed/crabpy/actions/workflows/backend.yaml)
  [![Coverage](https://coveralls.io/repos/OnroerendErfgoed/crabpy/badge.png?branch=master)](https://coveralls.io/r/OnroerendErfgoed/crabpy?branch=master)




  ```sh
  pip install hatch
  hatch build
  hatch build -t wheel
  hatch build -t sdist
  ```




  full docs: https://pip-tools.readthedocs.io/en/latest/

  To start, first install pip-tools:
  ```sh
  pip install pip-tools
  ```



  You can also use `uv` and for the remainder of the readme replace `pip`, `pip-compile` or
  `pip-sync` by `uv pip`, `uv pip compile` and `uv pip sync`.

  `uv` is a very fast replacement for pip-toools. It's optional, but can save a lot of time.
  ```sh
  pip install uv
  ```



  Note, `pip-sync` also uninstalls everything from the virtualenv which does not belong
  there according to the requirements file. This includes the project itself. You will
  have to install `crabpy` again after `pip-sync`.
  Since the requirements file of pip-sync is still a normal requirements file you can also
  use `pip install -r` to install all libraries defined in it. This will not cleanup your
  virtualenv and uninstall other libraries.

  The compiled requirements files are made in a 3.11 environment.
  ```sh
  pip-sync requirements-dev.txt
  pip install -e .
  ```
  `requirements-dev.txt` contains all libraries uncluding those for testing and development.

  `requirements.txt` contains only the necessary libraries for running the library.



  ```sh
  echo -e "\nStarting"
  PIP_COMPILE_ARGS="-q --strip-extras --no-header --resolver=backtracking --no-emit-options pyproject.toml"
  pip-compile $PIP_COMPILE_ARGS -o requirements.txt;
  echo "requirements.txt done"
  pip-compile $PIP_COMPILE_ARGS --extra dev -o requirements-dev.txt;
  echo "requirements-dev.txt done"
  echo "Finished"
  ```

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


pkgId: f0f707a220ab75dd7dc9ebe9b91dada34d87d972249f4b87a58236bacb17cdd9
name: python-crabpy-pyramid
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Bindings for the CRABpy webservices and the Pyramid framework.
url: https://pypi.org/project/crabpy-pyramid/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crabpy-pyramid-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Bindings for the crabpy library and the pyramid framework

  [![pypi](https://badge.fury.io/py/crabpy_pyramid.png)](http://badge.fury.io/py/crabpy_pyramid)
  [![docs](https://readthedocs.org/projects/crabpy-pyramid/badge/?version=latest)](https://readthedocs.org/projects/crabpy-pyramid/?badge=latest)
  [![CI](https://github.com/OnroerendErfgoed/crabpy_pyramid/actions/workflows/backend.yaml/badge.svg)](https://github.com/OnroerendErfgoed/crabpy_pyramid/actions/workflows/backend.yaml)
  [![coverage](https://coveralls.io/repos/OnroerendErfgoed/crabpy_pyramid/badge.png?branch=master)](https://coveralls.io/r/OnroerendErfgoed/crabpy_pyramid?branch=master)
  [![pypi](https://badge.fury.io/py/crabpy_pyramid.png)](http://badge.fury.io/py/crabpy_pyramid)





  More information about this library can be found in `docs`. The docs can be
  built using `Sphinx <http://sphinx-doc.org>`_.

  Please make sure you have installed Sphinx in the same environment where
  crabpy\_pyramid is present.

  ```sh
  pip install sphinx sphinxcontrib-httpdomain
  pip install -e .
  cd docs
  make html
  ```



  ```sh
  pip install hatch
  hatch build
  hatch build -t wheel
  hatch build -t sdist
  ```




  full docs: https://pip-tools.readthedocs.io/en/latest/

  To start, first install pip-tools:
  ```sh
  pip install pip-tools
  ```



  You can also use `uv` and for the remainder of the readme replace `pip`, `pip-compile` or
  `pip-sync` by `uv pip`, `uv pip compile` and `uv pip sync`.

  `uv` is a very fast replacement for pip-toools. It's optional, but can save a lot of time.
  ```sh
  pip install uv
  ```



  Note, `pip-sync` also uninstalls everything from the virtualenv which does not belong
  there according to the requirements file. This includes the project itself. You will
  have to install `crabpy_pyramid` again after `pip-sync`.
  Since the requirements file of pip-sync is still a normal requirements file you can also
  use `pip install -r` to install all libraries defined in it. This will not cleanup your
  virtualenv and uninstall other libraries.

  The compiled requirements files are made in a 3.11 environment.
  ```sh
  pip-sync requirements-dev.txt
  pip install -e .
  ```
  `requirements-dev.txt` contains all libraries uncluding those for testing and development.

  `requirements.txt` contains only the necessary libraries for running the library.



  ```sh
  echo -e "\nStarting"
  PIP_COMPILE_ARGS="-q --strip-extras --no-header --resolver=backtracking --no-emit-options pyproject.toml"
  pip-compile $PIP_COMPILE_ARGS -o requirements.txt;
  echo "requirements.txt done"
  pip-compile $PIP_COMPILE_ARGS --extra dev -o requirements-dev.txt;
  echo "requirements-dev.txt done"
  echo "Finished"
  ```

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


pkgId: d147f6610315fabdac5f388d387df50bc279dd613dc3d254d4ce853a1ba1ab78
name: python-crack-pdf
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A tool to crack password-protected PDFs
url: https://github.com/szpatrichard/crack-pdf
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crack-pdf-0.1.1-1.src.rpm
checksum_type: sha256
description:
  crack-pdf is a command-line tool for attempting to decrypt password-protected PDF files using a brute-force approach.



  - Attempts to crack PDF passwords using digit combinations
  - Configurable password length
  - Command-line interface for easy use



  To install crack-pdf, follow these steps:

  1. Clone the repository:

  ```sh
  git clone <https://github.com/szpatrichard/crack-pdf.git>
  cd crack-pdf
  ```

  2. Install the package:

  ```sh
  pip install -e .
  ```



  After installation, you can use the `crack-pdf` command from anywhere in your terminal:

  ```sh
  crack-pdf /path/to/your/pdf -l <password_length>
  ```

  Where:

  - `/path/to/your/pdf` is the path to the PDF file you want to decrypt
  - `<password_length>` is the length of the password to try (e.g., 4 for a 4-digit password)

  Example:

  ```sh
  crack-pdf ~/user/documents/locked.pdf -l 4
  ```

  This command will attempt to crack a PDF password using all 4-digit combinations.



  - This tool only attempts numeric passwords.
  - It uses a brute-force approach, which can be time-consuming for longer passwords.
  - It's intended for educational purposes and should not be used for illegal activities.



  Contributions to crack-pdf are welcome! Please feel free to submit a Pull Request.



  This project is licensed under the MIT License - see the [LICENCE](LICENCE) file for details.



  This tool is for educational purposes only. Only use it on PDF files that you own or have explicit permission to access. The authors are not responsible for any misuse or damage caused by this program.


pkgId: de171419d77b67f7f03ea7fceb5a579fcafbab045d3e300e95588eb34d662721
name: python-craft-ai-sdk
arch: src
version: 0.52.1
epoch: 0
release: 1
summary: Craft AI MLOps platform SDK
url: https://www.craft.ai/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craft-ai-sdk-0.52.1-1.src.rpm
checksum_type: sha256
description:
  This Python SDK lets you interact with Craft AI MLOps Platform.


  This project relies on **Python 3.8+**. Once a supported version of Python is installed, you can install `craft-ai-sdk` from PyPI with:

  ```console
  pip install craft-ai-sdk
  ```


  You can configure the SDK by instantiating the `CraftAiSdk` class in this way:

  ```python
  from craft_ai_sdk import CraftAiSdk

  CRAFT_AI_SDK_TOKEN =  # your access key obtained from your settings page
  CRAFT_AI_ENVIRONMENT_URL =  # url to your environment

  sdk = CraftAiSdk(sdk_token=CRAFT_AI_SDK_TOKEN, environment_url=CRAFT_AI_ENVIRONMENT_URL)
  ```

  If using the SDK in interactive mode, some additional feedbacks will be printed. You can force disable or enable those logs by either
  * Setting the `verbose_log` SDK parameter
  * Or setting the `SDK_VERBOSE_LOG` env var


pkgId: bc869c1383367f1d55e7449ec531e040247af4c685d65f6e73d48b2d6a084c26
name: python-craft-application
arch: src
version: 4.3.0
epoch: 0
release: 1
summary: A framework for *craft applications.
url: https://pypi.org/project/craft-application/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craft-application-4.3.0-1.src.rpm
checksum_type: sha256
description:
  This project will provide a basis for future projects similar to Snapcraft_, Charmcraft_ and Rockcraft_, with the eventual goal of rebasing those applications on this.


pkgId: b7c8b49fbff8c44724cc2ed273c8cd374b95ff54559335b33dcb3eb227eda361
name: python-craft-archives
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/craft-archives/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craft-archives-2.0.2-1.src.rpm
checksum_type: sha256
description:
  Craft Archives is a Python package to manage interaction with software
  archives on behalf of tools using the Craft Parts framework.
  Craft Archives provides a set of common interfaces to define the locations
  of software archives, install packages and verify their integrity.
  The aim of this package is to provide a uniform, extensible set of interfaces
  that other tools and packages can use to work with software archives.
  This package is most useful for implementers of tools using the Craft Parts
  framework that need to provide support for additional software archives.


pkgId: f7bbd76c0b57d4cdabff994dff1f105333f2e320142a97753e69515bd97651a6
name: python-craft-parts
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Craft parts tooling
url: https://github.com/canonical/craft-parts
rpm_license: GNU General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craft-parts-2.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.com/projects/canonical-craft-parts/badge/?version=latest)](https://canonical-craft-parts.readthedocs-hosted.com/en/latest/?badge=latest)

  Craft-parts provides a mechanism to obtain data from different sources,
  process it in various ways, and prepare a filesystem subtree suitable for
  deployment. The components used in its project specification are called
  *parts*, which can be independently downloaded, built and installed, and
  also depend on each other in order to assemble the subtree containing the
  final artifacts.




  Free software: GNU Lesser General Public License v3




  https://canonical-craft-parts.readthedocs-hosted.com/en/latest/



  A `Makefile` is provided for easy interaction with the project. To see
  all available options run:

  ```
  make help
  ```



  In order to develop any `apt` related items, the `python-apt` package is needed.
  The `apt` extra will require this package in general.

  > Ubuntu 22.04 is assumed in the rest of this setup

  Development packages, such as those to build the Apt Python package are required:

  ```bash
  sudo apt install libapt-pkg-dev intltool fuse-overlayfs python3.10-venv python3-dev gcc g++ make
  ```

  The following are required to run integration tests (it is a default target for `make tests`):
  ```bash
  sudo snap install chisel --candidate
  sudo apt install ninja-build cmake scons qt5-qmake p7zip rpm \
                   autoconf automake autopoint gcc git gperf help2man libtool texinfo \
                   pkg-config
  ```

  Create virtual environment to develop in and activate it:

  ```bash
  python3 -m venv .venv
  source .venv/bin/activate
  ```

  Install the required Python packages

  ```bash
  pip install -e .[dev,docs]
  pip install https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.4.0ubuntu1/python-apt_2.4.0ubuntu1.tar.xz
  ```


  * focal (20.04): https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.0.1ubuntu0.20.04.1/python-apt_2.0.1ubuntu0.20.04.1.tar.xz
  * jammy (22.04): https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.4.0ubuntu1/python-apt_2.4.0ubuntu1.tar.xz
  * lunar (23.04): https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.5.3ubuntu1/python-apt_2.5.3ubuntu1.tar.xz
  * noble (24.04): https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.7.7ubuntu1/python-apt_2.7.7ubuntu1.tar.xz



  To run all tests in the suite run:

  ```bash
  make tests
  ```

  To get coverage information for Craft Parts from the unit tests:

  ```bash
  make coverage
  ```


  If a new dependency is added to the project run:

  ```bash
  make freeze-requirements
  ```



  To locally verify documentation changes run:

  ```bash
  make docs
  ```

  After running, newly generated documentation shall be available at
  `./docs/_build/html/`.




  Please follow these guidelines when committing code for this project:

  - Use a topic with a colon to start the subject
  - Separate subject from body with a blank line
  - Limit the subject line to 50 characters
  - Do not capitalize the subject line
  - Do not end the subject line with a period
  - Use the imperative mood in the subject line
  - Wrap the body at 72 characters
  - Use the body to explain what and why (instead of how)


pkgId: 8c0b75f180f6f188238e030e3f7bb05c076c68d09fc98d75b80472145abce0ef
name: python-craft-providers
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/craft-providers/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craft-providers-2.0.4-1.src.rpm
checksum_type: sha256
description:
  This project provides Python interfaces for instantiating and executing
  builds for a variety of target environments.
  Initial providers include:
  - `LXD containers`_
  - `Multipass VMs`_
  Host support is targeted for:
  - Linux
  - Mac OS X
  - Windows


pkgId: bf437df8ff7c9eab974f2a0ed1d060f544fda582bcc0d365ec8eca09a819448d
name: python-craft-store
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Store bindings for Snaps and Charms
url: https://pypi.org/project/craft-store/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craft-store-3.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.com/projects/canonical-craft-store/badge/?version=latest)](https://canonical-craft-store.readthedocs-hosted.com/en/latest/?badge=latest)



  This project aims to provide python interfaces for communicating with
  Canonical Stores, such as Charmhub and the Snap Store.



  Free software: GNU Lesser General Public License v3



  https://canonical-craft-store.readthedocs-hosted.com.






  To run all tests in the suite run:

  ```
  tox
  ```



  Some integration tests require collaborator permission on the `craft-store-test-charm`
  charm package on the staging craft-store. These can be run by creating a pull request.

  Other integration tests simply require a valid login to the staging charmhub store.
  These can be run by exporting charmhub staging credentials to the environment
  variable `CRAFT_STORE_CHARMCRAFT_CREDENTIALS`. An easy way to do this is to
  create a `charmcraft.yaml` file containing the lines:

      charmhub:
        api-url: "https://api.staging.charmhub.io"
        storage-url: "https://storage.staging.snapcraftcontent.com"

  and then run `charmcraft login --export cc.cred` to login and
  `export CRAFT_STORE_CHARMCRAFT_CREDENTIALS=$(cat cc.cred)` to put the credentials
  into the environment variable. Note that if you do not have collaborator permissions
  on `craft-store-test-charm`, some tests will fail rather than being skipped.



  If a new dependency is added to the project run:

  TODO




  To locally verify documentation changes run:

  `tox run -e lint-docs,build-docs`


  After running, newly generated documentation shall be available at
  `./docs/_build/html/`.



  Please follow these guidelines when committing code for this project:

  - Use a topic with a colon to start the subject
  - Separate subject from body with a blank line
  - Limit the subject line to 50 characters
  - Do not capitalize the subject line
  - Do not end the subject line with a period
  - Use the imperative mood in the subject line
  - Wrap the body at 72 characters
  - Use the body to explain what and why (instead of how)

  As an example:


      endpoints: support package attenuations

      Required in order to obtain credentials that apply only to a given package;
      be it charm, snap or bundle.


pkgId: 62bd66165e322bdf98169aa45010163dddfcf904cd9cfb5121ab1f066f021624
name: python-craftaxlm
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Add your description here
url: https://pypi.org/project/craftaxlm/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craftaxlm-0.0.5-1.src.rpm
checksum_type: sha256
description:
  A wrapper around the Craftax agent benchmark, for evaluating digital agents.

  <p align="middle">
    <img src="https://raw.githubusercontent.com/MichaelTMatthews/Craftax/main/images/dungeon_crawling.gif" width="200" />
  </p>


  First, download the package with ```pip install craftaxlm```. Next, import the agent-computer interface of your choice via
  ```
  from craftaxlm import CraftaxACI, CraftaxClassicACI
  ```
  This package is early in development, so for implementation examples, please refer to the [baseline ReAct implementation](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax)




  | LM | Algorithm | Reward (% max) |                                              Code                                               |
  |:----------|---------------:|:-----------------------------------------------------------------------------------------------:|:---------------------------------------:|
  | gpt-4o-mini | ReAct   |            18.4 | [CraftaxLM_Baselines](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax/test.py) |


  | LM | Algorithm | Reward (% max) |                                              Code                                               |
  |:----------|---------------:|:-----------------------------------------------------------------------------------------------:|:---------------------------------------:|
  | gpt-4o-mini | ReAct   |            02.9 | [CraftaxLM_Baselines](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax/test.py) |


  ```
  pyenv virtualenv craftax_env
  poetry install
  ```

  When in doubt

  ```
  from jax import debug
  ...
  debug.breakpoint()
  ```


  To learn more about Craftax, check out the paper [website](https://craftaxenv.github.io) here.
  To cite the underlying Craftax environment, see:
  ```
  @inproceedings{matthews2024craftax,
      author={Michael Matthews and Michael Beukman and Benjamin Ellis and Mikayel Samvelyan and Matthew Jackson and Samuel Coward and Jakob Foerster},
      title = {Craftax: A Lightning-Fast Benchmark for Open-Ended Reinforcement Learning},
      booktitle = {International Conference on Machine Learning ({ICML})},
      year = {2024}
  }
  ```
  To cite the Crafter benchmark, see:
  ```
  @article{hafner2021crafter,
    title={Benchmarking the Spectrum of Agent Capabilities},
    author={Danijar Hafner},
    year={2021},
    journal={arXiv preprint arXiv:2109.06780},
  }
  ```


  ```
  uv venv craftaxlm-dev
  source craftaxlm-dev/bin/activate
  uv run ruff format .
  ```


pkgId: 4443d9c210cebc0aac29426dce3dbfcf9d47560a848939f64d25afca0046d75a
name: python-craftaxlm
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Add your description here
url: https://pypi.org/project/craftaxlm/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craftaxlm-0.0.6-1.src.rpm
checksum_type: sha256
description:
  A wrapper around the Craftax agent benchmark, for evaluating digital agents over extremely long time horizons.

  <p align="middle">
    <img src="https://raw.githubusercontent.com/MichaelTMatthews/Craftax/main/images/dungeon_crawling.gif" width="200" />
  </p>


  First, download the package with ```pip install craftaxlm```. Next, import the agent-computer interface of your choice via
  ```
  from craftaxlm import CraftaxACI, CraftaxClassicACI
  ```
  This package is early in development, so for implementation examples, please refer to the [baseline ReAct implementation](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax)


  In order to make experiments reasonable to run across a range of LMs, currently the leaderboard evaluates agents in the following manner:
  1. Five rollouts are sampled from the agent, with a hard cap of 300 actions per rollout.
  2. The agent is evaluated using a modified version of the original Crafter score -
      ```
      sum(ln(1 + P(1_achievement_obtained)) for achievement in achievements) / (sum(ln(2) * len(achievements)))
      ```
      where P(1_achievement_obtained) is the probability of the achievement being obtained in a single rollout. The key idea is that incremental progress towards difficult achievements ought to weigh more heavily in the score.


  | LM | Algorithm | Score (% max) |                                              Code                                               |
  |:----------|---------------:|:-----------------------------------------------------------------------------------------------:|:---------------------------------------:|
  | gpt-4o | ReAct   |            29.6 | [CraftaxLM_Baselines](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax/test.py) |
  | gpt-4o-mini | ReAct   |            18.4 | [CraftaxLM_Baselines](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax/test.py) |


  | LM | Algorithm | Score (% max) |                                              Code                                               |
  |:----------|---------------:|:-----------------------------------------------------------------------------------------------:|:---------------------------------------:|
  | gpt-4o-mini | ReAct   |            02.9 | [CraftaxLM_Baselines](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax/test.py) |


  ```
  pyenv virtualenv craftax_env
  poetry install
  ```

  When in doubt

  ```
  from jax import debug
  ...
  debug.breakpoint()
  ```


  To learn more about Craftax, check out the paper [website](https://craftaxenv.github.io) here.
  To cite the underlying Craftax environment, see:
  ```
  @inproceedings{matthews2024craftax,
      author={Michael Matthews and Michael Beukman and Benjamin Ellis and Mikayel Samvelyan and Matthew Jackson and Samuel Coward and Jakob Foerster},
      title = {Craftax: A Lightning-Fast Benchmark for Open-Ended Reinforcement Learning},
      booktitle = {International Conference on Machine Learning ({ICML})},
      year = {2024}
  }
  ```
  To cite the Crafter benchmark, see:
  ```
  @article{hafner2021crafter,
    title={Benchmarking the Spectrum of Agent Capabilities},
    author={Danijar Hafner},
    year={2021},
    journal={arXiv preprint arXiv:2109.06780},
  }
  ```



  ```
  uv venv craftaxlm-dev
  source craftaxlm-dev/bin/activate
  uv sync
  uv run ruff format .
  ```

  - General code quality suggestions or improvements. Especially those that improve speed or reduce tokens.
  - PRs to fix issues or add afforances that help your LM agent perform well
  - Leaderboard submissions that demonstrate improved performance using algorithms for learning from data


pkgId: 528d31a32648c20e675977c6398e3a0c9691188f0d6f195095dc0530a764be66
name: python-crafter
arch: src
version: 1.8.3
epoch: 0
release: 1
summary: Open world survival game for reinforcement learning.
url: http://github.com/danijar/crafter
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crafter-1.8.3-1.src.rpm
checksum_type: sha256
description:
  **Status:** Stable release

  [![PyPI](https://img.shields.io/pypi/v/crafter.svg)](https://pypi.python.org/pypi/crafter/#history)



  Open world survival game for evaluating a wide range of agent abilities within
  a single environment.

  ![Crafter Terrain](https://github.com/danijar/crafter/raw/main/media/terrain.png)



  Crafter features randomly generated 2D worlds where the player needs to forage
  for food and water, find shelter to sleep, defend against monsters, collect
  materials, and build tools. Crafter aims to be a fruitful benchmark for
  reinforcement learning by focusing on the following design goals:

  - **Research challenges:** Crafter poses substantial challenges to current
    methods, evaluating strong generalization, wide and deep exploration,
    representation learning, and long-term reasoning and credit assignment.

  - **Meaningful evaluation:** Agents are evaluated by semantically meaningful
    achievements that can be unlocked in each episode, offering insights into the
    ability spectrum of both reward agents and unsupervised agents.

  - **Iteration speed:** Crafter evaluates many agent abilities within a single
    env, vastly reducing the computational requirements over benchmarks suites
    that require training on many separate envs from scratch.

  See the research paper to find out more: [Benchmarking the Spectrum of Agent
  Capabilities](https://arxiv.org/pdf/2109.06780.pdf)

  ```
  @article{hafner2021crafter,
    title={Benchmarking the Spectrum of Agent Capabilities},
    author={Danijar Hafner},
    year={2021},
    journal={arXiv preprint arXiv:2109.06780},
  }
  ```



  ```sh
  python3 -m pip install crafter  # Install Crafter
  python3 -m pip install pygame   # Needed for human interface
  python3 -m crafter.run_gui      # Start the game
  ```

  <details>
  <summary>Keyboard mapping (click to expand)</summary>

  | Key | Action |
  | :-: | :----- |
  | WASD | Move around |
  | SPACE| Collect material, drink from lake, hit creature |
  | TAB | Sleep |
  | T | Place a table |
  | R | Place a rock |
  | F | Place a furnace |
  | P | Place a plant |
  | 1 | Craft a wood pickaxe |
  | 2 | Craft a stone pickaxe |
  | 3 | Craft an iron pickaxe |
  | 4 | Craft a wood sword |
  | 5 | Craft a stone sword |
  | 6 | Craft an iron sword |

  </details>

  ![Crafter Video](https://github.com/danijar/crafter/raw/main/media/video.gif)



  To install Crafter, run `pip3 install crafter`. The environment follows the
  [OpenAI Gym][gym] interface. Observations are images of size (64, 64, 3) and
  outputs are one of 17 categorical actions.

  ```py
  import gym
  import crafter

  env = gym.make('CrafterReward-v1')  # Or CrafterNoReward-v1
  env = crafter.Recorder(
    env, './path/to/logdir',
    save_stats=True,
    save_video=False,
    save_episode=False,
  )

  obs = env.reset()
  done = False
  while not done:
    action = env.action_space.sample()
    obs, reward, done, info = env.step(action)
  ```

  [gym]: https://github.com/openai/gym



  Agents are allowed a budget of 1M environmnent steps and are evaluated by their
  success rates of the 22 achievements and by their geometric mean score. Example
  scripts for computing these are included in the `analysis` directory of the
  repository.

  - **Reward:** The sparse reward is `+1` for unlocking an achievement during
    the episode and `-0.1` or `+0.1` for lost or regenerated health points.
    Results should be reported not as reward but as success rates and score.

  - **Success rates:** The success rates of the 22 achievemnts are computed
    as the percentage across all training episodes in which the achievement was
    unlocked, allowing insights into the ability spectrum of an agent.

  - **Crafter score:** The score is the geometric mean of success rates, so that
    improvements on difficult achievements contribute more than improvements on
    achievements with already high success rates.



  Please create a pull request if you would like to add your or another algorithm
  to the scoreboards. For the reinforcement learning and unsupervised agents
  categories, the interaction budget is 1M. The external knowledge category is
  defined more broadly.



  | Algorithm | Score (%) | Reward | Open Source |
  |:----------|----------:|-------:|:-----------:|
  | [Curious Replay](https://arxiv.org/pdf/2306.15934.pdf) | 19.4±1.6 | - | [AutonomousAgentsLab/cr-dv3](https://github.com/AutonomousAgentsLab/cr-dv3) |
  | [PPO (ResNet)](https://arxiv.org/pdf/2307.03486.pdf)| 15.6±1.6 | 10.3±0.5 | [snu-mllab/Achievement-Distillation](https://github.com/snu-mllab/Achievement-Distillation)
  | [DreamerV3](https://arxiv.org/pdf/2301.04104v1.pdf) | 14.5±1.6 | 11.7±1.9 | [danijar/dreamerv3](https://github.com/danijar/dreamerv3) |
  | [LSTM-SPCNN](https://arxiv.org/pdf/2208.03374.pdf) | 12.1±0.8 | — | [astanic/crafter-ood](https://github.com/astanic/crafter-ood) |
  | [EDE](https://openreview.net/pdf?id=GZDsKahGY-2) | 11.7±1.0 | — | [yidingjiang/ede](https://github.com/yidingjiang/ede) |
  | [OC-SA](https://arxiv.org/pdf/2208.03374.pdf) | 11.1±0.7 | — | [astanic/crafter-ood](https://github.com/astanic/crafter-ood) |
  | [DreamerV2](https://arxiv.org/pdf/2010.02193.pdf) | 10.0±1.2 | 9.0±1.7 | [danijar/dreamerv2](https://github.com/danijar/dreamerv2) |
  | [PPO](https://arxiv.org/pdf/1710.02298.pdf) | 4.6±0.3 | 4.2±1.2 | [DLR-RM/stable-baselines3](https://github.com/DLR-RM/stable-baselines3) |
  | [Rainbow](https://arxiv.org/pdf/1710.02298.pdf) | 4.3±0.2 | 6.0±1.3 | [Kaixhin/Rainbow](https://github.com/Kaixhin/Rainbow) |



  | Algorithm | Score (%) | Reward | Open Source |
  |:----------|----------:|-------:|:-----------:|
  | [Plan2Explore](https://arxiv.org/pdf/2010.02193.pdf) | 2.1±0.1 | 2.1±1.5 | [danijar/dreamerv2](https://github.com/danijar/dreamerv2) |
  | [RND](https://arxiv.org/pdf/1810.12894.pdf) | 2.0±0.1 | 0.7±1.3 | [alirezakazemipour/PPO-RND](https://github.com/alirezakazemipour/PPO-RND) |
  | Random | 1.6±0.0 | 2.1±1.3 | — |



  | Algorithm | Score (%) | Reward | Uses | Interaction | Open Source |
  |:----------|----------:|-------:|:-----|:-----------:|:-----------:|
  | [Human](https://en.wikipedia.org/wiki/Human) | 50.5±6.8 | 14.3±2.3 | Life experience | 0 | [crafter_human_dataset](https://archive.org/details/crafter_human_dataset) |
  | [SPRING](https://arxiv.org/pdf/2305.15486.pdf) | 27.3±1.2 | 12.3±0.7 | LLM, scene description, Crafter paper | 0 | ❌ |
  | [Achievement Distillation](https://arxiv.org/pdf/2307.03486.pdf) | 21.8±1.4 | 12.6±0.3 | Reward structure | 1M | [snu-mllab/Achievement-Distillation](https://github.com/snu-mllab/Achievement-Distillation) |
  | [ELLM](https://arxiv.org/pdf/2302.06692.pdf) | — | 6.0±0.4 | LLM, scene description | 5M | ❌ |



  Baseline scores of various agents are available for Crafter, both with and
  without rewards. The scores are available in JSON format in the `scores`
  directory of the repository. For comparison, the score of human expert players
  is 50.5\%. The [baseline
  implementations](https://github.com/danijar/crafter-baselines) are available as
  a separate repository.

  <img src="https://github.com/danijar/crafter/raw/main/media/scores.png" width="400"/>



  Please [open an issue][issues] on Github.

  [issues]: https://github.com/danijar/crafter/issues


pkgId: 9cbcca539486faeaf64f2ebb6dd27c5870625224945c8caecf0aae5ab617608a
name: python-crappy
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: Command and Real-time Acquisition in Parallelized Python
url: https://github.com/LaboratoireMecaniqueLille/crappy
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crappy-2.0.6-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/crappy)](https://pepy.tech/project/crappy)
  [![Documentation Status](https://readthedocs.org/projects/crappy/badge/?version=latest)](https://crappy.readthedocs.io/en/latest/?badge=latest)
  [![PyPi version](https://badgen.net/pypi/v/crappy/)](https://pypi.org/project/crappy/)
  [![Python version](https://img.shields.io/pypi/pyversions/crappy.svg)](https://pypi.org/project/crappy/)
  CRAPPY aims to provide a free and open-source software canvas for driving
  experimental setups in a versatile and accessible way.

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 2, June 1991  Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/> 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it.  (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.)  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.  To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.  Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software.  If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.  Finally, any free program is threatened constantly by software patents.  We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary.  To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.  The precise terms and conditions for copying, distribution and modification follow.  GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License.  The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  Each licensee is addressed as "you".  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.  1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.  b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.  c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License.  (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.  In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:  a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  c) Accompany it with the information you received as to the offer to distribute corresponding source code.  (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)  The source code for a work means the preferred form of the work for making modifications to it.  For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable.  However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.  4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  5. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Program or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.  6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.  7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all.  For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.  10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  {description} Copyright (C) {year}  {fullname}  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.  Also add information on how to contact you by electronic and paper mail.  If the program is interactive, make it output a short notice like this when it starts in an interactive mode:  Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.  {signature of Ty Coon}, 1 April 1989 Ty Coon, President of Vice  This General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.


pkgId: 7f2ad01d56642911eb30472a8fb5f80a20ea414a2ebc70fcb1269adab672ae82
name: python-crappy
arch: src
version: 2.0.7
epoch: 0
release: 1
summary: Command and Real-time Acquisition in Parallelized Python
url: https://github.com/LaboratoireMecaniqueLille/crappy
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crappy-2.0.7-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/crappy)](https://www.pepy.tech/projects/crappy)
  [![Documentation Status](https://readthedocs.org/projects/crappy/badge/?version=latest)](https://crappy.readthedocs.io/en/latest/)
  [![PyPi version](https://badgen.net/pypi/v/crappy/)](https://pypi.org/project/crappy/)
  [![Python version](https://img.shields.io/pypi/pyversions/crappy.svg)](https://pypi.org/project/crappy/)
  CRAPPY aims to provide a free and open-source software canvas for driving
  experimental setups in a versatile and accessible way.

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


pkgId: b123cbcdc058a78a5b5e932b57d2bfd9e87df6b89eb2c64465a631fd5077fb2e
name: python-craps
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: A table game engine.
url: https://github.com/mhegarty/craps
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craps-2.0.2-1.src.rpm
checksum_type: sha256
description:
  <div id="top"></div>
  <!--
  *** Thanks for checking out craps. If you have a suggestion that would
  *** make this better, please fork the repo and create a pull request
  *** or simply open an issue with the tag "enhancement".
  *** Don't forget to give the project a star!
  *** Thanks again! Now go create something AMAZING! :D
  -->



  <!-- PROJECT SHIELDS -->
  <!--
  *** I'm using markdown "reference style" links for readability.
  *** Reference links are enclosed in brackets [ ] instead of parentheses ( ).
  *** See the bottom of this document for the declaration of the reference variables
  *** for contributors-url, forks-url, etc. This is an optional, concise syntax you may use.
  *** https://www.markdownguide.org/basic-syntax/#reference-style-links
  -->
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![LinkedIn][linkedin-shield]][linkedin-url]



  <!-- PROJECT LOGO -->
  <h3 align="center">craps</h3>

  <br />

  <div align="center">
    <!-- <a align="center" href="https://github.com/mhegarty/craps/blob/master/logo.png">
      <img src="https://raw.githubusercontent.com/mhegarty/craps/master/logo.png"
      alt="Logo" width=80 height=80>
    </a> -->
    <a align="center" href="https://github.com/mhegarty/craps/blob/master/logo.png">
      <img src="https://raw.githubusercontent.com/mhegarty/craps/master/logo.png"
      alt="Logo">
    </a>
  <br />
  <br />
    <p align="center">
      A lightweight table game simulator.
      <!-- <br />
      <a href="https://github.com/mhegarty/craps"><strong>Explore the code »</strong></a>-->
      <br />
      <br />
      ·
      <a href="https://github.com/mhegarty/craps/issues">Report Bug</a>
      ·
      <a href="https://github.com/mhegarty/craps/issues">Request Feature</a>
    </p>
  </div>



  <!-- TABLE OF CONTENTS -->
  <!--
  <details>
    <summary>Table of Contents</summary>
    <ol>
      <li>
        <a href="#about-the-project">About The Project</a>
        <ul>
          <li><a href="#built-with">Built With</a></li>
        </ul>
      </li>
      <li>
        <a href="#getting-started">Getting Started</a>
        <ul>
          <li><a href="#prerequisites">Prerequisites</a></li>
          <li><a href="#installation">Installation</a></li>
        </ul>
      </li>
      <li><a href="#usage">Usage</a></li>
      <li><a href="#roadmap">Roadmap</a></li>
      <li><a href="#contributing">Contributing</a></li>
      <li><a href="#license">License</a></li>
      <li><a href="#contact">Contact</a></li>
      <li><a href="#acknowledgments">Acknowledgments</a></li>
    </ol>
  </details>
  -->



  <!-- ABOUT THE PROJECT -->
  <!--


  [![Product Name Screen Shot][product-screenshot]](https://example.com)

  Here's a blank template to get started: To avoid retyping too much info. Do a search and replace with your text editor for the following: `mhegarty`, `craps`, `@mjhegarty`, `hegarty`, `email`, `email_client`, `project_title`, `project_description`

  <p align="right">(<a href="#top">back to top</a>)</p>
  -->

  <!--


  * [Python](https://python.org/)

  <p align="right">(<a href="#top">back to top</a>)</p>
  -->


  <!-- GETTING STARTED -->
  <!-- ## Getting Started

  The game engine is ready to roll. Let's get rolling.
   -->


  <!-- ## Prerequisites

  This package uses libraries that have been standard since python 2.7 and it will likely
  run on any python version you are using. If you experience any issues, please [report a bug](https://github.com/mhegarty/craps/issues). -->






  Install with pip (recommended)
   ```sh
   pip install craps
   ```

  <!-- <p align="right">(<a href="#top">back to top</a>)</p> -->



  <!-- USAGE EXAMPLES -->



  ```python
  !pip install craps
  from craps import Game, PassBet, LineOddsBet, ComeBet, PointOddsBet
  ```

      Collecting craps
        Downloading craps-1.1.0-py3-none-any.whl (9.9 kB)
      Installing collected packages: craps
      Successfully installed craps-1.1.0



  ```python

  g = Game(arrival_cash = 100, minimum_bet=10)


  g.bet(PassBet(10))
  g.roll()
  ```

      [Bet] You made a PassBet on the box for 10
      [Rail] You have 990.0 on the rail
      [Table] The shooter is ready, the point is off
      [Table] PassBet for 10 is working on the box
      [Roll] Shooter rolled 10
      [Roll] The point is 10
      [Rail] You have 990.0 on the rail



  ```python

  g.bet(LineOddsBet(20, g.puck))


  g.bet(ComeBet(g.minimum_bet))
  ```

      [Bet] You made a LineOddsBet on 10 for 20
      [Rail] You have 970.0 on the rail
      [Bet] You made a ComeBet on the box for 10.0
      [Rail] You have 960.0 on the rail



  ```python

  g.roll()
  ```

      [Table] The shooter is ready, the point is 10
      [Table] PassBet for 10 is working on 10
      [Table] LineOddsBet for 20 is working on 10
      [Table] ComeBet for 10.0 is working on the box
      [Roll] Shooter rolled 8
      [Roll] 2+6=8 came easy
      [Bet] ComeBet for 10.0 was moved to the 8
      [Rail] You have 960.0 on the rail



  ```python

  g.callout()
  ```

      [Table] PassBet for 10 is working on 10
      [Table] LineOddsBet for 20 is working on 10
      [Table] ComeBet for 10.0 is working on 8



  ```python

  g.bet(PointOddsBet(30, 8))
  ```

      [Bet] You made a PointOddsBet on 8 for 30
      [Rail] You have 930.0 on the rail



  ```python

  g.roll()
  ```

      [Table] The shooter is ready, the point is 10
      [Table] PassBet for 10 is working on 10
      [Table] LineOddsBet for 20 is working on 10
      [Table] ComeBet for 10.0 is working on 8
      [Table] PointOddsBet for 30 is working on 8
      [Roll] Shooter rolled 10
      [Roll] Winner!!, 10
      [Payout] PassBet on 10 paid out 20
      [Payout] LineOddsBet on 10 paid out 60.0
      [Rail] You have 1010.0 on the rail


    <!-- <a href="https://github.com/mhegarty/craps/blob/master/images/example.png">
      <img src="https://raw.githubusercontent.com/mhegarty/craps/master/images/example.png"
       alt="Notebook">
    </a> -->

  <!-- _For more examples, please refer to the [Documentation](https://example.com)_-->

  <p align="right">(<a href="#top">back to top</a>)</p>



  <!-- ROADMAP -->


  - Add Bet types to model.py
    - Add [place bets](https://www.liveabout.com/craps-place-bets-537453)
    - Add [side bets](https://wizardofodds.com/games/craps/appendix/5/)
      - Add the [Yo](https://www.lolcraps.com/craps/bets/yo/) first. That's fun.
  - Strategy constructor / builder
    - Logic layer to facilitate strategy construction in a low code environment. For example:
      - `IF` the game puck is off `AND` I do not have a place bet, `THEN` make a place bet.
      - `IF` the game puck is on `AND` I do <u>not</u> have odds on a place or come bet, `THEN` put f(x) odds on it.

  See the [open issues](https://github.com/mhegarty/craps/issues) for a full list of proposed features (and known issues).

  <!-- <p align="right">(<a href="#top">back to top</a>)</p> -->



  <!-- CONTRIBUTING -->


  Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.

  If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
  Don't forget to give the project a star! Thanks again!

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request

  <!-- <p align="right">(<a href="#top">back to top</a>)</p> -->



  <!-- LICENSE -->


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

  <!-- <p align="right">(<a href="#top">back to top</a>)</p> -->



  <!-- CONTACT -->


  Mike Hegarty - [@mjhegarty](https://twitter.com/@mjhegarty) - mike@petorca.com

  Project Link: [https://github.com/mhegarty/craps](https://github.com/mhegarty/craps)

  <!-- <p align="right">(<a href="#top">back to top</a>)</p> -->



  <!-- ACKNOWLEDGMENTS -->


  * Thanks to [@dhegarty19](https://www.instagram.com/dhegarty19/) for agreeing to celebrate our third aniversary at the casino.
  * Big thanks to Othneil Drew for the awesome work on [the best readme template](https://github.com/othneildrew/Best-README-Template)
  * [pikpng.com](https://www.pikpng.com/pngvi/hbRwTJb_png-clipart/) for the logo image.


  <!-- <p align="right">(<a href="#top">back to top</a>)</p> -->



  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/mhegarty/craps.svg?style=for-the-badge
  [contributors-url]: https://github.com/mhegarty/craps/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/mhegarty/craps.svg?style=for-the-badge
  [forks-url]: https://github.com/mhegarty/craps/network/members
  [stars-shield]: https://img.shields.io/github/stars/mhegarty/craps.svg?style=for-the-badge
  [stars-url]: https://github.com/mhegarty/craps/stargazers
  [issues-shield]: https://img.shields.io/github/issues/mhegarty/craps.svg?style=for-the-badge
  [issues-url]: https://github.com/mhegarty/craps/issues
  [license-shield]: https://img.shields.io/github/license/mhegarty/craps.svg?style=for-the-badge
  [license-url]: https://github.com/mhegarty/craps/blob/master/LICENSE.txt
  [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
  [linkedin-url]: https://linkedin.com/in/hegarty
  <!-- [product-screenshot]: images/screenshot.png -->


pkgId: c0ea675acec6168755aa1725eb1a8a5170ae4a619e0c77b8f7491d911574fa3f
name: python-crapssim
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Simulator for Craps with various betting strategies
url: https://github.com/skent259/CrapsSim
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crapssim-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/crapssim)
  ![GitHub Repo stars](https://img.shields.io/github/stars/skent259/crapssim?style=social)

  When playing craps in a casino, there are unlimited combinations of ways that that players can place their bets. But, with this freedom comes complexity, and players deserve to know how a strategy could perform in each session. The 'crapssim' package is designed answer these tough questions: What's a fun strategy involving multiple numbers where the house edge doesn't increase too much? What's the best amount of passline or don't pass odds for my bankroll? Does hedging my bet improve my net winnings?

  Crapssim is a python package which runs all of the necessary elements of a Craps table.  The package follows some natural logic:

  - a `Table` has `Player`(s) and `Dice` on it
  - the `Player`(s) have `Bet`(s) on the `Table`
  - each `Player`'s `Strategy` can automatically set up `Bet`(s)

  With these building blocks, crapssim supports

  - running **1 session** with **1 player/strategy** to test a realistic day at the craps table,
  - running **many sessions** with **1 player/strategy** to understand how a strategy performs in the long term, or
  - running **many sessions** with **many players/strategies** to simulate how they compare to each other

  These powerful options can lead to some unique analysis of the game of craps, such as the following figure comparing 4 strategies with a budget of $200:

  ![best-budget-strategies](https://user-images.githubusercontent.com/41379385/109597132-404bc280-7add-11eb-848c-1981d57d100a.png)



  There's a few good resources for getting started:

  1. Try the interactive [google collab notebook](https://github.com/skent259/crapssim/blob/master/crapssim_sandbox.ipynb) to test a single strategy and see how the interface works
  2. Check out Corey Brown's scripts to define strategies and compare them: https://github.com/coreyabrown/CoreyCrapsSim
  3. Looks at the minimal working examples below


  To see how a single session might play out for you using a pass line bet with double odds, over 20 rolls, one might run:

  ```python
  import crapssim as craps
  from crapssim.strategy import BetPassLine, PassLineOddsMultiplier

  table = craps.Table()
  your_strat = BetPassLine(5) + PassLineOddsMultiplier(2)

  table.add_player(strategy=your_strat)
  table.run(max_rolls=20, verbose=True)
  ```

  To evaluate a couple of strategies across many table sessions, you can run:

  ```python
  import crapssim as craps

  n_sim = 20
  bankroll = 300
  strategies = {
      "place68": craps.strategy.examples.PassLinePlace68(5),
      "ironcross": craps.strategy.examples.IronCross(5),
  }

  for i in range(n_sim):
      table = craps.Table()
      for s in strategies:
          table.add_player(bankroll, strategy=strategies[s], name=s)

      table.run(max_rolls=float("inf"), max_shooter=10, verbose=False)

      for p in table.players:
          print(f"{i}, {p.name}, {p.bankroll}, {bankroll}, {table.dice.n_rolls}")
  ```

  For more advanced strategies, you can either write your own custom `Strategy` class or add strategy components together.  Some building blocks and examples can be found in the [strategy](./crapssim/strategy/) module. We plan to have a more detailed tutorial and more strategy examples available soon.



  For a normal user, it is recommended to install the official release. You will
  need an installation of python version 3.10 or newer.  Then, run the following
  code in your terminal:

  ```python
  pip install crapssim
  ```

  Development installation instructions are [also available](./doc/installation.rst).



  Some results from this simulator have been posted to http://pages.stat.wisc.edu/~kent/blog:
  - [One Surprising Feature of Dark Side Betting](https://pages.stat.wisc.edu/~kent/blog/2021.10.24/dark-side-surprises.html)
  - [5 Systems to Try at the Craps Table](http://pages.stat.wisc.edu/~kent/blog/2021.02.22/five_craps_systems.html)
  - [Craps: Best Strategies on a Budget](http://pages.stat.wisc.edu/~kent/blog/2019.07.31_Craps_Budget/craps_best-strategies-on-a-budget.html)
  - [All Bets Are Off: Re-learning the Pass Line Bet in Craps](http://pages.stat.wisc.edu/~kent/blog/2019.02.28_Craps_Passline/passline-and-odds.html)




  If you discover something interesting using this simulator, please let me know so that I can highlight those results here.  You can find me at skent259@gmail.com.

  Those looking to contribute to this project are welcome to do so.  Currently, the top priority is to improve

  - Supported bets (see [bet.py](./crapssim/bet.py))
  - Supported strategies (see [strategy](./crapssim/strategy))
  - Documentation


pkgId: 9690e007a962f5d06221d1b0cfdc3b12c45bb001cb37e3467834ee0abcd12b38
name: python-crashs
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: CRASHS: Cortical Reconstruction for Automated Segmentation of Hippocampal Subfields (ASHS)
url: https://github.com/pyushkevich/crashs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crashs-0.2.5-1.src.rpm
checksum_type: sha256
description:
  CRASHS is a surface-based modeling and groupwise registration pipeline for the human medial temporal lobe (MTL). It is used to postprocess the results of [ASHS](https://github.com/pyushkevich/ashs) segmentation with ASHS atlases that contain a white matter label. CRASHS uses the [CRUISE](https://doi.org/10.1016/j.neuroimage.2004.06.043) technique implemented in the [NighRes software](https://nighres.readthedocs.io/en/latest/) to fit the white matter segmentation with a surface of spherical topology, and find a series of surfaces spanning between the gray/white boundary and the pial surface. The middle surface is inflated and registered to a population template, allowing surface-based analysis of MTL cortical thickness and other measures such as functional MRI and diffusion MRI.

  The CRASHS pipeline is described in the supplemental material to our paper in the special issue of Alzheimer's and Dementia on the [20th anniversary of ADNI](https://doi.org/10.1002/alz.14161).




  CRASHS requires the `nighres` package, which cannot be installed with `pip`. To install `nighres`, please follow the [installation instructions](https://nighres.readthedocs.io/en/latest/). To our knowledge, ARM64 architecture is currently not supported.

  Once `nighres` is installed, you can install CRASHS:

  ```sh
  pip install crashs
  python3 -m crashs fit --help
  ```

  Or, if you want to run the latest development code:

  ```sh
  git clone https://github.com/pyushkevich/crashs
  cd crashs
  pip install .
  ```


  This repository includes the CRASHS scripts and a `Dockerfile`. The official container on DockerHub is labeled `pyushkevich/crashs:latest`

  ```sh
  docker run -v your_data_directory:/data -it pyushkevich/crashs:latest /bin/bash
  python3 -m crashs fit --help
  ```

  A sample dataset is also provided and can be processed as follows (also see `run_sample.sh`)

  ```sh
  docker run -v your_data_directory:/data -it pyushkevich/crashs:latest /bin/bash
  python3 -m crashs fit -s right -r 0.1 sample_data/035_S_4082_2011-06-28 templates/crashs_template_01 /data/test
  ```


  The main input to the package is the ASHS output folder. Before running CRASHS, you will need to run ASHS on your MRI scans using one of the atlases for which a CRASHS template is available.

  CRASHS offers different templates for different ASHS versions. Currently, the following templates are provided:

  * **ashs_pmc_t1**: Template for the T1-weighted MRI version of ASHS [T1-ASHS](https://doi.org/10.1002/hbm.24607) using the [ASHS-PMC-T1 atlas](https://www.nitrc.org/frs/?group_id=370). We recommend using the 2023 ASHS-PMC-T1 atlas with the white matter label. However, you can also provide segmentations created using the original ASHS-PMC-T1 atlas and the white matter label will be added to the existing segmentation automatically, using [nnUNet](https://github.com/MIC-DKFZ/nnUNet).

  * **ashs_pmc_alveus**: Template for the high-resolution oblique coronal T2-weighted MRI version of [ASHS](https://doi.org/10.1002/hbm.22627). The white matter label will be added to the existing segmentation and extended synthetically over the alveus/fimbria, as described in our [ADNI 20th anniversary paper](https://doi.org/10.1002/alz.14161).



  You can download the templates and pretrained models for running CRASHS from this link:

  * https://doi.org/10.5061/dryad.kkwh70scx

  Download and extract the archive and set the environment variable `CRASHS_DATA` to point to the folder in which you extract the archive.

  ```sh
  cp ~/Downloads/crashs_template_package_20240830.tgz /my/crashs/folder
  cd /my/crashs/folder
  tar -zxvf crashs_template_package_20240830.tgz
  export CRASHS_DATA=/my/crashs/folder/crashs_template_package_20240830
  ```

  We recommend adding the line above that sets the `CRASHS_DATA` environment variable to your `.bashrc`, `.bash_profile` or `.zshrc` file, depending on what shell you use. Alternatively, you can invoke CRASHS below with the `-C` switch to provide the path to the templates and models directory.


  The program generates many outputs, but the most useful ones are:
  * `fitting/[ID]_fitted_omt_hw_target.vtk`: the grey/white and grey/csf boundaries estimated by the `cruise_cortex_extraction` module of NighRes. These meshes are in physical (RAS) coordinate space, not in voxel (IJK) space output by Nighres. *If you extract meshes from the T1-ASHS segmentation in ITK-SNAP, those should line up with these meshes.*

  * `fitting/[ID]_fitted_omt_hw_target.vtk`: the mid-surface of the gray matter estimated by the `volumetric_layering` module of NighRes. Also in RAS space.

  * `fitting/[ID]_fitted_omt_match_to_hw.vtk`: the template mesh projected onto the mid-surface surface, also in RAS space. This should have the same geometry as the mid-surface, but the same number of vertices/faces as the template. This mesh will also have scalar arrays for the anatomical label and other features from the template, such as template curvature (useful for visualization). **This mesh can be used to map data from subject space (thickness, fMRI, NODDI, etc) into template space for group analysis**

  * `thickness/[ID]_template_thickness.vtk`: a mesh with same geometry as the template that has a point array `VoronoiRadius` containing half-thickness of the gray matter at each vertex.

  * `thickness/[ID]_thickness_roi_summary.csv`: Mean and median half-thickness across gray matter ROIs.



  The following files can be used to check how well the fitting between the inflated template mid-surface and the inflated subject mid-surface worked.

  * `fitting/[ID]_fit_target_reduced.vtk`: this is the inflated and sub-sampled mid-surface mesh of the subject, affine transformed into the space of the inflated template. Each triangle is associated with an anatomical label.

  * `fitting/[ID]_fitted_lddmm_template.vtk`: this is the inflated template warped to optimally match the mesh above. The fit is not perfect but should be close.

  * `fitting/[ID]_fitted_dist_stat.json`: distance statistics of the fitting, including average, max, and 95th percentile of the distance. Useful to check for poor fitting results.


  * PA Yushkevich, L Xie, LEM Wisse, M Dong, S Ravikumar, R Ittyerah,  R de Flores, SR Das, DA Wolk for the Alzheimer’s Disease Neuroimaging Initiative (ADNI), Mapping Medial Temporal Lobe Longitudinal Change in Preclinical Alzheimer’s Disease, 2023 Alzheimer's Association International Conference (AAIC 2023).


pkgId: da8c262d18588c438fb76a4f364bbc66f5d36efa1f4c6fce9e429d1c6ffc93f7
name: python-crashs
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: CRASHS: Cortical Reconstruction for Automated Segmentation of Hippocampal Subfields (ASHS)
url: https://github.com/pyushkevich/crashs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crashs-0.2.6-1.src.rpm
checksum_type: sha256
description:
  CRASHS is a surface-based modeling and groupwise registration pipeline for the human medial temporal lobe (MTL). It can be used to perform groupwise analysis of pointwise measures in the MTL, such as cortical thickness, longitudinal volume change, functional MRI activation, microstructure, etc. It uses similar principles to whole-brain surface-based analysis pipelines like [FreeSurfer](https://surfer.nmr.mgh.harvard.edu/) and [CRUISE](https://doi.org/10.1016/j.neuroimage.2004.06.043), but restricted to the MTL region. CRASHS is used to postprocess the results of [ASHS](https://github.com/pyushkevich/ashs) segmentation with certain ASHS atlases.

  Some of the newer ASHS atlases include the white matter label, which is used by CRASHS. For other ASHS atlases, CRASHS can paint in the white matter label using [nnU-Net](https://github.com/MIC-DKFZ/nnUNet). CRASHS uses the [CRUISE](https://doi.org/10.1016/j.neuroimage.2004.06.043) technique implemented in the [NighRes software](https://nighres.readthedocs.io/en/latest/) to fit the white matter segmentation with a surface of spherical topology, and find a series of surfaces spanning between the gray/white boundary and the pial surface. The middle surface is inflated and registered to a population template, allowing surface-based analysis of MTL cortical thickness and other measures such as functional MRI and diffusion MRI.

  The CRASHS pipeline is described in the supplemental material to our paper in the special issue of Alzheimer's and Dementia on the [20th anniversary of ADNI](https://doi.org/10.1002/alz.14161).



  CRASHS requires the `nighres` package, which cannot be installed with `pip`. To install `nighres`, please follow the [installation instructions](https://nighres.readthedocs.io/en/latest/). To our knowledge, the ARM64 architecture (newer Macs) is currently not supported.

  Once `nighres` is installed, you can install CRASHS:

  ```sh
  pip install crashs
  python3 -m crashs fit --help
  ```

  Or, if you want to run the latest development code:

  ```sh
  git clone https://github.com/pyushkevich/crashs
  cd crashs
  pip install .
  ```


  The CRASHS Docker container is available on DockerHub as `pyushkevich/crashs:latest`. Please see instructions below on using the container.


  The main input to the package is the ASHS output folder. Before running CRASHS, you will need to run ASHS on your MRI scans using one of the atlases for which a CRASHS template is available.

  CRASHS offers different templates for different ASHS versions. Currently, the following templates are provided:

  * **ashs_pmc_t1**: Template for the T1-weighted MRI version of ASHS [T1-ASHS](https://doi.org/10.1002/hbm.24607) using the [ASHS-PMC-T1 atlas](https://www.nitrc.org/frs/?group_id=370). We recommend using the 2023 ASHS-PMC-T1 atlas with the white matter label. However, you can also provide segmentations created using the original ASHS-PMC-T1 atlas and the white matter label will be added to the existing segmentation automatically, using [nnUNet](https://github.com/MIC-DKFZ/nnUNet).

  * **ashs_pmc_alveus**: Template for the high-resolution oblique coronal T2-weighted MRI version of [ASHS](https://doi.org/10.1002/hbm.22627). The white matter label will be added to the existing segmentation and extended synthetically over the alveus/fimbria, as described in our [ADNI 20th anniversary paper](https://doi.org/10.1002/alz.14161).



  You can download the templates and pretrained models for running CRASHS from this link:

  * https://doi.org/10.5061/dryad.kkwh70scx

  Download and extract the archive and set the environment variable `CRASHS_DATA` to point to the folder in which you extract the archive.

  ```sh
  cp ~/Downloads/crashs_template_package_20240830.tgz /my/crashs/folder
  cd /my/crashs/folder
  tar -zxvf crashs_template_package_20240830.tgz
  export CRASHS_DATA=/my/crashs/folder/crashs_template_package_20240830
  ```

  We recommend adding the line above that sets the `CRASHS_DATA` environment variable to your `.bashrc`, `.bash_profile` or `.zshrc` file, depending on what shell you use. Alternatively, you can invoke CRASHS below with the `-C` switch to provide the path to the templates and models directory.



  An example segmentation using T1-ASHS is provided in the folder `sample_data`. It can be used to test CRASHS.

  If using Docker, run the following command to open a command prompt on the container. Be sure to adjust paths `your_output_directory` and `/my/crashs/folder/crashs_template_package_20240830` to match your system. These paths will be mapped to paths `/data` and `/package` in the container.

  ```sh
  docker run \
      -v your_output_directory:/data \
      -v /my/crashs/folder/crashs_template_package_20240830:/package \
      -it pyushkevich/crashs:latest /bin/bash
  ```

  Run this command inside of the container to run CRASHS on the example T1-ASHS segmentation.

  ```sh
  python3 -m crashs fit \
      -C /package -s right -c corr_usegray \
      sample_data/035_S_4082_2011-06-28 ashs_pmc_t1 /data/035_S_4082_2011-06-28
  ```

  You should find the output from running CRASHS in folder `your_output_directory/035_S_4082_2011-06-28` on your system.



  If using CRASHS installed with `pip`, download the dataset from the `sample_data` folder in this repository to some location on your system, call it `your_input_dir`. Create an output directory, `your_output_dir`. Make sure the `CRASHS_DATA` environment variable has been set as explained above. Then you can run CRASHS on the sample dataset as follows:

  ```sh
  python3 -m crashs fit \
      -s right -c corr_usegray \
      your_input_dir/035_S_4082_2011-06-28 ashs_pmc_t1 your_output_dir/035_S_4082_2011-06-28
  ```

  You should find the output from running CRASHS in folder `your_output_dir/035_S_4082_2011-06-28`.


  The program generates many outputs, but the most useful ones are:
  * `fitting/[ID]_fitted_omt_hw_target.vtk`: the grey/white and grey/csf boundaries estimated by the `cruise_cortex_extraction` module of NighRes. These meshes are in physical (RAS) coordinate space, not in voxel (IJK) space output by Nighres. *If you extract meshes from the T1-ASHS segmentation in ITK-SNAP, those should line up with these meshes.*

  * `fitting/[ID]_fitted_omt_hw_target.vtk`: the mid-surface of the gray matter estimated by the `volumetric_layering` module of NighRes. Also in RAS space.

  * `fitting/[ID]_fitted_omt_match_to_hw.vtk`: the template mesh projected onto the mid-surface surface, also in RAS space. This should have the same geometry as the mid-surface, but the same number of vertices/faces as the template. This mesh will also have scalar arrays for the anatomical label and other features from the template, such as template curvature (useful for visualization). **This mesh can be used to map data from subject space (thickness, fMRI, NODDI, etc) into template space for group analysis**

  * `thickness/[ID]_template_thickness.vtk`: a mesh with same geometry as the template that has a point array `VoronoiRadius` containing half-thickness of the gray matter at each vertex.

  * `thickness/[ID]_thickness_roi_summary.csv`: Mean and median half-thickness across gray matter ROIs.

  The following files can be used to check how well the fitting between the inflated template mid-surface and the inflated subject mid-surface worked.

  * `fitting/[ID]_fit_target_reduced.vtk`: this is the inflated and sub-sampled mid-surface mesh of the subject, affine transformed into the space of the inflated template. Each triangle is associated with an anatomical label.

  * `fitting/[ID]_fitted_lddmm_template.vtk`: this is the inflated template warped to optimally match the mesh above. The fit is not perfect but should be close.

  * `fitting/[ID]_fitted_dist_stat.json`: distance statistics of the fitting, including average, max, and 95th percentile of the distance. Useful to check for poor fitting results.


  * PA Yushkevich, L Xie, LEM Wisse, M Dong, S Ravikumar, R Ittyerah,  R de Flores, SR Das, DA Wolk for the Alzheimer’s Disease Neuroimaging Initiative (ADNI), Mapping Medial Temporal Lobe Longitudinal Change in Preclinical Alzheimer’s Disease, 2023 Alzheimer's Association International Conference (AAIC 2023).


pkgId: bd235adc0747185869de36c98e57449d5dd9a9438c775d22af8fd51568a40d9d
name: python-crashtest
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Manage Python errors with ease
url: https://github.com/sdispater/crashtest
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crashtest-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/sdispater/crashtest/actions/workflows/main.yml/badge.svg)](https://github.com/sdispater/crashtest/actions/workflows/main.yml)
  [![PyPI version](https://img.shields.io/pypi/v/crashtest)](https://pypi.org/project/crashtest/)

  Crashtest is a Python library that makes exceptions handling and inspection easier.


pkgId: 657c3893b85f86927e654fad3a6116c75590cf43915bb4c4f5c6d5e1693c4d42
name: python-crashvb-logging-utilities
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Consolidation of logging utilities.
url: https://pypi.org/project/crashvb-logging-utilities/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crashvb-logging-utilities-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![pypi version](https://img.shields.io/pypi/v/crashvb-logging-utilities.svg)](https://pypi.org/project/crashvb-logging-utilities)
  [![build status](https://github.com/server27nw/crashvb-logging-utilities/actions/workflows/main.yml/badge.svg)](https://github.com/server27nw/crashvb-logging-utilities/actions)
  [![coverage status](https://coveralls.io/repos/github/server27nw/crashvb-logging-utilities/badge.svg)](https://coveralls.io/github/server27nw/crashvb-logging-utilities)
  [![python versions](https://img.shields.io/pypi/pyversions/crashvb-logging-utilities.svg?logo=python&logoColor=FBE072)](https://pypi.org/project/crashvb-logging-utilities)
  [![linting](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/PyCQA/pylint)
  [![code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![license](https://img.shields.io/github/license/server27nw/crashvb-logging-utilities.svg)](https://github.com/server27nw/crashvb-logging-utilities/blob/master/LICENSE.md)



  Consolidation of logging utilities.




  ```
  $ pip install crashvb-logging-utilities
  ```



  ```bash
  $ git clone https://github.com/server27nw/crashvb-logging-utilities
  $ cd crashvb-logging-utilities
  $ virtualenv env
  $ source env/bin/activate
  $ python -m pip install --editable .[dev]
  ```



  ```python
  import click
  import logging
  import sys
  from traceback import print_exception
  from typing import NamedTuple

  from click.core import Context
  from crashvb_logging_utilities import LOGGING_DEFAULT, logging_options, set_log_levels

  LOGGER = logging.getLogger(__name__)

  class TypingContextObject(NamedTuple):
      
      ...
      verbosity: int

  @click.group()
  @logging_options
  @click.pass_context
  def cli(
      context: Context,
      verbosity: int = LOGGING_DEFAULT,
  ):
      """Main group."""

      if verbosity is None:
          verbosity = LOGGING_DEFAULT

      set_log_levels(verbosity)

      context.obj = TypingContextObject(
          
          verbosity=verbosity,
      )

  @cli.command(name="command1", ...)
  @click.option( ... )
  @click.pass_context
  def command1(context: Context, ...):
      """Command #1"""
      ctx = context.obj
      try:
  	    ...
      except Exception as exception:  # pylint: disable=broad-except
          if ctx.verbosity > 0:
              logging.fatal(exception)
          if ctx.verbosity > LOGGING_DEFAULT:
              exc_info = sys.exc_info()
              print_exception(*exc_info)
          sys.exit(1)

  ```



  | Variable | Default Value | Description |
  | ---------| ------------- | ----------- |



  [Source Control](https://github.com/server27nw/crashvb-logging-utilities)


pkgId: 147e9675278e394c93e2a32126095c6731a04f546538ef35173e669f5e1a516c
name: python-cratedb-sqlparse
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Parsing utilities to validate and split SQL statements for CrateDB.
url: https://pypi.org/project/cratedb-sqlparse/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cratedb-sqlparse-0.0.10-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/crate/cratedb-sqlparse.svg)](https://github.com/crate/cratedb-sqlparse/blob/main/LICENSE)
  [![PyPI version](https://img.shields.io/pypi/v/cratedb-sqlparse.svg)](https://pypi.org/project/cratedb-sqlparse/)
  [![PyPI downloads](https://pepy.tech/badge/cratedb-sqlparse/month)](https://pepy.tech/project/cratedb-sqlparse/)

  [![Tests](https://github.com/crate/cratedb-sqlparse/actions/workflows/python.yml/badge.svg)](https://github.com/crate/cratedb-sqlparse/actions/workflows/python.yml)
  [![Test coverage](https://img.shields.io/codecov/c/gh/crate/cratedb-sqlparse.svg)](https://codecov.io/gh/crate/cratedb-sqlparse/)
  [![Python versions](https://img.shields.io/pypi/pyversions/cratedb-sqlparse.svg)](https://pypi.org/project/cratedb-sqlparse/)

  [![Status](https://img.shields.io/pypi/status/cratedb-sqlparse.svg)](https://pypi.org/project/cratedb-sqlparse/)

  This package provides utilities to validate and split SQL statements specifically designed for
  CrateDB.

  It is built upon CrateDB's antlr4 grammar, ensuring accurate parsing tailored to CrateDB's SQL
  dialect.

  It draws inspiration from `sqlparse`.



  ```shell
  pip install cratedb-sqlparse
  ```





  ```python
  from cratedb_sqlparse import sqlparse

  query = """
      SELECT * FROM SYS.SHARDS;
      INSERT INTO doc.tbl VALUES (1);
  """
  statements = sqlparse(query)

  print(len(statements))


  select_query = statements[0]

  print(select_query.query)


  print(select_query.type)


  print(select_query.tree)

  ```



  By default exceptions are stored in `statement.exception`

  ```python
  from cratedb_sqlparse import sqlparse

  query = """
  SELECT COUNT(*) FROM doc.tbl f HERE f.id = 1;

  INSERT INTO doc.tbl VALUES (1, 23, 4);
  """
  statements = sqlparse(query)
  stmt = statements[0]

  if stmt.exception:
      print(stmt.exception.error_message)
      

      print(stmt.exception.original_query_with_error_marked)
      
      
      
      

      print(stmt.exception.offending_token.text)
      
  ```

  In some situations, you might want sqlparse to raise an exception.

  You can set `raise_exception` to `True`

  ```python
  from cratedb_sqlparse import sqlparse

  sqlparse('SELECT COUNT(*) FROM doc.tbl f WHERE .id = 1;', raise_exception=True)


  ```

  Catch the exception:

  ```python
  from cratedb_sqlparse import sqlparse, ParsingException

  try:
      t = sqlparse('SELECT COUNT(*) FROM doc.tbl f WHERE .id = 1;', raise_exception=True)[0]
  except ParsingException:
      print('Catched!')
  ```

  Note:

  It will only raise the first exception it finds, even if you pass in several statements.



  Query metadata can be read with `statement.metadata`

  ```python
  from cratedb_sqlparse import sqlparse

  stmt = sqlparse("SELECT A, B FROM doc.tbl12")

  print(stmt.metadata)

  ```



  Properties defined within a `WITH` statement, `statement.metadata.with_properties`.


  ```python
  from cratedb_sqlparse import sqlparse

  stmt = sqlparse("""
      CREATE TABLE doc.tbl12 (A TEXT) WITH (
        "allocation.max_retries" = 5,
        "blocks.metadata" = false
      );
  """)[0]

  print(stmt.metadata)

  ```


  ```python
  print(stmt.metadata.tables)


  table = stmt.metadata.tables[0]
  print(table.schema, table.name, table.fqn, sep='\n')



  ```





  Parameterized properties are properties without a real defined value, marked with a dollar string,  `metadata.parameterized_properties`

  ```python
  from cratedb_sqlparse import sqlparse

  stmt = sqlparse("""
      CREATE TABLE doc.tbl12 (A TEXT) WITH (
      "allocation.max_retries" = 5,
      "blocks.metadata" = $1
  );
  """)[0]

  print(stmt.metadata)

  ```

  In this case, `blocks.metadata` will be in `with_properties` and `parameterized_properties` as well.

  For values to be picked up they need to start with a dollar `'$'` and be preceded by integers, e.g. `'$1'`, `'$123'` -
  `'$123abc'` would not be valid.






  ```shell
  git clone https://github.com/crate/cratedb-sqlparse

  cd cratedb-sqlparse/cratedb_sqlparse_py

  python3 -m venv .venv

  source .venv/bin/activate

  pip install --editable='.[develop,generate,release,test]'
  ```

  Everytime you open a shell again you would need to run `source .venv/bin/activate`
  to use `poe` commands.



  ```shell
  poe check
  ```



  ```shell
  poe test
  ```



  ```shell
  poe test -k test_sqlparse_collects_exceptions_2
  ```



  ```shell
  poe lint
  ```


pkgId: 8dbf081395747288eba1415b78d850ada356d2f78986a88a84a632eee24a40fb
name: python-craterstats-gui
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/LWATLINGTON02/CraterStats-Capstone/tree/main
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-craterstats-gui-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  A graphical user interface for improving user experience when computing and generating crater statistics.

description:
  Northern Arizona University Senior Computer Science Capstone project.
  This project is to create a Graphical User Interface for the current [Craterstats3](https://github.com/ggmichael/craterstats) command line program.



  Due to the application still being in the alpha stage, the initialization for execution has environment requirements for running the application.<br>
  [Windows/Mac](https://github.com/LWATLINGTON02/CraterStats-Capstone/blob/main/User%20Guides/Windows.md) [Linux](https://github.com/LWATLINGTON02/CraterStats-Capstone/blob/main/User%20Guides/Linux.md)


  Upon running the application you should be greeted with the home screen.

  ![image](https://github.com/user-attachments/assets/4ed48b5e-8ec8-4966-8f36-f16c8f153ff7)

  In the toolbar, you can select the "Open" button from the "File" dropdown list. <br>
  If you do not have your own plot configuration and data files, you can download samples here:
  [Configuration File](https://github.com/LWATLINGTON02/CraterStats-Capstone/blob/main/Alpha/craterstats_config_files/checker.plt)
  [Data File](https://github.com/LWATLINGTON02/CraterStats-Capstone/blob/main/Alpha/sample/sample.scc) <br>
  ***Disclaimer: CraterstatsGUI can only process .scc and .diam files at this stage in development.***

  ![image](https://github.com/user-attachments/assets/f7a10ca5-b683-4984-8cfd-8e31173a2881)

  Select a plot configuration file.
  ![image](https://github.com/user-attachments/assets/a2d57c49-7c6f-4b94-a9ff-eb0dc209d537)

  After uploading a configuration file select the Plot Settings tab
  ![image](https://github.com/user-attachments/assets/88d970e8-596e-408d-912f-ce9ae22fdc88)

  Upon opening the Plot Settings page, upload a source file by selecting "Browse"
  ![image](https://github.com/user-attachments/assets/ce259393-73bf-4841-adb6-af27b59db951)

  Select your source file
  ![image](https://github.com/user-attachments/assets/0fcbd837-fca0-4538-af53-72370c16d551)

  After upload, the application should be displaying your plot configuration
  ![image](https://github.com/user-attachments/assets/6bd5898d-5fa6-4212-8baf-b4302821c56c)








  [Github](https://github.com/ggmichael/craterstats) of craterstats CLI program created and developed by Greg Michaels.


pkgId: 1c14b10a3414a0849d3b433c88e9963acad68d3472659814f14296531d0fe9f4
name: python-crawlee
arch: src
version: 0.3.8
epoch: 0
release: 1
summary: Crawlee for Python
url: https://crawlee.dev/python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crawlee-0.3.8-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
      <a href="https://crawlee.dev">
          <picture>
            <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/apify/crawlee-python/master/website/static/img/crawlee-dark.svg?sanitize=true">
            <img alt="Crawlee" src="https://raw.githubusercontent.com/apify/crawlee-python/master/website/static/img/crawlee-light.svg?sanitize=true" width="500">
          </picture>
      </a>
      <br>
      <small>A web scraping and browser automation library</small>
  </h1>

  <p align=center>
      <a href="https://badge.fury.io/py/crawlee" rel="nofollow">
          <img src="https://badge.fury.io/py/crawlee.svg" alt="PyPI version" style="max-width: 100%;">
      </a>
      <a href="https://pypi.org/project/crawlee/" rel="nofollow">
          <img src="https://img.shields.io/pypi/dm/crawlee" alt="PyPI - Downloads" style="max-width: 100%;">
      </a>
      <a href="https://pypi.org/project/crawlee/" rel="nofollow">
          <img src="https://img.shields.io/pypi/pyversions/crawlee" alt="PyPI - Python Version" style="max-width: 100%;">
      </a>
      <a href="https://discord.gg/jyEM2PRvMU" rel="nofollow">
          <img src="https://img.shields.io/discord/801163717915574323?label=discord" alt="Chat on discord" style="max-width: 100%;">
      </a>
  </p>

  Crawlee covers your crawling and scraping end-to-end and **helps you build reliable scrapers. Fast.**

  > 🚀 Crawlee for Python is open to early adopters!

  Your crawlers will appear almost human-like and fly under the radar of modern bot protections even with the default configuration. Crawlee gives you the tools to crawl the web for links, scrape data and persistently store it in machine-readable formats, without having to worry about the technical details. And thanks to rich configuration options, you can tweak almost any aspect of Crawlee to suit your project's needs if the default settings don't cut it.

  > 👉 **View full documentation, guides and examples on the [Crawlee project website](https://crawlee.dev/python/)** 👈

  We also have a TypeScript implementation of the Crawlee, which you can explore and utilize for your projects. Visit our GitHub repository for more information [Crawlee for JS/TS on GitHub](https://github.com/apify/crawlee).



  We recommend visiting the [Introduction tutorial](https://crawlee.dev/python/docs/introduction) in Crawlee documentation for more information.

  Crawlee is available as the [`crawlee`](https://pypi.org/project/crawlee/) PyPI package. The core functionality is included in the base package, with additional features available as optional extras to minimize package size and dependencies. To install Crawlee with all features, run the following command:

  ```sh
  pip install 'crawlee[all]'
  ```

  Then, install the [Playwright](https://playwright.dev/) dependencies:

  ```sh
  playwright install
  ```

  Verify that Crawlee is successfully installed:

  ```sh
  python -c 'import crawlee; print(crawlee.__version__)'
  ```

  For detailed installation instructions see the [Setting up](https://crawlee.dev/python/docs/introduction/setting-up) documentation page.



  The quickest way to get started with Crawlee is by using the Crawlee CLI and selecting one of the prepared templates. First, ensure you have [Pipx](https://pipx.pypa.io/) installed:

  ```sh
  pipx --help
  ```

  Then, run the CLI and choose from the available templates:

  ```sh
  pipx run crawlee create my-crawler
  ```

  If you already have `crawlee` installed, you can spin it up by running:

  ```sh
  crawlee create my-crawler
  ```



  Here are some practical examples to help you get started with different types of crawlers in Crawlee. Each example demonstrates how to set up and run a crawler for specific use cases, whether you need to handle simple HTML pages or interact with JavaScript-heavy sites. A crawler run will create a `storage/` directory in your current working directory.



  The [`BeautifulSoupCrawler`](https://crawlee.dev/python/api/class/BeautifulSoupCrawler) downloads web pages using an HTTP library and provides HTML-parsed content to the user. By default it uses [`HttpxHttpClient`](https://crawlee.dev/python/api/class/HttpxHttpClient) for HTTP communication and [BeautifulSoup](https://pypi.org/project/beautifulsoup4/) for parsing HTML. It is ideal for projects that require efficient extraction of data from HTML content. This crawler has very good performance since it does not use a browser. However, if you need to execute client-side JavaScript, to get your content, this is not going to be enough and you will need to use [`PlaywrightCrawler`](https://crawlee.dev/python/api/class/PlaywrightCrawler). Also if you want to use this crawler, make sure you install `crawlee` with `beautifulsoup` extra.

  ```python
  import asyncio

  from crawlee.beautifulsoup_crawler import BeautifulSoupCrawler, BeautifulSoupCrawlingContext


  async def main() -> None:
      crawler = BeautifulSoupCrawler(
          
          max_requests_per_crawl=10,
      )

      
      @crawler.router.default_handler
      async def request_handler(context: BeautifulSoupCrawlingContext) -> None:
          context.log.info(f'Processing {context.request.url} ...')

          
          data = {
              'url': context.request.url,
              'title': context.soup.title.string if context.soup.title else None,
          }

          
          await context.push_data(data)

          
          await context.enqueue_links()

      
      await crawler.run(['https://crawlee.dev'])

  if __name__ == '__main__':
      asyncio.run(main())
  ```



  The [`PlaywrightCrawler`](https://crawlee.dev/python/api/class/PlaywrightCrawler) uses a headless browser to download web pages and provides an API for data extraction. It is built on [Playwright](https://playwright.dev/), an automation library designed for managing headless browsers. It excels at retrieving web pages that rely on client-side JavaScript for content generation, or tasks requiring interaction with JavaScript-driven content. For scenarios where JavaScript execution is unnecessary or higher performance is required, consider using the [`BeautifulSoupCrawler`](https://crawlee.dev/python/api/class/BeautifulSoupCrawler). Also if you want to use this crawler, make sure you install `crawlee` with `playwright` extra.

  ```python
  import asyncio

  from crawlee.playwright_crawler import PlaywrightCrawler, PlaywrightCrawlingContext


  async def main() -> None:
      crawler = PlaywrightCrawler(
          
          max_requests_per_crawl=10,
      )

      
      @crawler.router.default_handler
      async def request_handler(context: PlaywrightCrawlingContext) -> None:
          context.log.info(f'Processing {context.request.url} ...')

          
          data = {
              'url': context.request.url,
              'title': await context.page.title(),
          }

          
          await context.push_data(data)

          
          await context.enqueue_links()

      
      await crawler.run(['https://crawlee.dev'])


  if __name__ == '__main__':
      asyncio.run(main())
  ```



  Explore our [Examples](https://crawlee.dev/python/docs/examples) page in the Crawlee documentation for a wide range of additional use cases and demonstrations.



  Why Crawlee is the preferred choice for web scraping and crawling?



  - Unified interface for **HTTP & headless browser** crawling.
  - Automatic **parallel crawling** based on available system resources.
  - Written in Python with **type hints** - enhances DX (IDE autocompletion) and reduces bugs (static type checking).
  - Automatic **retries** on errors or when you’re getting blocked.
  - Integrated **proxy rotation** and session management.
  - Configurable **request routing** - direct URLs to the appropriate handlers.
  - Persistent **queue for URLs** to crawl.
  - Pluggable **storage** of both tabular data and files.
  - Robust **error handling**.



  - Crawlee has out-of-the-box support for **headless browser** crawling (Playwright).
  - Crawlee has a **minimalistic & elegant interface** - Set up your scraper with fewer than 10 lines of code.
  - Complete **type hint** coverage.
  - Based on standard **Asyncio**.



  Crawlee is open-source and runs anywhere, but since it's developed by [Apify](https://apify.com), it's easy to set up on the Apify platform and run in the cloud. Visit the [Apify SDK website](https://docs.apify.com/sdk/python/) to learn more about deploying Crawlee to the Apify platform.



  If you find any bug or issue with Crawlee, please [submit an issue on GitHub](https://github.com/apify/crawlee-python/issues). For questions, you can ask on [Stack Overflow](https://stackoverflow.com/questions/tagged/apify), in GitHub Discussions or you can join our [Discord server](https://discord.com/invite/jyEM2PRvMU).



  Your code contributions are welcome, and you'll be praised for eternity! If you have any ideas for improvements, either submit an issue or create a pull request. For contribution guidelines and the code of conduct, see [CONTRIBUTING.md](https://github.com/apify/crawlee-python/blob/master/CONTRIBUTING.md).



  This project is licensed under the Apache License 2.0 - see the [LICENSE](https://github.com/apify/crawlee-python/blob/master/LICENSE) file for details.


pkgId: 2a9a7c1ebdafc0fd75f3d43400f62bdcf8e18f92aa3109130ea503fa42f884a6
name: python-crawler-framework
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Framework for crawling
url: https://pypi.org/project/crawler-framework/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crawler-framework-0.3.4-1.src.rpm
checksum_type: sha256
description:
  Main objective is to secure fast deployment of crawler system that will help you setup all that you need to
  get started with data mining interactively over cmd/terminal.
  Concept is based on long working experience and mistakes that have been learned over the years in data mining
  and database arhitecture. It could save you a lot of time and effort using this framework.
  Currently works on Win OS.


  Most important thing is that you have python 3 installed on your machine.

  **With virtual environment (recommended)**<br>
  To be able to make virtual environment you will need to ```pip3.7 install virtualenv```
  Location of your virtual environment on WinOS shoud be ```C:\Users\YourUsername\Envs```
  Then create virtual environment ```py -3.7 -m virtualenv Envs/crawler_framework``` <br>
  By default now your virtual environment should be active if it isn't activate your virtual
  environment by writing ```workon crawler_framework```  <br>
  Now you can install library  ```pip install crawler_framework```

  **Without virtual environment**<br>
  Just open cmd and write ```pip3.7 install crawler_framework```. This option is ok if you have only one version
  of python installed on your system. But if you have more python version installed and you decide to go with this
  option you will have to finish some additional question's during configuration of crawler framework.
  Like that it will be ensured that everything works ether way.



  Before we can deploy anything we must setup connection strings for one or more database
  servers that we are going to use.
  Currently supported are PostgreSQL, Oracle and Microsoft SQL Server.

  <i>It is recommended to create database on your server that will only be used by framework. </i>


  Open cmd/terminal and write  ```config.py```. If everything goes well you should see this options below.
  It is possible that program asks for some additional information if you have more than one python interpreter
  installed on your machine and you did not use virtual environment. But it will be required only once.

  ![dbconfig](https://raw.githubusercontent.com/DraganMatesic/crawler_framework/master/images/config.PNG)

  Create all database connection's that you think you will use, from database where you will deploy crawler_framework
  to database where you will store data etc. by selecting option number 1 and then database option number one.

  ![dbconfig](https://raw.githubusercontent.com/DraganMatesic/crawler_framework/master/images/dbconfig.PNG)


  **Microsoft SQL Server** <br>
   If you are using default option be sure to define in ODBC Data sources administrator dsn name that will have
   default database that will be used for framework. If you are using pymssql you will define server_ip, port and database
   during database configuration stage.


  Open cmd/terminal and write  ```config.py```. Select option 2 (Deploy framework) and then select option from
  the list of connections you created that is going to be used for deployment. This will deploy table structure in selected database
  on selected server connection. In our case we will deploy it on PostgreSQL localhost server.


  You can skip this if you are not planing to use tor as your proxy provider but only public proxies.

  Open cmd/terminal and write  ```config.py```. Select option 4 (Tor setup). Then from to setup option select option 1(Install),
  this will automatically install tor expert bundle with all necessary directories and subdirectories.

  If you have already have installed and then changed default options then this will reset those options back to default just like some kind of reinstall.

  Setup option 2 (Tor options) allows you to change some of defaults when constructing our tor network such as
  how many tor instances should run in same time or how long time must pass before changing and identity of tor instance.


  Proxy server is multifunctional program that acquires new proxies(crawlers), test proxies, creates tor network etc.

  Open cmd/terminal and write  ```config.py```. Select option 3 (Run proxy server).

  From suboptions you can select suboption 0 to run all both public proxy and tor service or suboption 1 to run only public proxy gatherer or
  suboption 2 to run only tor service. <br><br>
  Suboption 2 is great if you want to run tor service on another pc inside your network.
  By doing so you can increase number of tor that will run but it will not hog your local CPU and RAM.
  <br><br>
  All data will be saved in database where you have deployed crawler_framewok.
  If you didn't made deployment then this will probably end with exceptions.


