# packages

pkgId: dea3582cf24d9e4e85e87b6a9d8ec2e3a669634d1281d7d1cce91136dad3eb55
name: python-controlflow
arch: src
version: 0.11.4
epoch: 0
release: 1
summary: A framework for building agentic LLM workflows
url: https://pypi.org/project/controlflow/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-controlflow-0.11.4-1.src.rpm
checksum_type: sha256
description:
  ![ControlFlow Banner](https://github.com/PrefectHQ/ControlFlow/blob/main/docs/assets/brand/controlflow_banner.png)



  **ControlFlow is a Python framework for building agentic AI workflows.**

  ControlFlow provides a structured, developer-focused framework for defining workflows and delegating work to LLMs, without sacrificing control or transparency:

  - Create discrete, observable [tasks](https://controlflow.ai/concepts/tasks) for an AI to work on.
  - Assign one or more specialized AI [agents](https://controlflow.ai/concepts/agents) to each task.
  - Combine tasks into a [flow](https://controlflow.ai/concepts/flows) to orchestrate more complex behaviors.


  The simplest ControlFlow workflow has one task, a default agent, and automatic thread management:

  ```python
  import controlflow as cf

  result = cf.run("Write a short poem about artificial intelligence")

  print(result)
  ```
  **Result:**
  ```
  In circuits and code, a mind does bloom,
  With algorithms weaving through the gloom.
  A spark of thought in silicon's embrace,
  Artificial intelligence finds its place.
  ```


  ControlFlow addresses the challenges of building AI-powered applications that are both powerful and predictable:

  - 🧩 [**Task-Centric Architecture**](https://controlflow.ai/concepts/tasks): Break complex AI workflows into manageable, observable steps.
  - 🔒 [**Structured Results**](https://controlflow.ai/patterns/task-results): Bridge the gap between AI and traditional software with type-safe, validated outputs.
  - 🤖 [**Specialized Agents**](https://controlflow.ai/concepts/agents): Deploy task-specific AI agents for efficient problem-solving.
  - 🎛️ [**Flexible Control**](https://controlflow.ai/patterns/instructions): Continuously tune the balance of control and autonomy in your workflows.
  - 🕹️ [**Multi-Agent Orchestration**](https://controlflow.ai/concepts/flows): Coordinate multiple AI agents within a single workflow or task.
  - 🔍 [**Native Observability**](https://github.com/PrefectHQ/prefect): Monitor and debug your AI workflows with full Prefect 3.0 support.
  - 🔗 **Ecosystem Integration**: Seamlessly work with your existing code, tools, and the broader AI ecosystem.




  Install ControlFlow with `pip`:

  ```bash
  pip install controlflow
  ```

  Next, configure your LLM provider. ControlFlow's default provider is OpenAI, which requires the `OPENAI_API_KEY` environment variable:

  ```
  export OPENAI_API_KEY=your-api-key
  ```

  To use a different LLM provider, [see the LLM configuration docs](https://controlflow.ai/guides/configure-llms).




  Here's a more involved example that showcases user interaction, a multi-step workflow, and structured outputs:

  ```python
  import controlflow as cf
  from pydantic import BaseModel


  class ResearchProposal(BaseModel):
      title: str
      abstract: str
      key_points: list[str]


  @cf.flow
  def research_proposal_flow():

      
      user_input = cf.Task(
          "Work with the user to choose a research topic",
          interactive=True,
      )

      
      proposal = cf.run(
          "Generate a structured research proposal",
          result_type=ResearchProposal,
          depends_on=[user_input]
      )

      return proposal


  result = research_proposal_flow()

  print(result.model_dump_json(indent=2))
  ```
  <details>
  <summary><i>Click to see results</i></summary>
  </br>

  >**Conversation:**
  > ```text
  > Agent: Hello! I'm here to help you choose a research topic. Do you have
  > any particular area of interest or field you would like to explore?
  > If you have any specific ideas or requirements, please share them as well.
  >
  > User: Yes, I'm interested in LLM agentic workflows
  > ```
  >
  > **Proposal:**
  > ```json
  > {
  >     "title": "AI Agentic Workflows: Enhancing Efficiency and Automation",
  >     "abstract": "This research proposal aims to explore the development and implementation of AI agentic workflows to enhance efficiency and automation in various domains. AI agents, equipped with advanced capabilities, can perform complex tasks, make decisions, and interact with other agents or humans to achieve specific goals. This research will investigate the underlying technologies, methodologies, and applications of AI agentic workflows, evaluate their effectiveness, and propose improvements to optimize their performance.",
  >     "key_points": [
  >         "Introduction: Definition and significance of AI agentic workflows, Historical context and evolution of AI in workflows",
  >         "Technological Foundations: AI technologies enabling agentic workflows (e.g., machine learning, natural language processing), Software and hardware requirements for implementing AI workflows",
  >         "Methodologies: Design principles for creating effective AI agents, Workflow orchestration and management techniques, Interaction protocols between AI agents and human operators",
  >         "Applications: Case studies of AI agentic workflows in various industries (e.g., healthcare, finance, manufacturing), Benefits and challenges observed in real-world implementations",
  >         "Evaluation and Metrics: Criteria for assessing the performance of AI agentic workflows, Metrics for measuring efficiency, accuracy, and user satisfaction",
  >         "Proposed Improvements: Innovations to enhance the capabilities of AI agents, Strategies for addressing limitations and overcoming challenges",
  >         "Conclusion: Summary of key findings, Future research directions and potential impact on industry and society"
  >     ]
  > }
  > ```
  </details>

  In this example, ControlFlow is automatically managing a `flow`, or a shared context for a series of tasks. You can switch between standard Python functions and agentic tasks at any time, making it easy to incrementally build out complex workflows.



  To dive deeper into ControlFlow:

  - [Read the full documentation](https://controlflow.ai)
  - [Explore example projects](https://controlflow.ai/examples)
  - [Join our community on Slack](https://prefect.io/slack)


pkgId: b5cd3cb077e5adabf3fedff0317681797ef6f290e57ed1576c0f57354f0a5d3c
name: python-controlib
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A Python package for advanced control systems design and deployment.
url: https://pypi.org/project/controlib/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-controlib-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A Python package for control system design and deployment.

  ControLib is a package to help users design advanced control systems, test and benchmark them, and deploy them on a few selected embedded platforms (Arduino, STM32 Nucleo, Raspberry Pi). By advanced, we are referring to control systems beyond the realm of classical control (e.g. Model Predictive Control), especially those that are heavily reliant on machine learning and/or optimisation. Some classical control systems (e.g. PID controllers) will be included as well.

  Some Simulink models will also be provided. To interact with these using Python, ControLib will use the [PySimlink](https://github.com/lharri73/PySimlink) package.

  ControLib will support Software-in-the-loop, Processor-in-the-loop, and Hardware-in-the-loop testing, although the extent to which it will do so is yet to be determined.

  Please note that development is still in the very early stages, and it might take a while before a stable version is released.



  The package's main features and capabilities will be announced and listed here as soon as they are added.



  An empty version of the package will be published on PyPI soon. For subsequent releases, the package will be available for installation using pip and git.



  Once some basic functionality has been added to the package, a small tutorial on how to use it will be presented here.



  An official documentation website will be released soon.



  Coming soon...



  Coming soon...



  This package is licenced under the [GNU General Public License v3.0](LICENSE).



  ControLib is currently being developed and maintained by Miguel Loureiro, a mechanical engineer who specialises in control systems, machine learning, and optimisation.

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


pkgId: a61dbe52858f9a5dcdfed646a6ed2394bc83b6a9ce82a2dfb9610be59f06b1f6
name: python-controlib
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A Python package for advanced control systems design and deployment.
url: https://pypi.org/project/controlib/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-controlib-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A Python package for control system design and deployment.

  ControLib is a package to help users design advanced control systems, test and benchmark them, and deploy them on a few selected embedded platforms (Arduino, STM32 Nucleo, Raspberry Pi). By advanced, we are referring to control systems beyond the realm of classical control (e.g. Model Predictive Control), especially those that are heavily reliant on machine learning and/or optimisation. Some classical control systems (e.g. PID controllers) will be included as well.

  Some Simulink models will also be provided. To interact with these using Python, ControLib will use the [PySimlink](https://github.com/lharri73/PySimlink) package.

  ControLib will support Software-in-the-loop, Processor-in-the-loop, and Hardware-in-the-loop testing, although the extent to which it will do so is yet to be determined.

  Please note that development is still in the very early stages, and it might take a while before a stable version is released.



  The package's main features and capabilities will be announced and listed here as soon as they are added.



  An empty version of the package will be published on PyPI soon. For subsequent releases, the package will be available for installation using pip and git.



  An official documentation website containing installation instructions, user guides, an API reference, examples, and a contribution guide,  will be released soon.



  Nothing to report.



  This package is licenced under the [GNU General Public License v3.0](LICENSE).



  ControLib is currently being developed and maintained by Miguel Loureiro, a mechanical engineer who specialises in control systems, machine learning, and optimisation.

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


pkgId: 869512b73ee0ff8bc75f25e85f12c8f6550ca188fcbd14c6cf55a674ba3d2466
name: python-controlnet-aux
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: Auxillary models for controlnet
url: https://github.com/patrickvonplaten/controlnet_aux
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-controlnet-aux-0.0.9-1.src.rpm
checksum_type: sha256
description:
  This is a PyPi installable package of [lllyasviel's ControlNet Annotators](https://github.com/lllyasviel/ControlNet/tree/main/annotator)

  The code is copy-pasted from the respective folders in <https://github.com/lllyasviel/ControlNet/tree/main/annotator> and connected to [the 🤗 Hub](https://huggingface.co/lllyasviel/Annotators).

  All credit & copyright goes to <https://github.com/lllyasviel> .



  ```
  pip install -U controlnet-aux
  ```

  To support DWPose which is dependent on MMDetection, MMCV and MMPose

  ```
  pip install -U openmim
  mim install mmengine
  mim install "mmcv>=2.0.1"
  mim install "mmdet>=3.1.0"
  mim install "mmpose>=1.1.0"
  ```



  You can use the processor class, which can load each of the auxiliary models with the following code

  ```python
  import requests
  from PIL import Image
  from io import BytesIO

  from controlnet_aux.processor import Processor


  url = "https://huggingface.co/lllyasviel/sd-controlnet-openpose/resolve/main/images/pose.png"

  response = requests.get(url)
  img = Image.open(BytesIO(response.content)).convert("RGB").resize((512, 512))








  processor_id = 'scribble_hed'
  processor = Processor(processor_id)

  processed_image = processor(img, to_pil=True)
  ```

  Each model can be loaded individually by importing and instantiating them as follows

  ```python
  from PIL import Image
  import requests
  from io import BytesIO
  from controlnet_aux import HEDdetector, MidasDetector, MLSDdetector, OpenposeDetector, PidiNetDetector, NormalBaeDetector, LineartDetector, LineartAnimeDetector, CannyDetector, ContentShuffleDetector, ZoeDetector, MediapipeFaceDetector, SamDetector, LeresDetector, DWposeDetector


  url = "https://huggingface.co/lllyasviel/sd-controlnet-openpose/resolve/main/images/pose.png"

  response = requests.get(url)
  img = Image.open(BytesIO(response.content)).convert("RGB").resize((512, 512))


  hed = HEDdetector.from_pretrained("lllyasviel/Annotators")
  midas = MidasDetector.from_pretrained("lllyasviel/Annotators")
  mlsd = MLSDdetector.from_pretrained("lllyasviel/Annotators")
  open_pose = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
  pidi = PidiNetDetector.from_pretrained("lllyasviel/Annotators")
  normal_bae = NormalBaeDetector.from_pretrained("lllyasviel/Annotators")
  lineart = LineartDetector.from_pretrained("lllyasviel/Annotators")
  lineart_anime = LineartAnimeDetector.from_pretrained("lllyasviel/Annotators")
  zoe = ZoeDetector.from_pretrained("lllyasviel/Annotators")
  sam = SamDetector.from_pretrained("ybelkada/segment-anything", subfolder="checkpoints")
  mobile_sam = SamDetector.from_pretrained("dhkim2810/MobileSAM", model_type="vit_t", filename="mobile_sam.pt")
  leres = LeresDetector.from_pretrained("lllyasviel/Annotators")
  teed = TEEDdetector.from_pretrained("fal-ai/teed", filename="5_model.pth")
  anyline = AnylineDetector.from_pretrained(
      "TheMistoAI/MistoLine", filename="MTEED.pth", subfolder="Anyline"
  )






  import torch
  device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  dwpose = DWposeDetector(det_config=det_config, det_ckpt=det_ckpt, pose_config=pose_config, pose_ckpt=pose_ckpt, device=device)


  canny = CannyDetector()
  content = ContentShuffleDetector()
  face_detector = MediapipeFaceDetector()
  lineart_standard = LineartStandardDetector()



  processed_image_hed = hed(img)
  processed_image_midas = midas(img)
  processed_image_mlsd = mlsd(img)
  processed_image_open_pose = open_pose(img, hand_and_face=True)
  processed_image_pidi = pidi(img, safe=True)
  processed_image_normal_bae = normal_bae(img)
  processed_image_lineart = lineart(img, coarse=True)
  processed_image_lineart_anime = lineart_anime(img)
  processed_image_zoe = zoe(img)
  processed_image_sam = sam(img)
  processed_image_leres = leres(img)
  processed_image_teed = teed(img, detect_resolution=1024)
  processed_image_anyline = anyline(img, detect_resolution=1280)

  processed_image_canny = canny(img)
  processed_image_content = content(img)
  processed_image_mediapipe_face = face_detector(img)
  processed_image_dwpose = dwpose(img)
  processed_image_lineart_standard = lineart_standard(img, detect_resolution=1024)
  ```



  In order to maintain the image aspect ratio, `detect_resolution`, `image_resolution` and images sizes need to be using multiple of `64`.


pkgId: 035d715644e1ad7a9f795519135f215743e9e4b1509d6d82f0939cef55f22e16
name: python-controlpyweb
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A project to facilitate easy read/write to the ControlByWeb line of Automation/SCADA IO products.
url: https://github.com/washad/ControlPyWeb
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-controlpyweb-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A project to facilitate easy read/write to the ControlByWeb line of Automation/SCADA IO products.



  Xytronic Research makes a handy line of remote IO products useful for home and industrial
  automation. Interacting with these modules generally requires the use
  of a url library such as requests, and then requires dissecting the response to be dissected
  and processed. While not terribly difficult to do, it is repetitive.

  This module seeks to abstract out some of that effort in a thought out and tested way.


  pip install controlpyweb



  The basis of functionality is the WebIOModule class. It both acts as a container for individual
  IO and handles interaction with the hardware.

  ~~~~
  from controlpyweb.webio_module import WebIOModule
  from controlpyweb.single_io import DiscreteIn, DiscreteOut, AnalogIn, AnalogOut


  class X404DigitalIn(WebIOModule):   # Name the class whatever you like
      StartButton = DiscreteIn("Start Button", "startButton")
      StopButton = DiscreteIn("Stop Button", "stopButton")
      DoorClosed = DiscreteIn("Door Closed", "doorClosed")


  class X410DigitalOut(WebIOModule):
      StartLamp = DiscreteOut("Start Lapm", "redLamp")
      MaintLight = DiscreteOut("Maintenance Lamp", "lamp1")


  digital_in = X404DigitalIn("192.168.1.1")
  relay_out = X410DigitalOut("192.168.1.2")


  digital_in.update_from_module()

  relay_out.StartLamp = digital_in.StartButton
  relay_out.MaintLight = not digital_in.DoorClosed

  relay_out.send_changes_to_module()
  ~~~~



  ~~~~
  relay_out.StartLamp.write_immediate(True)
  is_started = digital_in.read_immediate()
  ~~~~

  (However, immediate reads/writes are costly from a resource perspective and should be avoided.)




  ~~~~
  if discrete_in.StartButton and discrete_in.DoorClosed:
      discrete_out.StartMachine = True
  ~~~~


pkgId: a29685bc1700bdac6fcb654768851bdba5ab5f62f7bd4ecf019b9ef3905d1598
name: python-conttest
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Simple continuous testing tool
url: https://github.com/eigenhombre/continuous-testing-helper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conttest-0.0.8-1.src.rpm
checksum_type: sha256
description:
  Continuous testing helper, adapted from [1], but which makes no
  assumption about what tests you might want to run continuously while
  developing.  For more information, see [this blog post](http://eigenhombre.com/testing/2012/03/31/ontinuous-testing-in-python-clojure-and-blub/).

  **Any command supplied to the script will be run once and
  then repeated any time the code in the current working directory
  changes.**  You may wish to edit the IGNORE_* tuples to suit your
  particular setup.

  Note that ANY command you supply the script will be run, so be
  careful.  You have been warned!

  [1] https://github.com/brunobord/tdaemon/blob/master/tdaemon.py



      ./setup.py install  # from source
  or

      pip install conttest  # use sudo if installing globally



      conttest nosetests
      conttest 'nosetests -q && pep8 -r .'

  Placing a file .conttest-excludes in the current working directory
  will exclude subdirectories, e.g.:

      .svn$
      .git
      build
      vendor/elastic*
      install

  will match files against the listed regular expressions and skip checking
  for changes in those directories.  This can save quite a bit of time and CPU
  during normal operation.



  [John Jacobsen](http://eigenhombre.com)



  Eclipse Public License

  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 OF THIRD PARTY RIGHTS. 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: 3c8dd5b2cbab7c86e4aaffdf53228f503ca12d5cc6cd2ed8eb4dddb38d4decfb
name: python-contxt-sdk
arch: src
version: 6.4.0
epoch: 0
release: 1
summary: Contxt SDK from ndustrial
url: https://github.com/ndustrialio/contxt-sdk-python
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-contxt-sdk-6.4.0-1.src.rpm
checksum_type: sha256
description:
  _the Python SDK for Contxt_

  [![CI](https://github.com/ndustrialio/contxt-sdk-python/workflows/CI/badge.svg)](https://github.com/ndustrialio/contxt-sdk-python/actions?query=workflow%3ACI)
  [![pypi version](https://img.shields.io/pypi/v/contxt-sdk.svg)](https://pypi.org/project/contxt-sdk/)
  ![python](https://img.shields.io/badge/python-3.8+-blue.svg)



  ```sh
  pip install contxt-sdk
  ```



  ```sh
  contxt --help
  ```



  ```sh
  docker compose up -d --wait
  poetry run poe test
  docker compose down
  ```



  Please refer to <https://ndustrialio.github.io/contxt-sdk-python>.



  Please refer to [CONTRIBUTING.md](CONTRIBUTING.md).


pkgId: d5559268942d192c4db8d50e2aeef9f28729a18824d8c2d04175a41d1a92a15a
name: python-conventional-pre-commit
arch: src
version: 3.6.0
epoch: 0
release: 1
summary: A pre-commit hook that checks commit messages for Conventional Commits formatting.
url: https://pypi.org/project/conventional-pre-commit/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conventional-pre-commit-3.6.0-1.src.rpm
checksum_type: sha256
description:
  A [`pre-commit`](https://pre-commit.com) hook to check commit messages for
  [Conventional Commits](https://conventionalcommits.org) formatting.

  Works with Python >= 3.8.



  Make sure `pre-commit` is [installed](https://pre-commit.com#install).

  Create a blank configuration file at the root of your repo, if needed:

  ```console
  touch .pre-commit-config.yaml
  ```

  Add a new repo entry to your configuration file:

  ```yaml
  repos:
    

    - repo: https://github.com/compilerla/conventional-pre-commit
      rev: <git sha or tag>
      hooks:
        - id: conventional-pre-commit
          stages: [commit-msg]
          args: []
  ```

  Install the `pre-commit` script:

  ```console
  pre-commit install --hook-type commit-msg
  ```

  Make a (normal) commit :x::

  ```console
  $ git commit -m "add a new feature"

  [INFO] Initializing environment for ....
  Conventional Commit......................................................Failed
  - hook id: conventional-pre-commit
  - duration: 0.07s
  - exit code: 1

  [Bad commit message] >> add a new feature
  Your commit message does not follow Conventional Commits formatting
  https://www.conventionalcommits.org/
  ```

  And with the `--verbose` arg:

  ```console
  $ git commit -m "add a new feature"

  [INFO] Initializing environment for ....
  Conventional Commit......................................................Failed
  - hook id: conventional-pre-commit
  - duration: 0.07s
  - exit code: 1

  [Bad commit message] >> add a new feature
  Your commit message does not follow Conventional Commits formatting
  https://www.conventionalcommits.org/

  Conventional Commit messages follow a pattern like:

      type(scope): subject

      extended body

  Please correct the following errors:

    - Expected value for 'type' but found none.
    - Expected value for 'delim' but found none.
    - Expected value for 'subject' but found none.

  Run:

      git commit --edit --file=.git/COMMIT_EDITMSG

  to edit the commit message and retry the commit.
  ```

  Make a (conventional) commit :heavy_check_mark::

  ```console
  $ git commit -m "feat: add a new feature"

  [INFO] Initializing environment for ....
  Conventional Commit......................................................Passed
  - hook id: conventional-pre-commit
  - duration: 0.05s
  ```



  `conventional-pre-commit` can also be installed and used from the command line:

  ```shell
  pip install conventional-pre-commit
  ```

  Then run the command line script:

  ```shell
  conventional-pre-commit [types] input
  ```

  - `[types]` is an optional list of Conventional Commit types to allow (e.g. `feat fix chore`)

  - `input` is a file containing the commit message to check:

  ```shell
  conventional-pre-commit feat fix chore ci test .git/COMMIT_MSG
  ```

  Or from a Python program:

  ```python
  from conventional_pre_commit.format import is_conventional


  print(is_conventional("feat: this is a conventional commit"))


  print(is_conventional("nope: this is not a conventional commit"))


  print(is_conventional("custom: this is a conventional commit", types=["custom"]))
  ```



  `conventional-pre-commit` supports a number of arguments to configure behavior:

  ```shell
  $ conventional-pre-commit -h
  usage: conventional-pre-commit [-h] [--no-color] [--force-scope] [--scopes SCOPES] [--strict] [--verbose] [types ...] input

  Check a git commit message for Conventional Commits formatting.

  positional arguments:
    types            Optional list of types to support
    input            A file containing a git commit message

  options:
    -h, --help       show this help message and exit
    --no-color       Disable color in output.
    --force-scope    Force commit to have scope defined.
    --scopes SCOPES  Optional list of scopes to support. Scopes should be separated by commas with no spaces (e.g. api,client)
    --strict         Force commit to strictly follow Conventional Commits formatting. Disallows fixup! style commits.
    --verbose        Print more verbose error output.
  ```

  Supply arguments on the command-line, or via the pre-commit `hooks.args` property:

  ```yaml
  repos:
    - repo: https://github.com/compilerla/conventional-pre-commit
      rev: <git sha or tag>
      hooks:
        - id: conventional-pre-commit
          stages: [commit-msg]
          args: [--strict, --force-scope, feat, fix, chore, test, custom]
  ```

  **NOTE:** when using as a pre-commit hook, `input` is supplied automatically (with the current commit's message).



  `conventional-pre-commit` comes with a [VS Code devcontainer](https://code.visualstudio.com/learn/develop-cloud/containers)
  configuration to provide a consistent development environment.

  With the `Remote - Containers` extension enabled, open the folder containing this repository inside Visual Studio Code.

  You should receive a prompt in the Visual Studio Code window; click `Reopen in Container` to run the development environment
  inside the devcontainer.

  If you do not receive a prompt, or when you feel like starting from a fresh environment:

  1. `Ctrl/Cmd+Shift+P` to bring up the command palette in Visual Studio Code
  1. Type `Remote-Containers` to filter the commands
  1. Select `Rebuild and Reopen in Container` to completely rebuild the devcontainer
  1. Select `Reopen in Container` to reopen the most recent devcontainer build



  Versioning generally follows [Semantic Versioning](https://semver.org/).



  Releases to PyPI and GitHub are triggered by pushing a tag.

  1. Ensure all changes for the release are present in the `main` branch
  1. Tag with the new version: `git tag vX.Y.Z` for regular release, `git tag vX.Y.Z-preN` for pre-release
  1. Push the new version tag: `git push origin vX.Y.Z`



  [Apache 2.0](LICENSE)

  Inspired by matthorgan's [`pre-commit-conventional-commits`](https://github.com/matthorgan/pre-commit-conventional-commits).

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


pkgId: 0ff2515c403cd8da449c6ff4de4894a9bf050a848e2155d34fc99610edba93b3
name: python-convergence-entropy-metric
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/convergence-entropy-metric/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convergence-entropy-metric-1.2.0-1.src.rpm
checksum_type: sha256
description:
  The following is a full implementation of the convergence-entropy measurement framework (here referred to as Entropy-conVergence Metric, or EVM) as described in Rosen and Dale 2023. We've taken strides to make this package as easy to implement as possible.

  At its core there are two things that researchers need to define for the most basic version of the EVM algorithm. Those are:

  1. A word vector model (we suggest those implemented in the HuggingFace transformer library)
  2. An entropy object

  Demonstrating how this would look in code:

  ```python
  from EVM import EVM, languageModelLayers
  from transformers import AutoTokenizer, AutoModel

  wv = languageModelLayers('roberta-base', layers=[7])

  mod = EVM(
      word_vector_model = wv
  )

  mod('No political action can be taken without first consulting the populace', 'it is the prerogative of the political class to make decisions'), \
  mod('No political action can be taken without first consulting the populace', 'Ultimately the populace has to have the right to decide their own fate')
  ```

  The above returns the entropy for the first sentence upon having read the second sentence, consistent with the equations and formulation listed in Rosen and Dale 2023.


  The Convergence Entropy Data Analysis package (CEDA) is an end-to-end shell designed to facilitate GPU assisted, fast analyses. Implementationally, it is quite simple.

  ```python
  from CEDA import ceda_model

  GRAPH = ceda_model(
      sigma=1.,
      device='cuda',
      wv_model='roberta-base',
      wv_layers=[7]
  )
  ```

  Where `wv_model` is parameter for the string name of any model available from the HuggingFace library of language models, and `wv_layers` selects which hidden layers to attenuate to from the language model when producing a representation of lexical units.

  On run-time, one can pass to the model a list of strings for both utterances $x$ and $y$ (see Rosen & Dale 2023 for terminology).

  ```python
  x_sentences = ['a list of', 'sentences']
  y_sentences = ['another list', 'of more sentences']

  GRAPH.fit(x_sentences, y_sentences)
  GRAPH.add_meta_data(
      meta_data = [
          {'a': 1, 'b': 2}, # a records oriented json object for metadata for each comparison in the graph.
                            
      ]
  )
  ```

  If there are repeated sentences in `x_sentence` or `y_sentences` it is worthwhile to sort the lists so as to cluster repetitions. This is because the model is designed to optimize for repeated examples by only generating vector representations for an utterance once in either the $x$ or $y$ variable so long as that element is repeated. Thus if you have a list of comparisons

  ```python
  x_sentences = ['Sentence A', 'Sentence A', 'Sentence B']
  y_sentences = ['sentence c', 'sentence d', 'sentence e']
  ```

  `ceda_model` will generate vectors for 'Sentence A' once, until it reaches 'Sentence B' in `x_sentences`.

  This creates a graph that can be used for any number of convergence-entropy based analyses, complete with metadata.

  Finally, one can save a checkpoint for the graph using the checkpoint function

  ```python
  CKPT_PATH = 'path/to/checkpoint.pt'
  GRAPH.checkpoint(CKPT_PATH)
  ```

  Saving a graph using the `.checkpoint()` has the added benefit, too, of allowing you to load a CEDA graph object from that checkpoint later.

  ```python
  CKPT_PATH = 'path/to/checkpoint.pt'
  GRAPH.load_from_checkpoint(CKPT_PATH)
  ```

  You can also create a dataframe for the graph to be saved as a .csv or other format.

  ```python
  CKPT_PATH = 'path/to/checkpoint.csv'
  df = GRAPH.graph_df()
  df.to_csv(CKPT_PATH, index=False, encoding='utf-8')
  ```

  A number of built-in visualization tools are included as well in the `EDA` package. We will expand on that documentation at a later date.



  Any use of this package should cite it using the following:

  ```
  @article{rosen_dale_berts_2023,
  	title = {{BERTs} of a feather: {Studying} inter- and intra-group communication via information theory and language models},
  	shorttitle = {{BERTs} of a feather},
  	url = {https://link.springer.com/10.3758/s13428-023-02267-2},
  	doi = {10.3758/s13428-023-02267-2},
  	journal = {Behavior Research Methods},
  	author = {Rosen, Zachary P and Dale, Rick},
  	year = {2023},
  }
  ```


pkgId: cb325289186db2004fc16aa615195fabacf12d3c1aab485dfa982d923c6a9678
name: python-convergence-entropy-metric
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/convergence-entropy-metric/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convergence-entropy-metric-1.2.3-1.src.rpm
checksum_type: sha256
description:
  The following is a full implementation of the convergence-entropy measurement framework (here referred to as Entropy-conVergence Metric, or EVM) as described in Rosen and Dale 2023. We've taken strides to make this package as easy to implement as possible.

  At its core there are two things that researchers need to define for the most basic version of the EVM algorithm. Those are:

  1. A word vector model (we suggest those implemented in the HuggingFace transformer library)
  2. An entropy object

  Demonstrating how this would look in code:

  ```python
  from convergence_entropy.CEM import CEM, languageModelLayers
  from transformers import AutoTokenizer, AutoModel

  wv = languageModelLayers('roberta-base', layers=[7])

  mod = CEM(
      wv_model = wv
  )

  mod('No action can be taken without first consulting the voters', 'it is the prerogative of politicians alone to make decisions'), \
  mod('No action can be taken without first consulting the voters', 'ultimately the people have to have the right to decide what we do next')
  ```

  The above returns the entropy for the first sentence upon having read the second sentence, consistent with the equations and formulation listed in Rosen and Dale 2023.


  The Convergence Entropy Data Analysis package (CEDA) is an end-to-end shell designed to facilitate GPU assisted, fast analyses. Implementationally, it is quite simple.

  ```python
  from convergence_entropy.CEDA import ceda_model

  GRAPH = ceda_model(
      sigma=1.,
      device='cuda',
      wv_model='roberta-base',
      wv_layers=[7]
  )
  ```

  Where `wv_model` is parameter for the string name of any model available from the HuggingFace library of language models, and `wv_layers` selects which hidden layers to attenuate to from the language model when producing a representation of lexical units.

  On run-time, one can pass to the model a list of strings for both utterances $x$ and $y$ (see Rosen & Dale 2023 for terminology).

  ```python
  x_sentences = ['a list of', 'sentences']
  y_sentences = ['another list', 'of more sentences']

  GRAPH.fit(x_sentences, y_sentences)
  GRAPH.add_meta_data(
      meta_data = [
          {'a': 1, 'b': 2}, # a records oriented json object for metadata for each comparison in the graph.
                            
      ]
  )
  ```

  If there are repeated sentences in `x_sentence` or `y_sentences` it is worthwhile to sort the lists so as to cluster repetitions. This is because the model is designed to optimize for repeated examples by only generating vector representations for an utterance once in either the $x$ or $y$ variable so long as that element is repeated. Thus if you have a list of comparisons

  ```python
  x_sentences = ['Sentence A', 'Sentence A', 'Sentence B']
  y_sentences = ['sentence c', 'sentence d', 'sentence e']
  ```

  `ceda_model` will generate vectors for 'Sentence A' once, until it reaches 'Sentence B' in `x_sentences`.

  This creates a graph that can be used for any number of convergence-entropy based analyses, complete with metadata.

  Finally, one can save a checkpoint for the graph using the checkpoint function

  ```python
  CKPT_PATH = 'path/to/checkpoint.pt'
  GRAPH.checkpoint(CKPT_PATH)
  ```

  Saving a graph using the `.checkpoint()` has the added benefit, too, of allowing you to load a CEDA graph object from that checkpoint later.

  ```python
  CKPT_PATH = 'path/to/checkpoint.pt'
  GRAPH.load_from_checkpoint(CKPT_PATH)
  ```

  You can also create a dataframe for the graph to be saved as a .csv or other format.

  ```python
  CKPT_PATH = 'path/to/checkpoint.csv'
  df = GRAPH.graph_df()
  df.to_csv(CKPT_PATH, index=False, encoding='utf-8')
  ```

  A number of built-in visualization tools are included as well in the `EDA` package. We will expand on that documentation at a later date.



  Any use of this package should cite it using the following:

  ```
  @article{rosen_dale_berts_2023,
  	title = {{BERTs} of a feather: {Studying} inter- and intra-group communication via information theory and language models},
  	shorttitle = {{BERTs} of a feather},
  	url = {https://link.springer.com/10.3758/s13428-023-02267-2},
  	doi = {10.3758/s13428-023-02267-2},
  	journal = {Behavior Research Methods},
  	author = {Rosen, Zachary P and Dale, Rick},
  	year = {2023},
  }
  ```

  If you're interested in the most up-to-date version of this package or are interested in contributing to it, you can find
  [the github repository for it here](https://github.com/zaqari/EVM).


pkgId: 468b64072771794c092dcf365dbc199c44f46aca5167cf77dd64b9ac8405f30b
name: python-conversations
arch: src
version: 0.36.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/conversations/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conversations-0.36.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/conversations.svg)](https://pypi.org/project/conversations)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/conversations.svg)](https://pypi.org/project/conversations)
  [![Tests](https://github.com/rob-luke/conversations/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/rob-luke/conversations/actions/workflows/test.yml)

  Introducing "Conversations" - a Python package designed to
  explore the true potential of conversational analysis.
  With its ability to transcribe, diarise, and generate visually appealing HTML reports,
  "Conversation" empowers you to delve deeper into the intricacies of human communication.
  Recognizing that conversations are brimming with meaning
  conveyed not just through language,
  but also through key acoustic features like loudness, intonation, and speech rate,
  this package brings forth an indispensable tool for understanding and
  interpreting the wealth of information embedded in everyday exchanges.
  `Conversations` enables you to analyse and comprehend
  the complex world of human interaction.



  Comprehensive documentation, including overview, API, and examples,
  can be found [here](https://rob-luke.github.io/conversations/).



  ```console
  pip install conversations
  ```



  ```python
  from pathlib import Path
  from conversations import Conversation


  audio_file = Path('/path/to/audio.mp4')
  speaker_mapping={"0": "Alice", "1": "Bob", "2": "Sam"}


  conversation = Conversation(recording=audio_file, speaker_mapping=speaker_mapping)


  conversation.transcribe()
  conversation.diarise()
  conversation.save()


  html_report = conversation.report()
  with open('conversation.html', 'w') as f:
      f.write(html_report.render())


  text_report = conversation.export_text()
  with open('conversation.txt', 'w') as f:
      f.write(text_report)


  summary = conversation.summarise()
  with open('conversation-summary.txt', 'w') as f:
      f.write(summary)


  answer = conversation.query("What was the value of operating cash flow we were discussing?")


  print(f"The answer to your query is: {answer}")
  print(summary)




























































  ```


pkgId: 5f37584e8193d1bbf11100e9fb6c32d3030b71ee556a2cf54b6fb76798d23ca9
name: python-conversor-andre-conforti
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Pacote simples para conversao de unidades.
url: https://pypi.org/project/conversor-andre-conforti/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conversor-andre-conforti-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Descrição.
  O pacote conversor_unidades é utilizado para realizar conversões simples entre diferentes unidades de medida.
  Ele oferece funções para converter:
  	- Temperatura: Celsius para Fahrenheit e vice-versa.
  	- Comprimento: Metros para centímetros e vice-versa.



  Utilize o gerenciador de pacotes [pip](https://pip.pypa.io/en/stable/) para instalar o conversor_unidades:

  ```bash
  pip install conversor-andre-conforti
  ```



  ```python
  from conversor_unidades.temperatura import celsius_para_fahrenheit
  from conversor_unidades.comprimento import metros_para_centimetros


  temperatura_celsius = 25
  temperatura_fahrenheit = celsius_para_fahrenheit(temperatura_celsius)
  print(f"{temperatura_celsius}°C equivalem a {temperatura_fahrenheit:.2f}°F")


  comprimento_metros = 1.5
  comprimento_centimetros = metros_para_centimetros(comprimento_metros)
  print(f"{comprimento_metros}m equivalem a {comprimento_centimetros}cm")
  ```


  André Conforti


  0.0.2


  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 4ae024ff0099a4710a245d9481c25df976f9cd6108d5d63651fcc413dc639976
name: python-convert-all
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A CLI tool to convert files between formats
url: https://github.com/PavlikPolivka/convert-anything
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convert-all-1.0.1-1.src.rpm
checksum_type: sha256
description:
  ```bash
  git clone https://github.com/yourusername/convert-anything.git
  cd convert-anything
  ```

  Create a virtual environment and install dependencies:
  ```bash
  python -m venv venv
  source venv/bin/activate  # On Windows: .\venv\Scripts\activate
  pip install -r requirements.txt


pkgId: e04bd4f1072aac2ab94f901c8bf350a94d48e9f7058d745af4a581e8aff77b34
name: python-convert-case
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Convert between string cases with built-in case inference.
url: https://github.com/JoelLefkowitz/convert-case
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convert-case-1.2.3-1.src.rpm
checksum_type: sha256
description:
  Convert between string cases with built-in case inference.



  | Source     | Shields                                                                                                                                      |
  | ---------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
  | Project    | ![release][release_shield] ![license][license_shield] ![lines][lines_shield] ![languages][languages_shield]                                  |
  | Health     | ![readthedocs][readthedocs_shield] ![github_review][github_review_shield]![codacy][codacy_shield] ![codacy_coverage][codacy_coverage_shield] |
  | Publishers | ![pypi][pypi_shield] ![pypi_downloads][pypi_downloads_shield]                                                                                |
  | Repository | ![issues][issues_shield] ![issues_closed][issues_closed_shield] ![pulls][pulls_shield] ![pulls_closed][pulls_closed_shield]                  |
  | Activity   | ![contributors][contributors_shield] ![monthly_commits][monthly_commits_shield] ![last_commit][last_commit_shield]                           |



  Install the package from pypi:

  ```bash
  pip install convert-case
  ```

  To experiment with the source code locally, clone the repository:

  ```bash
  git clone https://github.com/joellefkowitz/convert-case
  ```

  To install linters, formatters and test runners:

  ```bash
  pip install .[all]
  npm install
  ```



  ```python
  from convert_case import camel_case

  camel_case('camel case') # Inferred: lower -> camel
  'camelCase'

  camel_case('Camel Case') # Inferred: title -> camel
  'camelCase'

  camel_case('CamelCase') # Inferred: pascal -> camel
  'camelCase'
  ```



  ```python
  def pascal_case(string: str) -> str:
      ...
  def is_pascal_case(string: str) -> bool:
      ...

  def camel_case(string: str) -> str:
      ...
  def is_camel_case(string: str) -> bool:
      ...

  def kebab_case(string: str) -> str:
      ...
  def is_kebab_case(string: str) -> bool:
      ...

  def sentence_case(string: str) -> str:
      ...
  def is_sentence_case(string: str) -> bool:
      ...

  def snake_case(string: str) -> str:
      ...
  def is_snake_case(string: str) -> bool:
      ...

  def title_case(string: str) -> str:
      ...
  def is_title_case(string: str) -> bool:
      ...

  def upper_case(string: str) -> str:
      ...
  def is_upper_case(string: str) -> bool:
      ...
  ```



  ```python
  LOWER = re.compile(r"^[a-z0-9\s]*$")
  UPPER = re.compile(r"^[A-Z0-9\s]*$")

  TITLE = re.compile(r"^(([A-Z0-9][a-z0-9]*)(\s[A-Z0-9][a-z0-9]*)*)?$")
  SENTENCE = re.compile(r"^(([A-Z0-9][a-z0-9]*)(\s[a-z0-9]*)*)?$")

  CAMEL = re.compile(r"^([a-z0-9][a-zA-Z0-9]*)?$")
  PASCAL = re.compile(r"^([A-Z0-9]|([A-Z0-9][a-z0-9]+)*)?$")

  SNAKE = re.compile(r"^([a-z0-9]+(_[a-z0-9]+)*)?$")
  KEBAB = re.compile(r"^([a-z0-9]+(-[a-z0-9]+)*)?$")
  ```



  To run unit tests:

  ```bash
  grunt test
  ```



  | test     | lower    | upper    | sentence | title    | camel  | snake    | kebab    | pascal |
  | -------- | -------- | -------- | -------- | -------- | ------ | -------- | -------- | ------ |
  | a        | a        | A        | A        | A        | a      | a        | a        | A      |
  | A        | a        | A        | A        | A        | a      | a        | a        | A      |
  | abc      | abc      | ABC      | Abc      | Abc      | abc    | abc      | abc      | Abc    |
  | ab cd    | ab cd    | AB CD    | Ab cd    | Ab Cd    | abCd   | ab_cd    | ab-cd    | AbCd   |
  | Ab cd    | ab cd    | AB CD    | Ab cd    | Ab Cd    | abCd   | ab_cd    | ab-cd    | AbCd   |
  | Ab Cd    | ab cd    | AB CD    | Ab cd    | Ab Cd    | abCd   | ab_cd    | ab-cd    | AbCd   |
  | ab_cd    | ab cd    | AB CD    | Ab cd    | Ab Cd    | abCd   | ab_cd    | ab-cd    | AbCd   |
  | ab-cd    | ab cd    | AB CD    | Ab cd    | Ab Cd    | abCd   | ab_cd    | ab-cd    | AbCd   |
  | abCd     | ab cd    | AB CD    | Ab cd    | Ab Cd    | abCd   | ab_cd    | ab-cd    | AbCd   |
  | ABCD     | abcd     | ABCD     | Abcd     | Abcd     | abcd   | abcd     | abcd     | Abcd   |
  | AbCd     | ab cd    | AB CD    | Ab cd    | Ab Cd    | abCd   | ab_cd    | ab-cd    | AbCd   |
  | ab cd ef | ab cd ef | AB CD EF | Ab cd ef | Ab Cd Ef | abCdEf | ab_cd_ef | ab-cd-ef | AbCdEf |
  | AbCdEf   | ab cd ef | AB CD EF | Ab cd ef | Ab Cd Ef | abCdEf | ab_cd_ef | ab-cd-ef | AbCdEf |
  | ab-cd-ef | ab cd ef | AB CD EF | Ab cd ef | Ab Cd Ef | abCdEf | ab_cd_ef | ab-cd-ef | AbCdEf |
  | Ab cd ef | ab cd ef | AB CD EF | Ab cd ef | Ab Cd Ef | abCdEf | ab_cd_ef | ab-cd-ef | AbCdEf |



  Numbers are treated as letters with no specific case.

  | test     | lower    | upper    | sentence | title    | camel  | snake    | kebab    | pascal |
  | -------- | -------- | -------- | -------- | -------- | ------ | -------- | -------- | ------ |
  | 1        | 1        | 1        | 1        | 1        | 1      | 1        | 1        | 1      |
  | 1bc      | 1bc      | 1BC      | 1bc      | 1bc      | 1bc    | 1bc      | 1bc      | 1bc    |
  | a1c      | a1c      | A1C      | A1c      | A1c      | a1c    | a1c      | a1c      | A1c    |
  | ab1      | ab1      | AB1      | Ab1      | Ab1      | ab1    | ab1      | ab1      | Ab1    |
  | a1 c     | a1 c     | A1 C     | A1 c     | A1 C     | a1C    | a1_c     | a1-c     | A1C    |
  | a1-c     | a1 c     | A1 C     | A1 c     | A1 C     | a1C    | a1_c     | a1-c     | A1C    |



  A goal of this converter is that it is deterministic. If we consider the following examples we can see that this is not simple to achieve. How should we interpret the string 'ABC', is it in upper case or pascal case?

  | test  | upper | pascal |
  | ----- | ----- | ------ |
  | abc   | ABC   | Abc    |
  | a b c | A B C | ABC    |

  Our options are:

  - To consider strings with consecutive capitals like 'ABC' not to be pascal case. If in this case 'a b c' is parsed to 'Abc' it would clash with parsing 'abc' into pascal case.

  - To store some state that remembers the string's case before parsing. This would introduce too much complexity.

  - To prioritize parsing the string as one case unless told otherwise. We choose to pick upper case as the inferred case. The caveat here is that we will no longer be performing 'round trip' conversion.

  Round trip conversion:

  ```python
  kebab_case('a b c')
  'a-b-c'

  lower_case('a-b-c')
  'a b c'
  ```

  Not round trip conversion:

  ```python
  pascal_case('a b c')
  'ABC'

  lower_case('ABC')
  'abc'
  ```



  This repository's documentation is hosted on [readthedocs][readthedocs].



  To run linters:

  ```bash
  grunt lint
  ```

  To run formatters:

  ```bash
  grunt format
  ```



  This repository uses github actions to lint and test each commit. Formatting tasks and writing/generating documentation must be done before committing new code.



  This repository adheres to semantic versioning standards.
  For more information on semantic versioning visit [SemVer][semver].

  Bump2version is used to version and tag changes.
  For example:

  ```bash
  bump2version patch
  ```



  Please read this repository's [changelog](CHANGELOG.md) for details on changes that have been made.



  Please read this repository's guidelines on [contributing](CONTRIBUTING.md) for details on the process for submitting pull requests. Moreover, our [code of conduct](CODE_OF_CONDUCT.md) declares our collaboration standards.



  - **joellefkowitz** - _Initial work_ - [joellefkowitz][author]

  [![Buy Me A Coffee][coffee_button]][author_coffee]



  Lots of love to the open source community!

  ![Be kind][be_kind]

  <!-- Project links -->

  [readthedocs]: https://convert-case.readthedocs.io/en/latest/

  <!-- External links -->

  [semver]: http://semver.org/
  [be_kind]: https://media.giphy.com/media/osAcIGTSyeovPq6Xph/giphy.gif

  <!-- Contributor links -->

  [author]: https://github.com/joellefkowitz
  [author_coffee]: https://www.buymeacoffee.com/joellefkowitz
  [coffee_button]: https://cdn.buymeacoffee.com/buttons/default-blue.png

  <!-- Project shields -->

  [release_shield]: https://img.shields.io/github/v/tag/joellefkowitz/convert-case
  [license_shield]: https://img.shields.io/github/license/joellefkowitz/convert-case
  [lines_shield]: https://img.shields.io/tokei/lines/github/joellefkowitz/convert-case
  [languages_shield]: https://img.shields.io/github/languages/count/joellefkowitz/convert-case

  <!-- Health shields -->

  [readthedocs_shield]: https://img.shields.io/readthedocs/convert-case
  [github_review_shield]: https://img.shields.io/github/workflow/status/JoelLefkowitz/convert-case/Review
  [codacy_shield]: https://img.shields.io/codacy/grade/3b8afbb8327d424b9990741fd587d7c4
  [codacy_coverage_shield]: https://img.shields.io/codacy/coverage/3b8afbb8327d424b9990741fd587d7c4

  <!-- Publishers shields -->

  [pypi_shield]: https://img.shields.io/pypi/v/convert-case
  [pypi_downloads_shield]: https://img.shields.io/pypi/dm/convert-case

  <!-- Repository shields -->

  [issues_shield]: https://img.shields.io/github/issues/joellefkowitz/convert-case
  [issues_closed_shield]: https://img.shields.io/github/issues-closed/joellefkowitz/convert-case
  [pulls_shield]: https://img.shields.io/github/issues-pr/joellefkowitz/convert-case
  [pulls_closed_shield]: https://img.shields.io/github/issues-pr-closed/joellefkowitz/convert-case

  <!-- Activity shields -->

  [contributors_shield]: https://img.shields.io/github/contributors/joellefkowitz/convert-case
  [monthly_commits_shield]: https://img.shields.io/github/commit-activity/m/joellefkowitz/convert-case
  [last_commit_shield]: https://img.shields.io/github/last-commit/joellefkowitz/convert-case


pkgId: d24e360c5253a2e9820266ff684f1aa6ea8b10821dcfe1d10e79f044e956757b
name: python-convert-numbers
arch: src
version: 0.4
epoch: 0
release: 1
url: https://github.com/azwri/convert_numbers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convert-numbers-0.4-1.src.rpm
checksum_type: sha256
summary:
  Arabic Persian English Hindi Numbers is a Python library to convert numbers from-to Arabic, Hinid, Persian and English.

description:
  ![Twitter Follow](https://img.shields.io/twitter/follow/Al_Azwari?label=Follow&style=social) [![Downloads](https://pepy.tech/badge/convert-numbers)](https://pepy.tech/project/convert-numbers) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/Django?style=plastic) [![PyPI version](https://badge.fury.io/py/convert-numbers.svg)](https://badge.fury.io/py/convert-numbers)





  ```bash
  pip install convert_numbers
  ```



  ```python
  import convert_numbers


  print(convert_numbers.hindi_to_english('٨٧٦٥٤٣٢٣٤٥٦٧٨')) #8765432345678



  print(convert_numbers.english_to_hindi('12309876523')) ##١٢٣٠٩٨٧٦٥٢٣



  print(convert_numbers.hindi_to_arabic('٨٧٦٥٤٣٢٣٤٥٦٧٨')) #8765432345678



  print(convert_numbers.arabic_to_hindi('12309876523')) #١٢٣٠٩٨٧٦٥٢٣



  print(convert_numbers.arabic_to_english('٢٣٤٥٦٧٨٠٩٨٧٦')) #234567809876



  print(convert_numbers.english_to_arabic('09876523456')) #٠٩٨٧٦٥٢٣٤٥٦



  print(convert_numbers.persian_to_english('۵۱۲۳۹۶۰۴۴')) #512396044



  print(convert_numbers.english_to_persian('512396044')) #۵۱۲۳۹۶۰۴۴



  print(convert_numbers.persian_to_hindi('۵۱۲۳۹۶۰۴۴')) #٥١٢٣٩٦٠٤٤



  print(convert_numbers.hindi_to_persian('٢٣٤٥٦٧٨٠٩٨٧٦')) #۲۳۴۵۶۷۸۰۹۸۷۶
  ```


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

  Please make sure to update tests as appropriate.


  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 16e30c9ab50d9dd50dc37a5bc66d39f7ce1d0967b729b506f6eb6970dc5365d6
name: python-convert_videos
arch: src
version: 2.8.11
epoch: 0
release: 1
summary: This tool allows bulk conversion of videos using ffmpeg
url: https://pypi.org/project/convert_videos/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convert_videos-2.8.11-1.src.rpm
checksum_type: sha256
description:
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/convert_videos)](https://pypi.org/project/convert_videos/) [![PyPI version](https://badge.fury.io/py/convert_videos.svg)](https://badge.fury.io/py/convert_videos)

  [![Workflow](https://github.com/justin8/convert_videos/actions/workflows/workflow.yml/badge.svg)](https://github.com/convert_videos/video_utils/actions/workflows/workflow.yml)
  [![codecov](https://codecov.io/gh/justin8/convert_videos/branch/master/graph/badge.svg)](https://codecov.io/gh/justin8/convert_videos)
  [![Downloads](https://pepy.tech/badge/convert_videos/month)](https://pepy.tech/project/convert_videos)

  This tool allows bulk conversion of videos using ffmpeg.

  By default it will append the codec name to the file, e.g. `Best Movie Ever.avi` -> `Best Movie Ever - x265.mkv`. This can be optionally overridden using the `--in-place` flag.

  Videos are only converted if they do not already match the desired codec, allowing you to process a folder of mixed format files and only convert the ones you desire. This can optionally be overridden.



  ```
  Usage: convert-videos [OPTIONS] DIRECTORIES...

  Options:
    -i, --in-place                  Replace the original files instead of
                                    appending the new codec name
    -f, --force                     Force conversion even if the format of the
                                    file already matches the desired format
    --video-codec TEXT              A target video codec. Supported codecs:
                                    HEVC, AVC  [default: HEVC]
    -q, --quality INTEGER           The quantizer quality level to use.
                                    [default: 24]
    -p, --preset TEXT               FFmpeg preset to use.  [default: medium]
    -w, --width INTEGER             Specify a new width to enable resizing of
                                    the video
    --extra-input-args TEXT         Specify any extra arguments you would like
                                    to pass to FFMpeg input here
    --extra-output-args TEXT        Specify any extra arguments you would like
                                    to pass to FFMpeg output here
    --audio-codec TEXT              A target audio codec  [default: AAC]
    --audio-channels INTEGER        The number of channels to mux sound in to
                                    [default: 2]
    --audio-bitrate INTEGER         The bitrate to use for the audio codec
                                    [default: 160]
    --temp-dir TEXT                 Specify a temporary directory to use during
                                    conversions instead of the system default
    -v, --verbose                   Enable verbose log output
    --container TEXT                Specify a video container to convert the
                                    videos in to  [default: mkv]
    --dry-run                       Do not make actual changes
    --encoder [software|nvidia|intel]
                                    Optionally use a harwdare encoder to speed
                                    things up.  [default: software]
    --audio-language TEXT           Only include audio streams in this language
    --subtitle-language TEXT        Only include subtitle streams in this
                                    language
    -h, --help                      Show this message and exit.
  ```



  To enable auto-completion:

  **zsh**
  Add the below to `~/.zshrc`
  `eval "$(_CONVERT_VIDEOS_COMPLETE=zsh_source convert-videos)"`

  **bash**
  Add the below to `~/.bashrc`
  `eval "$(_CONVERT_VIDEOS_COMPLETE=bash_source convert-videos)"`

  **fish**
  Add the following to `~/.config/fish/completions/convert-videos.fish`
  `eval (env _CONVERT_VIDEOS_COMPLETE=fish_source convert-videos)`





  The default output container is `mkv` format. This can be changed with the `--container` flag to anything that is supported by FFMPEG and the chosen video and audio codecs



  Default settings is HEVC/x265 at quality of 23



  Currently only HEVC (x265) and AVC (h264) are supported for video codecs.



  Videos can be resized automatically by providing a width. Height is automatically calculated to ensure that the aspect ratio is maintained.



  Hardware acceleration is supported on nVidia and Intel devices.

  Caveats for nVidia:

  - Conversions use constqp mode for the quality setting instead of CRF, as nvenc does not support CRF
  - b-frames are not currently supported; nvenc itself supports them on 20xx+ series graphics cards.

  Caveats for Intel:

  - Conversions use global_quality mode as CRF isn't supported on Intel hardware. ICQ and LA-ICQ are apparently better, but only supported on Windows
  - Look-ahead is only supported on x264 (not HEVC)
  - There is a bug (current as of 2023-05) where all videos converted with Intel's QSV with FFMPEG have a single I-frame at the start and no more; so currently this is unsuable



  Default settings is 160kbps 2 channel AAC.

  All audio streams will be included by default unless a language filter is specified with `--audio-language`.



  All subtitles will be copied from the source if they exist unless a language filter is specified with `--subtitle-language`.


pkgId: 92e0bccd2d23e04ee58d1c50957e5745ee2cad79b9654d836e0eb4b61faf5210
name: python-convertapi
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Convert API Python Client
url: https://github.com/ConvertAPI/convertapi-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convertapi-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Convert various files like MS Word, Excel, PowerPoint, Images to PDF and Images. Create PDF and Images from url and raw HTML. Extract and create PowerPoint presentation from PDF. Merge, Encrypt, Split, Repair and Decrypt PDF files. All supported files conversions and manipulations can be found at https://www.convertapi.com/doc/supported-formats


pkgId: 34f796abe89f1d1c3e43c911c1370a8fc360333989a694a9738f4e5099678cd4
name: python-convertdate
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Converts between Gregorian dates and other calendar systems
url: https://github.com/fitnr/convertdate
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convertdate-2.4.0-1.src.rpm
checksum_type: sha256
description:
  The convertdate package was originally developed as "[Python Date
  Utils](http://sourceforge.net/projects/pythondateutil/)" by Phil
  Schwartz. It has been significantly updated and expanded.
  [Consult the complete docs for detailed usage info](https://convertdate.readthedocs.io/).
  Available calendars:
  -   Armenian
  -   Bahai
  -   Coptic (Alexandrian)
  -   French Republican
  -   Gregorian
  -   Hebrew
  -   Indian Civil
  -   Islamic
  -   Julian
  -   Mayan
  -   Persian
  -   Positivist
  -   Mayan
  -   ISO
  -   Ordinal (day of year)
  -   Dublin day count
  -   Julian day count
  The `holidays` module also provides some useful holiday-calculation,
  with a focus on North American and Jewish holidays.


pkgId: fe3857202427dcb7c348d60d18ac30c646500a1fa46f9697bd6947d6c67c48cc
name: python-converter21
arch: src
version: 3.2.0
epoch: 0
release: 1
url: https://github.com/gregchapman-dev/converter21
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-converter21-3.2.0-1.src.rpm
checksum_type: sha256
summary:
  A music21-extending format converter package and command line tool (replaces music21's Humdrum and MEI parser, and adds a Humdrum writer and MEI writer)

description:
  A music21-extending converter package that contains alternate music21 Humdrum and MEI converters (a Humdrum parser/writer, and a MEI parser/writer).  converter21 is also a command line tool for conversion between various music notation file formats.

  The Humdrum portion of this software is derived/translated from the C++ code in [humlib](https://github.com/craigsapp/humlib), by Craig Stuart Sapp.

  The core of the MEI parsing portion of this software was based on the MEI converter in [music21](https://github.com/cuthbertlab/music21), by Michael Scott Asato Cuthbert.


  Requires Python 3.10 or later.  Depends on [music21](https://pypi.org/project/music21) v9.1, which should also be configured (instructions [here](https://web.mit.edu/music21/doc/usersGuide/usersGuide_01_installing.html)) to display a musical score (e.g. with Musescore). Some of the tests depend on [musicdiff](https://pypi.org/project/musicdiff), but converter21 itself does not.


  ```
  python3 -m converter21 [-h]
                         [-f from_format]
                         -t to_format
                         [-c]
                         input_file output_file

  Positional arguments:
    input_file            input music file to convert from (extension is used to determine input
                          format if --input-from/-f is not specified)
    output_file           output music file to convert to (extension is NOT used to determine or
                          validate output format, so if you're not careful you'll end up with
                          contents not matching the extension)

  Named arguments:
    -h, --help            show help message and exit
    -f, --input-from {humdrum,musicxml,mei,abc...}
                          format of the input file (only necessary if input file has unsupported or
                          incorrect extension)
    -t, --output-to {humdrum,musicxml,lilypond,braille...}
                          format of the output file (required)
    -c, --cached-parse-ok
                          use music21's cached parse of the input file if it exists
  ```


  Call converter21.register() to get music21 to use converter21's alternate Humdrum and MEI converters in your own code.


  The MIT License (MIT)
  Copyright (c) 2021-2024 Greg Chapman

  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.

  The Humdrum parsing/writing portion of this software is derived/translated from the
  C++ code in [humlib](https://github.com/craigsapp/humlib), which uses the BSD 2-Clause
  License:

  Copyright (c) 2015-2021 Craig Stuart Sapp
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

  1. Redistributions of source code must retain the above copyright notice, this
     list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright notice,
     and the following disclaimer in the documentation and/or other materials
     provided with the distribution.

  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 OWNER 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.

  The core of the MEI parsing portion of this software was based on the MEI parser
  in [music21](https://github.com/cuthbertLab/music21), which uses the BSD 3-Clause License:

  Copyright (c) 2006-2023 Michael Scott Asato Cuthbert
  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 names music21, Michael Scott Asato Cuthbert, 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 Cuthbert 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: aeabedf07c8fdcf87abac86d730677314ebb5a622ab9f419022367fa5d51c443
name: python-convertkit-py
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Python client for the ConvertKit API
url: https://github.com/andreskull/convertkit-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convertkit-py-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A Python client for the ConvertKit API.



  ```bash
  pip install convertkit-py
  ```



  Copy the sample environment file:

  ```bash
  cp .env-sample .env
  ```

  Edit `.env` with your ConvertKit credentials:

  ```text
  CONVERTKIT_API_KEY=your_api_key_here
  CONVERTKIT_API_SECRET=your_secret_key_here
  CONVERTKIT_FORM_NAME=your_form_name_here
  ```



  ```python
  from convertkit import ConvertKit
  from dotenv import load_dotenv
  import os


  load_dotenv()


  kit = ConvertKit(
      api_key=os.getenv('CONVERTKIT_API_KEY'),
      api_secret=os.getenv('CONVERTKIT_API_SECRET'),
      form_name=os.getenv('CONVERTKIT_FORM_NAME')
  )


  subscriber_data = {
      'email': 'example@example.com',
      'fields': {'first_name': 'John'},
      'tags': ['tag1', 'tag2']
  }
  kit.create_subscriber_with_fields_and_tags(subscriber_data)
  ```



  - Manage subscribers
  - Handle custom fields
  - Manage tags
  - Work with forms
  - Full API coverage





  1. Clone the repository
  2. Install development dependencies: `pip install -e ".[dev]"`
  3. Install test dependencies: `pip install pytest python-dotenv`



  1. Create a `.env` file in the project root:
  ```text
  KIT_API_KEY=your_api_key_here
  KIT_API_SECRET=your_secret_here
  ```

  2. Run tests:
  ```bash
  pytest tests -v
  ```



  MIT License


pkgId: f7b3bfd5c986bcda091090ba7664811d1c57f411ae5ed2c242487ef9077d58b6
name: python-convey
arch: src
version: 1.4.4
epoch: 0
release: 1
summary: CSV processing and mutual conversion of web related data types
url: https://github.com/CZ-NIC/convey
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convey-1.4.4-1.src.rpm
checksum_type: sha256
description:
  prefix            1.1.1.0-1.1.1.255
  asn               as13335
  abusemail         abuse@apnic.net
  country           au
  netname           apnic-labs
  csirt-contact     -
  incident-contact  au
  status            200
  text              DNSThe free app that makes your (much longer text...)
  ```

  Parses CSV file.
  ```bash
  $ convey my-file-with-ips.csv # will trigger file parsing
  Source file: /tmp/my-file.csv
  Log lines: 200
  Sample:
  Delimiter character found: ','
  Quoting character: '"'
  Header is present: not used
  Could you confirm this? [y]/n
  ```

  Again, let's provide an IP to the [web service](#web-service), it returns JSON with WHOIS-related information and scraped HTTP content.
  ```bash
  $ convey --server  # start a UWSGI session
  ```
  Access in the browser: http://localhost:26683/?q=example.com
  ```json
  {"ip": "93.184.216.34", "prefix": "93.184.216.0-93.184.216.255", "asn": "", "abusemail": "abuse@verizondigitalmedia.com", "country": "unknown", "netname": "edgecast-netblk-03", "csirt-contact": "-", "incident-contact": "unknown", "status": 200, "text": "DNSThe free app that makes your (much longer text...)"}
  ```


  * You'll be asked to install `dialog` library at the first run if not already present in the system.
  * If something is missing on your system, you may find help yourself with this command:
  `sudo apt install python3-pip python3-dev python3-tk git xdg-utils dialog whois dnsutils nmap curl build-essential libssl-dev libpcre3 libpcre3-dev && pip3 install setuptools wheel uwsgi && pip3 install --upgrade ipython`
      * `build-essential` is needed to build `uwsgi` and `envelope`
      * `libpcre3 libpcre3-dev` needed to suppress uWSGI warning `!!! no internal routing support, rebuild with pcre support !!!`
      * `libssl-dev` needed to be present before building `uwsgi` if you will need to use `--https`

  ```bash

  python3 -m venv venv
  . venv/bin/activate
  (venv) $ ... # continue below

  pip3 install convey  # without root use may want to use --user

  pip3 install git+https://github.com/CZ-NIC/convey.git

  convey [filename or input text] # or try `python3 -m convey` if you're not having `.local/bin` in your executable path
  ```
  Parameter `[filename or input text]` may be the path of the CSV source file or any text that should be parsed. Note that if the text consist of a single value, program prints out all the computable information and exits; I.E. inputting a base64 string will decode it.

  ```bash

  git clone git@github.com:CZ-NIC/convey.git
  cd convey
  pip3 install -r requirements.txt  --user

  ./convey.py
  ```

  1. Run: `apt-get install bash-completion jq`
  2. Copy: [extra/convey-autocompletion.bash](./extra/convey-autocompletion.bash) to `/etc/bash_completion.d/`
  3. Restart terminal

  * Launch convey with [`--help`](docs/convey-help-cmd-output.md) flag to see [further options](docs/convey-help-cmd-output.md).
  * A file [`config.ini`](convey/defaults/config.ini) is automatically created in [user config folder](convey/defaults/config.ini). This file may be edited for further customisation. Access it with `convey --config`.
  > * Convey tries to open the file in the default GUI editor or in the terminal editor if GUI is not an option.
  > * If `config.ini` is present at working directory, that one is used over the one in the user config folder.
  > * Configuration is updated automatically on upgrade.


  Some field types are directly computable:
  * **abusemail** – got abuse e-mail contact from whois
  * **asn** – got from whois
  * **base64** – encode/decode
  * **cc_contact** – e-mail address corresponding with the abusemail, taken from your personal contacts_cc CSV in the format `domain,cc;cc` (mails delimited by a semicolon). Path to this file has to be specified in `config.ini » contacts_cc`.
  * **country** – country code from whois
  * **~~csirt_contact~~** – e-mail address corresponding with country code, taken from your personal contacts_abroad CSV in the format `country,abusemail`. Path to this file has to be specified in `config.ini » contacts_abroad`
  * **external** – you specify method in a custom .py file that receives the field and generates the value for you, see below
  * **hostname** – domain from url
  * **incident_contact** – if the IP comes from local country (specified in `config.ini » local_country`) the field gets *abusemail*, otherwise we get *country@@mail* where *mail* is either *abusemail* or abroad country e-mail. When splitting by this field, convey is subsequently able to send the split files to local abuse and foreign csirt contacts.
  * **ip** – translated from url
  * **netname** – got from whois
  * **prefix** – got from whois

  When obtaining a WHOIS record
  * We are internally calling `whois` program, detecting what servers were asked.
  * Sometimes you encounter a funny formatted *whois* response. We try to mitigate such cases and **re-ask another registry** in well known cases.
  * Since IP addresses in the same prefix share the same information we cache it to gain **maximal speed** while reducing *whois* queries.
  * Sometimes you encounter an IP that gives no information but asserts its prefix includes a large portion of the address space. All IP addresses in that portion ends labeled as unknowns. At the end of the processing you are **asked to redo unknowns** one by one to complete missing information, flushing misleading superset from the cache.
  * You may easily hit **LACNIC query rate** quota. In that case, we re-queue such lines to be queried after the quota is over if possible. At the end of the processing, you will get asked whether you wish to carefully and slowly reprocess the lines awaiting the quota lift.

  Some of the field types are possible to be auto-detected:
  * **ip** – standard IPv4 / IPv6 addresses
  * **cidr** – CIDR notation, ex: 127.0.0.1/32
  * **port_ip** – IPv4 in the form 1.2.3.4.port
  * **any_ip** – IPv4 garbled in the form `any text 1.2.3.4 any text`
  * **hostname** – or FQDN; 2nd or 3rd domain name
  * **url** – URL starting with http/https
  * **asn** – AS Number
  * **base64** – text encoded with base64
  * **wrong_url** – URL that has been deactivated by replacing certain chars, ex: "hxxp://example[.]com"

  Current field computing capacity can be get from `--show-uml` flag. Generate yours by ex: `convey --show-uml | dot -Tsvg -o /tmp/convey-methods.svg`
  * Dashed node: field type is auto-detectable
  * Dashed edge: field types are identical
  * Edge label: generating options asked at runtime
  * Rectangle: field category border
  ![Methods overview](./docs/convey-methods.svg?sanitize=True)


  If you wish to compute an **external** field, prepare a file whose contents can be as simple as this:
  ```python3
  def any_method(value):
      
      return "modified :)"
  ```

  * When CSV processing, hit *'Add column'* and choose *'new external... from a method in your. py file'*
  * Or in the terminal append `--field external` to your `convey` command. A dialog for a path of the Python file and desired method will appear.
  ```bash
  $ convey [string_or_filepath] --field external
  ```
  * You may as well directly specify the path and the callable. Since the `--field` has following syntax:
  > *FIELD[[CUSTOM]],[COLUMN],[SOURCE_TYPE],[CUSTOM],[CUSTOM]*
  You may omit both *COLUMN* and *SOURCE_TYPE* writing it this way:
  > *FIELD,~~COLUMN,SOURCE_TYPE~~,CUSTOM,CUSTOM*
  > external,/tmp/myfile.py,any_method
  ```bash
  $ convey [string_or_filepath] --field external,/tmp/myfile.py,any_method
  Input value seems to be plaintext.


pkgId: 854b88e079b6d3ccdeebe1a571c34aa8cc721c20dbd52d4d17f0ec3a95106609
name: python-conviso-cli
arch: src
version: 2.2.11
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/conviso-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conviso-cli-2.2.11-1.src.rpm
checksum_type: sha256
description:
  This is a command line tool to interact with [convisoappsec] API.


  Please visit the [official documentation] for further information.

  [official documentation]: <https://docs.convisoappsec.com/cli/installation>


pkgId: efeb924852bea3edb9f3a5099092ad1d3b074dabd036c90bfed3c2bd46498870
name: python-convlstm-mlx
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: An MLX implementation of ConvLSTM
url: https://github.com/tomo-oga/convlstm-mlx
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convlstm-mlx-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A Convolutional LSTM recurrent layer.



  This `Module` computes the hidden and cell state for a time-step, expressed as:

  $` i_t = \sigma (W_{xi} \ast X_t + W_{hi} \ast H_{t-1} + W_{ci} \odot C_{t-1} + b_i) `$ \
  $` f_t = \sigma (W_{xf} \odot X_t \ast H_{t-1} + W_{cf} \odot C_{t-1} + b_f) `$\
  $` C_t = f_t \odot X_t + i_t \odot tanh(W_{xc} \ast X_{t} + W_{hc} \ast H_{t-1} + b_c) `$ \
  $` o_t = \sigma(W_{xo} \ast X_t +  W_{ho} \ast H_{t-1} + W_{co} \odot C_t + b_o `$ \
  $` H_t = o_t \odot tanh(C_t) `$ \

  Where $`\sigma`$ and $`\odot`$ represent the hyperbolic sigmoid function and Hadamard product respectively.

  The expected input for this layer has shape `NHWC` or  `HWC` where:

  * `N` is the optional batch dimension
  * `H` is the input's spatial height dimension
  * `W` is the input's spatial width dimension
  * `C` is the input's channel dimension

  And returns a `Tuple` of the hidden state, $`H_t`$, and the cell state, $`C_t`$, each with shape `NHWO`.

  **Args:**

  `in_channels (int)`: The number of input channels, `C`.\
  `out_channels (int)`: The number of output channels, `O`.\
  `kernel_size (int)`: The size of the convolution filters, must be odd to keep spatial dimensions with padding. Default: `5`. \
  `stride (Union[int, tuple]` : The stride of the convolution.
  `padding (Union[int, tuple]` : Padding to add to the input for convolution.
  `dilation (Union[int, tuple]` : Dilation of the convolution.
  `bias` (bool): Whether the convolutional calculation should use biases or not. Default: `True.`



  Unrolls a `_conv_lstm_cell` sequentially over time-steps.

  The expected input for this layer has shape `NLHWC` or  `LHWC` where:

  * `N` is the optional batch dimension
  * `L` is the length of the sequence
  * `H` is the input's spatial height dimension
  * `W` is the input's spatial width dimension
  * `C` is the input's channel dimension

  **Args:**
  `in_channels (int)`: The number of input channels, `C`.\
  `out_channels (int)`: The number of output channels, `O`.\
  `kernel_size (int)`: The size of the convolution filters, must be odd to keep spatial dimensions with padding. Default: `5`. \
  `bias` (bool): Whether the convolutional calculation should use biases or not. Default: `True.`

  The following features are yet to be implemented from initial release:\
  [] Bi-directionality - allows the conv-lstm to unroll both forwards and backwards across the sequence
  [] Allow for stride customization
  [] Allow for customizable padding along with modes 'same' and 'valid'


pkgId: 7ec6ba32f65c124db179b9cb5871f4f28a50b529d5e0e5e378fc8119756e0f21
name: python-convocations
arch: src
version: 2.7
epoch: 0
release: 1
summary: convocations
url: https://github.com/crazy-penguins/convocations
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convocations-2.7-1.src.rpm
checksum_type: sha256
description:
  a set of [`invoke`](https://pypi.org/project/invoke)-inspired, [`raft`](https://pypi.org/project/raft)-based convocations that we hope
  can help make development and devops a little easier.  powered by angry penguins.




  useful utilities when working on projects intended to be published in a
  python repository like pypi



  creates a template project that you can use to create packages / modules
  that will be deployed to pypi or another python repository.



  useful utilities to make life easier for those getting started with using
  a repository.



  creates a standard virtual environment for running the project



  builds the project using setup.py or pyproject.toml



  cleans any builds



  runs test via pytest and prints out a coverage report



  bumps the current version of the project via bumpversion



  uploads any distribution via twine



  a handy combination of clean, test, build, version, upload





  | name                       | description                                                                                                                                                                    |
  |----------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | convocations.prefix        | a handy prefix used in output and the directory in which cfn templates / parameters can be found                                                                               |
  | aws                        | object                                                                                                                                                                         |
  | aws.profile                | the profile to use when creating boto3 sessions                                                                                                                                |
  | aws.start_url              | the sso start url                                                                                                                                                              |
  | aws.account_id             | the target account id for sso                                                                                                                                                  |
  | aws.sso_account_id         | an alias for account_id                                                                                                                                                        |
  | aws.sso_region             | the region in which sso is configured                                                                                                                                          |
  | aws.sso_start_url          | an alias for start_url                                                                                                                                                         |
  | aws.role                   | the role which we will assume after sso is completed, if unspecified, we will take the first role alphabetically                                                               |
  | aws.sso_role_name          | an alias for role                                                                                                                                                              |
  | aws.global_parameter_files | files that contain parameters that should be loaded by default when using cloudformation.  by convention the file at convocation.prefix/params/global.yml will also be loaded. |
















  azure development will require certain os level packages to be
  installed:

  ```bash
  apt install -y gnome-keyring libgirepository1.0-dev libcairo2-dev
  ```


pkgId: 7811f2ff5fbe471a4554660ff9e34749e6d91d0a03334e7f1da50b8bc25f6725
name: python-convoke
arch: src
version: 2.2.9
epoch: 0
release: 1
summary: A Python app configuration toolkit that tries to do things right.
url: https://github.com/eykd/convoke/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convoke-2.2.9-1.src.rpm
checksum_type: sha256
description:
  - Source Code: https://github.com/eykd/convoke
  - Issue Tracker: https://github.com/eykd/convoke/issues


pkgId: f9e85ec24bb7f86bdedd1ea6d78abe246ea5f4b37145f802cda36412d3b20222
name: python-convoys
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Fit machine learning models to predict conversion using Weibull and Gamma distributions
url: https://better.engineering/convoys
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convoys-0.2.1-1.src.rpm
checksum_type: sha256
description:
  For more information, see
  `the package documentation <https://better.engineering/convoys>`_
  or
  `the Github project page <https://github.com/better/convoys>`_.

  .. image:: https://better.engineering/convoys/_images/dob-violations-combined.png


pkgId: d0f6e6297ad211656dc8ac3459cc870de0a1c4bd7a5e2f37739c97de24b75e07
name: python-convtools
arch: src
version: 1.14.3
epoch: 0
release: 1
summary: dynamic, declarative data transformations with automatic code generation
url: https://pypi.org/project/convtools/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-convtools-1.14.3-1.src.rpm
checksum_type: sha256
description:
  **convtools** is a Python library that simplifies data transformation by
  allowing you to define them in a declarative way. It then generates the
  necessary Python code in the background, saving you time and effort.

  [![License](https://img.shields.io/github/license/westandskif/convtools.svg)](https://github.com/westandskif/convtools/blob/master/LICENSE.txt)
  [![codecov](https://codecov.io/gh/westandskif/convtools/branch/master/graph/badge.svg)]( https://codecov.io/gh/westandskif/convtools)
  [![Tests status](https://github.com/westandskif/convtools/workflows/tests/badge.svg)](https://github.com/westandskif/convtools/actions/workflows/pytest.yml)
  [![Docs status](https://readthedocs.org/projects/convtools/badge/?version=latest)](https://convtools.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://badge.fury.io/py/convtools.svg)](https://pypi.org/project/convtools/)
  [![Twitter](https://img.shields.io/twitter/url?label=convtools&style=social&url=https%3A%2F%2Ftwitter.com%2Fconvtools)](https://twitter.com/convtools)
  [![Downloads](https://static.pepy.tech/badge/convtools)](https://pepy.tech/project/convtools)
  [![Python versions](https://img.shields.io/pypi/pyversions/convtools.svg)](https://pypi.org/project/convtools/)

  ____



  `pip install convtools`



  **[convtools.readthedocs.io](https://convtools.readthedocs.io/en/latest/)**




  ```python
  from convtools import conversion as c

  input_data = [
      {"a": 5, "b": "foo"},
      {"a": 10, "b": "foo"},
      {"a": 10, "b": "bar"},
      {"a": 10, "b": "bar"},
      {"a": 20, "b": "bar"},
  ]

  conv = (
      c.group_by(c.item("b"))
      .aggregate(
          {
              "b": c.item("b"),
              "a_first": c.ReduceFuncs.First(c.item("a")),
              "a_max": c.ReduceFuncs.Max(c.item("a")),
          }
      )
      .pipe(
          c.aggregate({
              "b_values": c.ReduceFuncs.Array(c.item("b")),
              "mode_a_first": c.ReduceFuncs.Mode(c.item("a_first")),
              "median_a_max": c.ReduceFuncs.Median(c.item("a_max")),
          })
      )
      .gen_converter()
  )

  assert conv(input_data) == {
      'b_values': ['foo', 'bar'],
      'mode_a_first': 10,
      'median_a_max': 15.0
  }

  ```


      * Sum
      * SumOrNone
      * Max
      * MaxRow
      * Min
      * MinRow
      * Count
      * CountDistinct
      * First
      * Last
      * Average
      * Median
      * Percentile
      * Mode
      * TopK
      * Array
      * ArrayDistinct
      * ArraySorted

      DICT REDUCERS ARE IN FACT AGGREGATIONS THEMSELVES, BECAUSE VALUES GET REDUCED.
      * Dict
      * DictArray
      * DictSum
      * DictSumOrNone
      * DictMax
      * DictMin
      * DictCount
      * DictCountDistinct
      * DictFirst
      * DictLast

      AND LASTLY YOU CAN DEFINE YOUR OWN REDUCER BY PASSING ANY REDUCE FUNCTION
      OF TWO ARGUMENTS TO ``c.reduce``.




  * convtools doesn't need to wrap data in a container to provide functionality,
    it simply runs the python code it generates on **any input**
  * convtools is lightweight (_though optional `black` is highly recommended for
    pretty-printing generated code out of curiosity_)
  * convtools fosters building pipelines on top of iterators, allowing for stream
    processing
  * convtools supports nested aggregations
  * convtools is a set of primitives for code generation, so it's just different.



  The best way to support the development of convtools is to spread the word!

  Also, if you already are a convtools user, we would love to hear about your use
  cases and challenges in the [Discussions
  section](https://github.com/westandskif/convtools/discussions).

  To report a bug or suggest enhancements, please open [an
  issue](https://github.com/westandskif/convtools/issues) and/or submit [a pull
  request](https://github.com/westandskif/convtools/pulls).


  **Reporting a Security Vulnerability**: see the [security policy](https://github.com/westandskif/convtools/security/policy).

rpm_license:
  The MIT License (MIT)  Copyright (c) 2021 Nikita Almakov  Copyright (c) 2020 iTechArt Group  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: a768486b3dcf699046e4ce8453ceba9d177229e0190c9de94eb2bd1a063e6a42
name: python-cook-builder
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Build script aggregator and remote executor
description: Checkout `cook-docs <https://serweryn617.github.io/cook-docs/>`_ GitHub Pages!
url: https://github.com/serweryn617/cook
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cook-builder-0.2.3-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Seweryn Rusecki  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: a9fc2298abb90b4461377dfbde0f4e34afd328c83f38047c20e65632222f1938
name: python-cookiecutter
arch: src
version: 2.6.0
epoch: 0
release: 1
url: https://github.com/cookiecutter/cookiecutter
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cookiecutter-2.6.0-1.src.rpm
checksum_type: sha256
summary:
  A command-line utility that creates projects from project templates, e.g. creating a Python package project from a Python package project template.

description:
  <h1 align="center">
      <img alt="cookiecutter Logo" width="200px" src="https://raw.githubusercontent.com/cookiecutter/cookiecutter/3ac078356adf5a1a72042dfe72ebfa4a9cd5ef38/logo/cookiecutter_medium.png">
  </h1>

  <div align="center">

  [![pypi](https://img.shields.io/pypi/v/cookiecutter.svg)](https://pypi.org/project/cookiecutter/)
  [![python](https://img.shields.io/pypi/pyversions/cookiecutter.svg)](https://pypi.org/project/cookiecutter/)
  [![Build Status](https://github.com/cookiecutter/cookiecutter/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/cookiecutter/cookiecutter/actions)
  [![codecov](https://codecov.io/gh/cookiecutter/cookiecutter/branch/master/graphs/badge.svg?branch=master)](https://codecov.io/github/cookiecutter/cookiecutter?branch=master)
  [![discord](https://img.shields.io/badge/Discord-cookiecutter-5865F2?style=flat&logo=discord&logoColor=white)](https://discord.gg/9BrxzPKuEW)
  [![docs](https://readthedocs.org/projects/cookiecutter/badge/?version=latest)](https://readthedocs.org/projects/cookiecutter/?badge=latest)
  [![Code Quality](https://img.shields.io/scrutinizer/g/cookiecutter/cookiecutter.svg)](https://scrutinizer-ci.com/g/cookiecutter/cookiecutter/?branch=master)

  </div>



  Create projects swiftly from **cookiecutters** (project templates) with this command-line utility. Ideal for generating Python package projects and more.

  - [Documentation](https://cookiecutter.readthedocs.io)
  - [GitHub](https://github.com/cookiecutter/cookiecutter)
  - [PyPI](https://pypi.org/project/cookiecutter/)
  - [License (BSD)](https://github.com/cookiecutter/cookiecutter/blob/main/LICENSE)



  Install cookiecutter using pip package manager:
  ```

  pipx install cookiecutter



  python -m pip install --user cookiecutter
  ```



  - **Cross-Platform:** Supports Windows, Mac, and Linux.
  - **User-Friendly:** No Python knowledge required.
  - **Versatile:** Compatible with Python 3.7 to 3.12.
  - **Multi-Language Support:** Use templates in any language or markup format.





  The recommended way to use Cookiecutter as a command line utility is to run it with [`pipx`](https://pypa.github.io/pipx/), which can be installed with `pip install pipx`, but if you plan to use Cookiecutter programmatically, please run `pip install cookiecutter`.

  **Use a GitHub template**

  ```bash




  $ pipx run cookiecutter gh:audreyfeldroy/cookiecutter-pypackage
  ```

  **Use a local template**

  ```bash
  $ pipx run cookiecutter cookiecutter-pypackage/
  ```

  **Use it from Python**

  ```py
  from cookiecutter.main import cookiecutter


  cookiecutter('cookiecutter-pypackage/')


  cookiecutter('gh:audreyfeldroy//cookiecutter-pypackage.git')
  ```



  - Generate projects from local or remote templates.
  - Customize projects with `cookiecutter.json` prompts.
  - Utilize pre-prompt, pre- and post-generate hooks.

  [Learn More](https://cookiecutter.readthedocs.io/en/latest/usage.html)



  - Utilize unlimited directory nesting.
  - Employ Jinja2 for all templating needs.
  - Define template variables easily with `cookiecutter.json`.

  [Learn More](https://cookiecutter.readthedocs.io/en/latest/tutorials/)



  Discover a variety of ready-to-use templates on [GitHub](https://github.com/search?q=cookiecutter&type=Repositories).



  - [cookiecutter-pypackage](https://github.com/audreyfeldroy/cookiecutter-pypackage)
  - [cookiecutter-django](https://github.com/pydanny/cookiecutter-django)
  - [cookiecutter-pytest-plugin](https://github.com/pytest-dev/cookiecutter-pytest-plugin)
  - [cookiecutter-plone-starter](https://github.com/collective/cookiecutter-plone-starter)



  Join the community, contribute, or seek assistance.

  - [Troubleshooting Guide](https://cookiecutter.readthedocs.io/en/latest/troubleshooting.html)
  - [Stack Overflow](https://stackoverflow.com/questions/tagged/cookiecutter)
  - [Discord](https://discord.gg/9BrxzPKuEW)
  - [File an Issue](https://github.com/cookiecutter/cookiecutter/issues?q=is%3Aopen)
  - [Contributors](AUTHORS.md)
  - [Contribution Guide](CONTRIBUTING.md)



  - Star us on [GitHub](https://github.com/cookiecutter/cookiecutter).
  - Stay tuned for upcoming support options.



  We value your feedback. Share your criticisms or complaints constructively to help us improve.

  - [File an Issue](https://github.com/cookiecutter/cookiecutter/issues?q=is%3Aopen)



  - Be patient and consider reaching out to the community for assistance.
  - For urgent matters, contact [@audreyfeldroy](https://github.com/audreyfeldroy) for consultation or custom development.



  Adhere to the [PyPA Code of Conduct](https://www.pypa.io/en/latest/code-of-conduct/) during all interactions in the project's ecosystem.



  Created and led by [Audrey Roy Greenfeld](https://github.com/audreyfeldroy), supported by a dedicated team of maintainers and contributors.


pkgId: ca8fec80a15ba27183aa68a0e31035ad661280ce04962b9952fa1360245941b1
name: python-cookiedb
arch: src
version: 9.0.0
epoch: 0
release: 1
summary: CookieDB is a noSQL document database.
url: https://github.com/jaedsonpys/cookiedb
rpm_license: Apache License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cookiedb-9.0.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">CookieDB</h1>
  <p align="center">A safe, fast and simple database.</p>

  <p align="center" style="margin-bottom: 15px">
      <a href="https://github.com/jaedsonpys/cookiedb/releases">
          <img alt="GitHub release (latest by date including pre-releases)" src="https://img.shields.io/github/v/release/jaedsonpys/cookiedb?include_prereleases&color=green&label=version">
      </a>
      <a href="https://github.com/jaedsonpys/cookiedb/blob/master/LICENSE" style="margin-right: 5px; margin-left: 5px">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/cookiedb?color=yellow">
      </a>
      <a href="https://pypi.org/project/cookiedb">
          <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/cookiedb?color=blue">
      </a>
  </p>

  CookieDB is a noSQL database that uses the `document` model with all data encrypted using AES-256, take advantage of *performance and security* to create your projects that need **fast storage** and simple to use, where you have full control over the data. Read the [full CookieDB documentation](https://jaedsonpys.github.io/cookiedb) to understand the methods available to create, read, update, and delete data in the database.



  First, let's start by performing a quick installation of CookieDB using the PIP package manager:

  ```
  pip install cookiedb
  ```

  If you prefer, you can perform the installation manually using Git. See below how to do this:

  ```
  git clone https://github.com/jaedsonpys/cookiedb.git
  cd cookiedb/
  python3 setup.py install
  ```



  Take a look at this **simple example of using** the database, where we create and get some data (the complete example can be found in [examples/example.py](https://github.com/jaedsonpys/cookiedb/blob/master/examples/example.py))

  ```python
  from cookiedb import CookieDB

  database = CookieDB('MyDatabase', key='secret')
  database.add('languages/python', {'name': 'Python', 'ext': '.py'})

  python_ext = database.get('languages/python/ext')
  print(f'Python extension: {python_ext}')
  ```

  You can find more usage examples in the [examples/ directory](https://github.com/jaedsonpys/cookiedb/tree/master/examples)



  ```
  Apache License
  Copyright 2023 Jaedson Silva
  ```

  This project uses the *Apache License*, anyone can use this project as long as the license conditions allow. [See more about the license](https://github.com/jaedsonpys/cookiedb/blob/master/LICENSE).


pkgId: 7033a10f0d9439ddd2b8983256e7eed07667e6378aedbe306e70ef44ecf7440e
name: python-cookiejar
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Cookiecutter templates discovery and management.
url: https://github.com/fcurella/cookiejar
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cookiejar-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Cookiecutter templates discovery and management.
  Usage::
      $ pip install cookiejar
      $ cookiejar create <templatename> [options]
  Will use `cookiecutter <https://github.com/audreyr/cookiecutter>`_ to create a new package from the template.


pkgId: a0a470e5dff53c10789e5483fcdf894f19d8db00adc46862c8bb302414de766f
name: python-cookieplone
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Create Plone projects, addons, documentation with ease!
url: https://pypi.org/project/cookieplone/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cookieplone-0.8.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img alt="Plone Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-logo.png">
  </p>

  <h1 align="center">
    Cookieplone 🍪
  </h1>


  <div align="center">

  [![PyPI](https://img.shields.io/pypi/v/cookieplone)](https://pypi.org/project/cookieplone/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cookieplone)](https://pypi.org/project/cookieplone/)
  [![PyPI - Wheel](https://img.shields.io/pypi/wheel/cookieplone)](https://pypi.org/project/cookieplone/)
  [![PyPI - License](https://img.shields.io/github/license/Plone/cookieplone)](https://pypi.org/project/cookieplone/)
  [![PyPI - Status](https://img.shields.io/pypi/status/cookieplone)](https://pypi.org/project/cookieplone/)

  [![Tests](https://github.com/plone/cookieplone/actions/workflows/main.yml/badge.svg)](https://github.com/plone/cookieplone/actions/workflows/main.yml)

  [![GitHub contributors](https://img.shields.io/github/contributors/plone/cookieplone)](https://github.com/plone/cookieplone)
  [![GitHub Repo stars](https://img.shields.io/github/stars/plone/cookieplone?style=social)](https://github.com/plone/cookieplone)

  </div>

  Welcome to Cookieplone, a powerful wrapper around Cookiecutter designed to streamline the development of Plone codebases.
  Whether you're building a backend add-on, a new Volto add-on, a full project with both backend and frontend, Cookieplone simplifies the process using robust Cookiecutter templates.



  Cookieplone offers the following key features for each audience.



  - **One stop for all Plone templates**: Cookieplone helps you find the correct template to start your new Plone project.
  - **Simplified usage**: Cookieplone provides an enhanced experience over standard Cookiecutter usage by offering predefined sane defaults and a unified approach to generating various Plone projects.
  - **Batteries included**: No need to install lots of dependencies. Run `pipx run cookieplone`, and you will quickly generate your codebase.




  - **Built-in validators**: Includes built-in validators to ensure user inputs are correct.
  - **Jinja2 filters**: Includes Jinja2 filters for advanced template control.
  - **Sub-templates**: Mechanism to easily instantiate "sub templates" within cookiecutter hooks -- i.e. post_gen_hook -- , facilitating greater code reuse.




  First, ensure you have Python, pip, and pipx installed on your system.

  Then install Cookieplone using `pipx`:

  ```shell

  pipx install cookieplone
  ```

  Or, if pipx is not an option, you can install Cookieplone in your Python user directory.

  ```shell
  python -m pip install --user cookieplone
  ```



  To see all available template options, run:

  ```shell
  pipx run cookieplone
  ```

  Cookieplone will walk you through the necessary steps, using sensible defaults and offering customization options where needed.



  Cookieplone will ask a lot of questions.
  You can use some of its options to avoid repeatedly entering the same values.



  You can use the [`--no-input`](https://cookiecutter.readthedocs.io/en/latest/cli_options.html#cmdoption-cookiecutter-no-input) option to make Cookieplone not prompt for parameters and only use `cookiecutter.json` file content.



  You can use the options [`--replay`](https://cookiecutter.readthedocs.io/en/latest/cli_options.html#cmdoption-cookiecutter-replay) and [`--replay-file`](https://cookiecutter.readthedocs.io/en/latest/cli_options.html#cmdoption-cookiecutter-replay-file) to not prompt for parameters and only use information entered previously or from a specified file.
  See [Replay Project Generation](https://cookiecutter.readthedocs.io/en/latest/advanced/replay.html) in the cookiecutter documentation for more information.



  You can also specify other templates.

  | Template | Description | Command |
  | --- | --- | --- |
  | **backend_addon** | Create a Plone add-on to be used with the backend. | `pipx run cookieplone backend_addon ` |
  | **frontend_addon** | Create a Plone add-on to be used with the frontend. | `pipx run cookieplone frontend_addon ` |

  The updated list of templates can be found at the [cookieplone-templates](https://github.com/plone/cookieplone-templates) repository.



  | Environment Variable | Description | Example |
  | --- | --- | --- |
  | **COOKIEPLONE_REPOSITORY** | Where to look for templates to be used. | `COOKIEPLONE_REPOSITORY=/home/plone/cookiecutter-plone/ pipx run cookieplone` |
  | **COOKIEPLONE_REPOSITORY_TAG** | Which tag/branch to use from a remote repository. | `COOKIEPLONE_REPOSITORY_TAG=experimental pipx run cookieplone` |
  | **COOKIEPLONE_REPO_PASSWORD** | Password to use when using a remote repository that is password protected. | `COOKIEPLONE_REPO_PASSWORD=very-secure pipx run cookieplone` |



  We welcome contributions to Cookieplone.

  You can create an issue in the issue tracker, or contact a maintainer.

  - [Issue Tracker](https://github.com/plone/cookieplone/issues)
  - [Source Code](https://github.com/plone/cookieplone/)



  - Python 3.10 or later
  - [Hatch](https://hatch.pypa.io/)



  Install all development dependencies, including Hatch, and create a local virtual environment with the following command.

  ```shell
  make install
  ```



  ```shell
  make check
  ```



  [`pytest`](https://docs.pytest.org/) is this package's test runner.

  Run all tests with the following command.

  ```shell
  make test
  ```

  Run all tests, but stop on the first error and open a `pdb` session with the following command.

  ```shell
  hatch run test -x --pdb
  ```

  Run only tests that match `test_run_sanity_checks_fail` with the following command.

  ```shell
  hatch run test -k test_run_sanity_checks_fail
  ```

  Run only tests that match `test_run_sanity_checks_fail`, but stop on the first error and open a `pdb` session with the following command.

  ```shell
  hatch run test -k test_run_sanity_checks_fail -x --pdb
  ```



  For support, questions, or more detailed documentation, visit the [official Cookieplone repository](https://github.com/plone/cookieplone).

  Thank you for choosing Cookieplone for your Plone development needs!




  <p align="left">
      <a href="https://plone.org/foundation/">
        <img alt="Plone Foundation Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-foundation.png">
      </a>
  </p>



  The project is released under the [MIT License](./LICENSE).


pkgId: 80b66ae18282b347112aa3dd91539c02c2aeb8c57db122e7861140b0f6583e15
name: python-coola
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: Library to check equality between two complex/nested objects
url: https://github.com/durandtibo/coola
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coola-0.8.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/durandtibo/coola/actions">
          <img alt="CI" src="https://github.com/durandtibo/coola/workflows/CI/badge.svg">
      </a>
      <a href="https://github.com/durandtibo/coola/actions">
          <img alt="Nightly Tests" src="https://github.com/durandtibo/coola/workflows/Nightly%20Tests/badge.svg">
      </a>
      <a href="https://github.com/durandtibo/coola/actions">
          <img alt="Nightly Package Tests" src="https://github.com/durandtibo/coola/workflows/Nightly%20Package%20Tests/badge.svg">
      </a>
      <br/>
      <a href="https://durandtibo.github.io/coola/">
          <img alt="Documentation" src="https://github.com/durandtibo/coola/workflows/Documentation%20(stable)/badge.svg">
      </a>
      <a href="https://durandtibo.github.io/coola/">
          <img alt="Documentation" src="https://github.com/durandtibo/coola/workflows/Documentation%20(unstable)/badge.svg">
      </a>
      <br/>
      <a href="https://codecov.io/gh/durandtibo/coola">
          <img alt="Codecov" src="https://codecov.io/gh/durandtibo/coola/branch/main/graph/badge.svg">
      </a>
      <a href="https://codeclimate.com/github/durandtibo/coola/maintainability">
          <img src="https://api.codeclimate.com/v1/badges/83ebb50e6c6f67b0570d/maintainability" />
      </a>
      <a href="https://codeclimate.com/github/durandtibo/coola/test_coverage">
          <img src="https://api.codeclimate.com/v1/badges/83ebb50e6c6f67b0570d/test_coverage" />
      </a>
      <br/>
      <a href="https://github.com/psf/black">
          <img  alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg">
      </a>
      <a href="https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings">
          <img  alt="Doc style: google" src="https://img.shields.io/badge/%20style-google-3666d6.svg">
      </a>
      <a href="https://github.com/astral-sh/ruff">
          <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
      </a>
      <a href="https://github.com/guilatrova/tryceratops">
          <img  alt="Doc style: google" src="https://img.shields.io/badge/try%2Fexcept%20style-tryceratops%20%F0%9F%A6%96%E2%9C%A8-black">
      </a>
      <br/>
      <a href="https://pypi.org/project/coola/">
          <img alt="PYPI version" src="https://img.shields.io/pypi/v/coola">
      </a>
      <a href="https://pypi.org/project/coola/">
          <img alt="Python" src="https://img.shields.io/pypi/pyversions/coola.svg">
      </a>
      <a href="https://opensource.org/licenses/BSD-3-Clause">
          <img alt="BSD-3-Clause" src="https://img.shields.io/pypi/l/coola">
      </a>
      <br/>
      <a href="https://pepy.tech/project/coola">
          <img  alt="Downloads" src="https://static.pepy.tech/badge/coola">
      </a>
      <a href="https://pepy.tech/project/coola">
          <img  alt="Monthly downloads" src="https://static.pepy.tech/badge/coola/month">
      </a>
      <br/>
  </p>



  `coola` is a Python library that provides simple functions to check in a single line if two
  complex/nested objects are equal or not.
  `coola` was initially designed to work
  with [PyTorch `Tensor`s](https://pytorch.org/docs/stable/tensors.html)
  and [NumPy `ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html), but it
  is possible to extend it
  to [support other data structures](https://durandtibo.github.io/coola/customization).

  - [Motivation](#motivation)
  - [Documentation](https://durandtibo.github.io/coola/)
  - [Installation](#installation)
  - [Contributing](#contributing)
  - [API stability](#api-stability)
  - [License](#license)



  Let's imagine you have the following dictionaries that contain both a PyTorch `Tensor` and a
  NumPy `ndarray`.
  You want to check if the two dictionaries are equal or not.
  By default, Python does not provide an easy way to check if the two dictionaries are equal or not.
  It is not possible to use the default equality operator `==` because it will raise an error.
  The `coola` library was developed to fill this gap. `coola` provides a function `objects_are_equal`
  that can indicate if two complex/nested objects are equal or not.

  ```pycon

  >>> import numpy
  >>> import torch
  >>> from coola import objects_are_equal
  >>> data1 = {"torch": torch.ones(2, 3), "numpy": numpy.zeros((2, 3))}
  >>> data2 = {"torch": torch.zeros(2, 3), "numpy": numpy.ones((2, 3))}
  >>> objects_are_equal(data1, data2)
  False

  ```

  `coola` also provides a function `objects_are_allclose` that can indicate if two complex/nested
  objects are equal within a tolerance or not.

  ```pycon

  >>> import numpy
  >>> import torch
  >>> from coola import objects_are_allclose
  >>> data1 = {"torch": torch.ones(2, 3), "numpy": numpy.zeros((2, 3))}
  >>> data2 = {"torch": torch.zeros(2, 3), "numpy": numpy.ones((2, 3))}
  >>> objects_are_allclose(data1, data2, atol=1e-6)
  False

  ```

  `coola` supports the following types:

  - [`jax.numpy.ndarray`](https://jax.readthedocs.io/en/latest/index.html)
  - [`numpy.ndarray`](https://numpy.org/doc/stable/index.html)
  - [`numpy.ma.MaskedArray`](https://numpy.org/doc/stable/reference/maskedarray.generic.html)
  - [`pandas.DataFrame`](https://pandas.pydata.org/)
  - [`pandas.Series`](https://pandas.pydata.org/)
  - [`polars.DataFrame`](https://www.pola.rs/)
  - [`polars.Series`](https://www.pola.rs/)
  - [`torch.Tensor`](https://pytorch.org/)
  - [`torch.nn.utils.rnn.PackedSequence`](https://pytorch.org/)
  - [`xarray.DataArray`](https://docs.xarray.dev/en/stable/)
  - [`xarray.Dataset`](https://docs.xarray.dev/en/stable/)
  - [`xarray.Variable`](https://docs.xarray.dev/en/stable/)

  Please check the [quickstart page](https://durandtibo.github.io/coola/quickstart) to learn more on
  how to use `coola`.



  - [latest (stable)](https://durandtibo.github.io/coola/): documentation from the latest stable
    release.
  - [main (unstable)](https://durandtibo.github.io/coola/main/): documentation associated to the main
    branch of the repo. This documentation may contain a lot of work-in-progress/outdated/missing
    parts.



  We highly recommend installing
  a [virtual environment](https://packaging.python.org/guides/installing-using-pip-and-virtual-environments/).
  `coola` can be installed from pip using the following command:

  ```shell
  pip install coola
  ```

  To make the package as slim as possible, only the minimal packages required to use `coola` are
  installed.
  To include all the dependencies, you can use the following command:

  ```shell
  pip install coola[all]
  ```

  Please check the [get started page](https://durandtibo.github.io/coola/get_started) to see how to
  install only some specific dependencies or other alternatives to install the library.
  The following is the corresponding `coola` versions and tested dependencies.

  | `coola` | `jax`<sup>*</sup> | `numpy`<sup>*</sup> | `pandas`<sup>*</sup> | `polars`<sup>*</sup> | `pyarrow`<sup>*</sup> | `torch`<sup>*</sup> | `xarray`<sup>*</sup> | `python`      |
  |---------|-------------------|---------------------|----------------------|----------------------|-----------------------|---------------------|----------------------|---------------|
  | `main`  | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<2.0`      | `>=10.0,<18.0`        | `>=1.11,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.8.3` | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<2.0`      | `>=10.0,<18.0`        | `>=1.11,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.8.2` | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<2.0`      | `>=10.0,<18.0`        | `>=1.11,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.8.1` | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<2.0`      | `>=10.0,<18.0`        | `>=1.11,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.8.0` | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<2.0`      | `>=10.0,<18.0`        | `>=1.11,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.7.4` | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<2.0`      | `>=10.0,<18.0`        | `>=1.11,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.7.3` | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<2.0`      |                       | `>=1.11,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.7.2` | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<2.0`      |                       | `>=1.11,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.7.1` | `>=0.4.1,<1.0`    | `>=1.21,<3.0`       | `>=1.3,<3.0`         | `>=0.18.3,<1.0`      |                       | `>=1.10,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.7.0` | `>=0.4.1,<1.0`    | `>=1.21,<2.0`       | `>=1.3,<3.0`         | `>=0.18.3,<1.0`      |                       | `>=1.10,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |

  <sup>*</sup> indicates an optional dependency

  <details>
      <summary>older versions</summary>

  | `coola`  | `jax`<sup>*</sup> | `numpy`<sup>*</sup> | `pandas`<sup>*</sup> | `polars`<sup>*</sup> | `torch`<sup>*</sup> | `xarray`<sup>*</sup> | `python`      |
  |----------|-------------------|---------------------|----------------------|----------------------|---------------------|----------------------|---------------|
  | `0.6.2`  | `>=0.4.1,<1.0`    | `>=1.21,<2.0`       | `>=1.3,<3.0`         | `>=0.18.3,<1.0`      | `>=1.10,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.6.1`  | `>=0.4.1,<1.0`    | `>=1.21,<2.0`       | `>=1.3,<3.0`         | `>=0.18.3,<1.0`      | `>=1.10,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.6.0`  | `>=0.4.1,<1.0`    | `>=1.21,<2.0`       | `>=1.3,<3.0`         | `>=0.18.3,<1.0`      | `>=1.10,<3.0`       | `>=2023.1`           | `>=3.9,<3.13` |
  | `0.5.0`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<1.0`      | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.4.0`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<1.0`      | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.3.1`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<1.0`      | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.3.0`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<1.0`      | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.2.2`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<1.0`      | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.2.1`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<1.0`      | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.2.0`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<1.0`      | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.1.2`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<0.21`     | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.1.1`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<0.20`     | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.13` |
  | `0.1.0`  | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<0.20`     | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.12` |
  | `0.0.26` | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<0.20`     | `>=1.10,<2.2`       | `>=2023.1,<2023.13`  | `>=3.9,<3.12` |
  | `0.0.25` | `>=0.4.1,<0.5`    | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<0.20`     | `>=1.10,<2.2`       | `>=2023.4,<2023.11`  | `>=3.9,<3.12` |
  | `0.0.24` | `>=0.3,<0.5`      | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<0.20`     | `>=1.10,<2.2`       | `>=2023.3,<2023.9`   | `>=3.9,<3.12` |
  | `0.0.23` | `>=0.3,<0.5`      | `>=1.21,<1.27`      | `>=1.3,<2.2`         | `>=0.18.3,<0.20`     | `>=1.10,<2.1`       | `>=2023.3,<2023.9`   | `>=3.9,<3.12` |
  | `0.0.22` | `>=0.3,<0.5`      | `>=1.20,<1.26`      | `>=1.3,<2.1`         | `>=0.18.3,<0.19`     | `>=1.10,<2.1`       | `>=2023.3,<2023.9`   | `>=3.9,<3.12` |
  | `0.0.21` | `>=0.3,<0.5`      | `>=1.20,<1.26`      | `>=1.3,<2.1`         | `>=0.18.3,<0.19`     | `>=1.10,<2.1`       | `>=2023.3,<2023.8`   | `>=3.9,<3.12` |
  | `0.0.20` | `>=0.3,<0.5`      | `>=1.20,<1.26`      | `>=1.3,<2.1`         | `>=0.18.3,<0.19`     | `>=1.10,<2.1`       | `>=2023.3,<2023.8`   | `>=3.9`       |

  </details>



  Please check the instructions in [CONTRIBUTING.md](.github/CONTRIBUTING.md).



  Everyone is welcome to contribute to the community.
  If you have any questions or suggestions, you can
  submit [Github Issues](https://github.com/durandtibo/coola/issues).
  We will reply to you as soon as possible. Thank you very much.



  :warning: While `coola` is in development stage, no API is guaranteed to be stable from one
  release to the next.
  In fact, it is very likely that the API will change multiple times before a stable 1.0.0 release.
  In practice, this means that upgrading `coola` to a new version will possibly break any code that
  was using the old version of `coola`.



  `coola` is licensed under BSD 3-Clause "New" or "Revised" license available in [LICENSE](LICENSE)
  file.


pkgId: 7028be35102b368d8ae2473b811e577fe725cdca583c4d4e49fd7f7e27d0b33a
name: python-cooleans
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Better than booleans
url: https://pypi.org/project/cooleans/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cooleans-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Cooleans is a Python package that aims to enhance the bool type in Python by adding a new possible value: "perhaps". This is a value that is neither True nor False, but rather may be one of those values. With cooleans, you can more accurately represent situations where the truth value of a statement is uncertain or unknown.





  You can install cooleans using pip:
  `pip install cooleans`



  Here's an example of how to use cooleans in Python:

  ```python
  from cooleans import DefinitelyTrue, DefinitelyFalse, Perhaps

  my_bool = DefinitelyTrue
  if my_bool:
      print("This is definitely true")

  my_bool = Perhaps
  if my_bool >= Perhaps:
      print("This might be true")
  ```

  In this example, we create a `DefinitelyTrue` coolean value and use it in an if statement to print "This is definitely true". We then create a Perhaps coolean value and use it in an if statement to print "This might be true". Note that Perhaps will always have a truth value of False when treated as a bool.



  Cooleans support the same logical operators as normal bools in Python, including:

  - `and`
  - `or`
  - `not`
  - `==`
  - `!=`
  - `<`
  - `>`
  - `<=`
  - `>=`



  Cooleans can be used directly as values since they are implemented as a Python class, like so:

  ```python
  from cooleans import DefinitelyTrue, DefinitelyFalse, Perhaps

  print(DefinitelyTrue and DefinitelyFalse)
  ```

  This code snippet will output DefinitelyFalse.



  We don't welcome contributions to cooleans yet.



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


pkgId: 88b085b535462627ded8356800892faf2762d1c9ab6459953105dcb9bba41651
name: python-cooler
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: Sparse binary format for genomic interaction matrices.
url: https://pypi.org/project/cooler/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cooler-0.10.2-1.src.rpm
checksum_type: sha256
description:
  <a href="https://open2c.github.io/cooler"><img width="25%" src="https://github.com/open2c/cooler/raw/master/docs/cooler_logo.png" alt="Cooler"></a>

  <table>
      <tr>
          <td>Latest Release</td>
          <td>
              <a href="https://pypi.org/project/cooler/">
                  <img src="https://img.shields.io/pypi/v/cooler?color=blue&label=PyPI%20package" alt="latest release pypi">
              </a>
              <a href="https://bioconda.github.io/recipes/cooler/README.html">
                  <img src="https://img.shields.io/conda/vn/bioconda/cooler?color=blue" alt="latest release bioconda">
              </a>
          </td>
      </tr>
      <tr>
          <td>License</td>
          <td>
              <a href="https://github.com/open2c/cooler/blob/master/LICENSE">
                  <img src="https://img.shields.io/badge/license-BSD-green" alt="license">
                  <!-- <img src="https://img.shields.io/pypi/l/cooler.svg" alt="license"> -->
              </a>
          </td>
      </tr>
      <tr>
          <td>Build Status</td>
          <td>
              <a href="https://github.com/open2c/cooler/blob/master/.github/workflows/ci.yml">
                  <img src="https://github.com/open2c/cooler/actions/workflows/ci.yml/badge.svg" alt="build status">
              </a>
          </td>
      </tr>
      <tr>
        <td>Pre-commit Status</td>
        <td>
          <a href="https://results.pre-commit.ci/repo/github/49553222">
          <img src="https://results.pre-commit.ci/badge/github/open2c/cooler/master.svg" alt="pre-commit status" />
          </a>
        </td>
      </tr>
      <tr>
          <td>Docs Status</td>
          <td>
              <a href="http://cooler.readthedocs.org/en/latest/">
                  <img src="https://readthedocs.org/projects/cooler/badge/?version=latest">
              </a>
          </td>
      </tr>
      <tr>
          <td>Coverage</td>
          <td>
              <a href="https://codecov.io/gh/open2c/cooler">
                  <img src="https://codecov.io/gh/open2c/cooler/branch/master/graph/badge.svg" alt="coverage">
              </a>
          </td>
      </tr>
      <tr>
          <td>Downloads</td>
          <td>
              <a href="https://pypi.org/project/cooler">
                  <img src="https://static.pepy.tech/personalized-badge/cooler?period=total&units=international_system&left_color=grey&right_color=blue&left_text=PyPI%20downloads" alt="pypi downloads">
              </a>
              <a href="http://bioconda.github.io/recipes/cooler/README.html">
                  <img src="https://img.shields.io/conda/dn/bioconda/cooler.svg?style=flat&label=Bioconda downloads" alt="bioconda downloads">
              </a>
          </td>
      </tr>
      <tr>
          <td>Citation</td>
          <td>
              <a href="https://doi.org/10.1093/bioinformatics/btz540">
                  <img src="https://img.shields.io/badge/DOI-10.1093%2Fbioinformatics%2Fbtz540-blue" alt="paper doi">
              </a>
              <a href="https://zenodo.org/badge/latestdoi/49553222">
                  <img src="https://zenodo.org/badge/49553222.svg" alt="zenodo doi">
              </a>
          </td>
      </tr>
      <tr>
          <td>Community</td>
          <td>
              <a href="https://bit.ly/open2c-slack">
                  <img src="https://img.shields.io/badge/chat-slack-%233F0F3F?logo=slack" alt="slack">
              </a>
              <a href="https://www.numfocus.org/">
                  <img src="https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A" alt="numfocus">
              </a>
          </td>
      </tr>
  </table>



  Cooler is a support library for a **sparse, compressed, binary** persistent storage [format](http://cooler.readthedocs.io/en/latest/schema.html), also called cooler, used to store genomic interaction data, such as Hi-C contact matrices.

  The cooler file format is an implementation of a genomic matrix data model using [HDF5](https://en.wikipedia.org/wiki/Hierarchical_Data_Format) as the container format. The `cooler` package includes a suite of [command line tools](http://cooler.readthedocs.io/en/latest/cli.html) and a [Python API](http://cooler.readthedocs.io/en/latest/api.html) to facilitate creating, querying and manipulating cooler files.

  To get started:

  - [Install](#Installation) cooler
  - Read the [documentation](http://cooler.readthedocs.org/en/stable/) and see the Jupyter Notebook [walkthrough](https://github.com/open2c/cooler-binder).
  - _cool_ files from published Hi-C data sets are available [here](https://usgs2.osn.mghpcc.org/cooler01/index.html) or via s3 (bucket `s3://cooler01 --endpoint-url https://usgs2.osn.mghpcc.org --no-sign-request`).
  - Many more multires (_mcool_) files are available on the [4DN data portal](https://data.4dnucleome.org/visualization/index).



  Install from PyPI using pip.
  ```sh
  $ pip install cooler
  ```

  If you are using `conda`, you can alternatively install `cooler` from the [bioconda](https://bioconda.github.io/index.html) channel.
  ```sh
  $ conda install -c conda-forge -c bioconda cooler
  ```



  Abdennur, N., and Mirny, L.A. (2020). Cooler: scalable storage for Hi-C data and other genomically labeled arrays. _Bioinformatics_. doi: [10.1093/bioinformatics/btz540](https://doi.org/10.1093/bioinformatics/btz540).

  ```bibtex
  @article{cooler2020,
      author = {Abdennur, Nezar and Mirny, Leonid A},
      title = "{Cooler: scalable storage for Hi-C data and other genomically labeled arrays}",
      journal={Bioinformatics},
      volume={36},
      number={1},
      pages={311--316},
      year={2020},
      doi = {10.1093/bioinformatics/btz540},
      url = {https://doi.org/10.1093/bioinformatics/btz540},
  }
  ```



  Interested in contributing to cooler? That's great! To get started, check out the [contributing guide](https://github.com/open2c/cooler/blob/master/CONTRIBUTING.md).




  - See other Open2C tools to process Hi-C data ([pairtools](https://github.com/open2c/pairtools), [distiller](https://github.com/open2c/distiller-nf)) and analyze Hi-C data ([cooltools](https://github.com/open2c/cooltools))!
  - Visualize your cooler data with [HiGlass](http://higlass.io)!
  - Check out this list of [3D genomics tools and papers](https://github.com/mdozmorov/HiC_tools), most of which accept cooler files.



  * Cooler is an Affiliated Project of [NumFOCUS](https://www.numfocus.org/).
  * Cooler development has received support from the NIH [4D Nucleome](https://www.4dnucleome.org/) Consortium.
  * We are grateful for a storage allocation from NSF's [ACCESS Cyberinfrastucture](https://access-ci.org/) Open Storage Network to host example cooler data.


pkgId: ee5ed5c43539bb3c1486a0bb470e771c86bf5cc04c1f5fa9ef63e103d14f27ef
name: python-coolipy
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Coolipy - (Un)oficial Coolify - coolify.io - Python client!
url: https://github.com/gbbocchini/coolipy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coolipy-0.0.3-1.src.rpm
checksum_type: sha256
description:
  **The first (un)official Python client for the [Coolify](https://coolify.io/).**
  Coolipy simplifies programmatically interacting with Coolify by providing wrappers around [Coolify API](https://coolify.io/docs/api), enabling you to manage projects, deployments, servers, services, and more with python scripts.



  Install Coolipy using pip:

  ```bash
  pip install coolipy
  ```


  - Manage Coolify projects, servers, and deployments.
  - Simplify service creation and environment management.
  - 1 dependency: requests.

  TO DO:

  - Async support.




  - Import and Initialize
  ```python
  from coolipy import Coolipy

  coolify = Coolipy(
      coolify_api_key="your_coolify_api_key",
      coolify_endpoint="your_coolify_instance_address",
  )
  ```



  - Get Project Information
  ```python
  coolify.projects.get(project_uuid="your_project_uuid")
  ```

  - Create a Service
  ```python
  service_data = ServiceModelCreate(
      type=COOLIFY_SERVICE_TYPES.glance,
      name="Example Service",
      project_uuid="your_project_uuid",
      server_uuid="your_server_uuid",
      destination_uuid="your_destination_uuid",
      instant_deploy=True,
      environment_name="production"
  )
  new_service = coolify.services.create(service_data)
  ```


  - List Servers
  ```python
  servers = coolify.servers.list()
  ```

  - Create a DB:
  ```python
  postgres_db = PostgreSQLModelCreate(
      project_uuid="your_project_uuid",
      server_uuid="your_server_uuid",
      environment_name="production",
      is_public=False,
      limits_cpu_shares=0,
      limits_cpus=0,
      limits_cpuset=0,
      limits_memory=0,
      limits_memory_reservation=0,
      limits_memory_swap=0,
      limits_memory_swappiness=0,
      instant_deploy=True,
      postgres_user="dbuser",
      postgres_password="password",
      postgres_db="mydatabase",
      name="My PostgreSQL DB",
      postgres_conf="LQ==",  # Example config
      postgres_host_auth_method="-",
      postgres_initdb_args="-"
  )

  coolify.databases.create(database_model_create=postgres_db)
  ```

  - Create an App
  ```python
  app_data = ApplicationPrivateGHModelCreate(
      project_uuid="your_project_uuid",
      server_uuid="your_server_uuid",
      environment_name="production",
      ports_exposes="8080",
      github_app_uuid="your_github_app_uuid",
      git_repository="your_github_repo",
      git_branch="main",
      build_pack=COOLIFY_BUILD_PACKS.dockerfile,
      instant_deploy=True,
      name="MyApp"
  )

  new_app = coolify.applications.create(app_data)
  ```




  This project is licensed under the Apache License 2.0. See the [LICENSE](./LICENSE) file for details.


pkgId: a92026387c42766b50e4896ac8539bbada874d55a4c643dda6ad989aa6c6c467
name: python-coolpuppy
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A versatile tool to perform pile-up analysis on Hi-C data in .cool format.
url: https://pypi.org/project/coolpuppy/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coolpuppy-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/147190130.svg)](https://zenodo.org/badge/latestdoi/147190130)
  [![PyPI version](https://badge.fury.io/py/coolpuppy.svg)](https://badge.fury.io/py/coolpuppy)
  [![Pytest](https://github.com/open2c/coolpuppy/actions/workflows/tests.yml/badge.svg)](https://github.com/open2c/coolpuppy/actions/workflows/tests.yml)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Docs status](https://readthedocs.org/projects/coolpuppy/badge/)](https://coolpuppy.readthedocs.io/en/latest/)

  .**cool** file **p**ile-**up**s with **py**thon.

  A versatile tool to perform pile-up analysis on Hi-C data in .cool format (https://github.com/mirnylab/cooler). And who doesn't like cool pupppies?





  Pileups is the generic term we use to describe any procedure that averages multiple 2D regions (snippets) of a 2D matrix, e.g. Hi-C data. In some contexts they are also known as APA (aggregate peak analysis, from Rao et al., 2014), or aggregate region/TAD analysis (in GENOVA, van der Weide et al., 2021), and other names.
  The most typical use case is to quantify average strength of called dots (loops) in Hi-C data, or strength of TAD boundaries. However the approach can do much more than that.
  This is the idea of how pileups work to check whether certain regions tend to interact with each other:

  <img src="https://raw.githubusercontent.com/open2c/coolpuppy/master/loop_quant.png" alt="Pileup schematic" width="1000px"/>

  On the right is the more typical use case for quantification of loop strength. On the left is a different approach, designed to check whether specific regions in the genome (e.g. binding sites of a certain factor) tend to interact with each other.

  What is very important for this quantification, is the normalization to expected values. This can be done in two ways: either using a chromosome- (or arm-) wide by-distance expected interactions, using a file with average values of interactions at different distances (e.g. output of `cooltools expected-cis`), or directly from Hi-C data by dividing the pileups over randomly shifted control regions. If neither expected normalization approach is used (just set `--nshifts 0`), this becomes essentially identical to the APA approach (Rao et al., 2014), which can be used for averaging strongly interacting regions, e.g. annotated loops. For weaker interactors, decay of contact probability with distance can hide any focal enrichment that could be observed otherwise. However, most importantly, when comparing different sets of regions at even slightly different distances, or comparing different datasets, the decay of contact probability with distance will very strongly affect the resulting values, hence normalizing to it is essential in many cases, and generally recommended.



  `cooltools` is the main package with Hi-C analysis maintained by open2C. It also has a tool to perform pileups. Why does `coolpup.py` exist then?
  The way `cooltools pileup` works, is it accumulates all snippets for the pileup into one 3D array (stack). Which gives a lot of flexibility in case one wants to subset the snippets based on some features later, or do some other non-standard computations based on the stack. But this is only advantageous when one performs analysis using the Python API, and moreover limits the application of `cooltools pileup` so it can't be applied to a truly large number of snippets due to memory requirements. That's where `coolpup.py` comes in: internally it never stores more than one snippet in memory, hence there is no limit to how many snippets can be processed. `coolpup.py` is particularly well suited performance-wise for analysing huge numbers of potential interactions, since it loads whole chromosomes into memory one by one (or in parallel to speed it up) to extract small submatrices quickly. Having to read everything into memory makes it relatively slow for small numbers of loops, but performance doesn't decrease until you reach a huge number of interactions. Additionally, `cooltools pileup` doesn't support inter-chromosomal (trans) pileups, however it is possible in `coolpup.py`.

  While there is no way to subset the snippets after the pileup is generated (since they are not stored), `coolpup.py` allows one to perform various subsetting during the pileup procedure. Builtin options in the CLI are subsetting by distance, by strand, by strand and distance at the same time, and by window/region - in case of a provided BED file, one pileup is generated for each row against all others in the same chromosome; in case of trans-pileups, pileups for each chromosome pair can be generated. Importantly, in Python API any arbitrary grouping of snippets is possible.



  .cool is a modern and flexible format to store Hi-C data.
  It uses HDF5 to store a sparse representation of the Hi-C data, which allows low memory requirements when dealing with high resolution datasets. Another popular format to store Hi-C data, .hic, can be converted into .cool files using `hic2cool` (https://github.com/4dn-dcic/hic2cool).

  See for details:

  Abdennur, N., and Mirny, L. (2019). Cooler: scalable storage for Hi-C data and other genomically-labeled arrays. Bioinformatics. [10.1093/bioinformatics/btz540](https://doi.org/10.1093/bioinformatics/btz540)




  All requirements apart are available from PyPI or conda.

  Before installing everything you need to obtain `Cython` using either pip or conda. Then for coolpuppy (and other dependencies) simply do:

  `pip install coolpuppy`

  or

  `pip install https://github.com/open2c/coolpuppy/archive/master.zip`

  to get the latest version from GitHub. This will make `coolpup.py` callable in your terminal, and importable in python as `coolpuppy`.



  The basic usage syntax is as follows:

  `coolpup.py [OPTIONS] coolfile.cool regionfile.bed`

  A guide walkthrough to pile-up analysis is available here (WIP): [Walkthrough](https://coolpuppy.readthedocs.io/en/latest/walkthrough.html)

  Docs for the command line interface are available here: [CLI docs](https://coolpuppy.readthedocs.io/en/latest/coolpup_py_cli.html)

  Some examples to get you started with CLI interface are available [here](https://coolpuppy.readthedocs.io/en/latest/Examples/Walkthrough_CLI.html) and for the python API examples see [here](https://coolpuppy.readthedocs.io/en/latest/Examples/Walkthrough_API.html).


  For flexible plotting, I suggest to use `matplotlib` or another library. However simple plotting capabilities are included in this package. Just run `plotpup.py` with desired options and list all the output files of `coolpup.py` you'd like to plot.


  Ilya M Flyamer, Robert S Illingworth, Wendy A Bickmore (2020). Coolpup.py: versatile pile-up analysis of Hi-C data. Bioinformatics, 36, 10, 2980–2985.

  [https://academic.oup.com/bioinformatics/article/36/10/2980/5719023](https://academic.oup.com/bioinformatics/article/36/10/2980/5719023)

  doi: 10.1093/bioinformatics/btaa073


pkgId: a424206c9e1a4a908d118c956ed3b8b7963030026d70c413edc55e9eea802ff6
name: python-coolpy
arch: src
version: 0.0.55
epoch: 0
release: 1
summary: Muon ionization simulation program
url: https://github.com/BerndStechauner/coolpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coolpy-0.0.55-1.src.rpm
checksum_type: sha256
description:
  This is a project demonstrating how publich a muon beam cooling module to PyPI



  Run the following to install:

  '''python pip install coolpy'''



  '''python
  from coolpy import quadrupole



  '''



  To install coolpy, aling with the tool you need to develop and run tests, run the following in you r virtualenv:

  '''bash
  $ pip install -e .[dev]
  '''


pkgId: 9cb1dc5a6a086ab91f81bcb7b0d0b6f9d2cbcb1c29d680140a444903af4b8349
name: python-coop
arch: src
version: 6.2.1
epoch: 0
release: 1
summary: Standard base to build Wagtail sites from
url: https://pypi.org/project/coop/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coop-6.2.1-1.src.rpm
checksum_type: sha256
description:
  This is a base to build all Neon Jungle sites off.
  This package contains all the common code shared
  between sites, with the ideal Neon Jungle site containing only
  model definitions, templates, and front end assets.


pkgId: 7b6c7c528f327b241e0541157dfc1ffbee3cd4ca79d561de3f258ce5b4d4dbd1
name: python-coop-kobe-downloader
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Add your description here
url: https://github.com/ryohidaka/coop-kobe-downloader
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coop-kobe-downloader-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/coop-kobe-downloader.svg)](https://badge.fury.io/py/coop-kobe-downloader)
  ![build](https://github.com/ryohidaka/coop-kobe-downloader/workflows/Build/badge.svg)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

  コープこうべの宅配の注文書(CSV)をダウンロードする Python パッケージ



  You can install this library using PyPI:

  ```shell
  pip install coop-kobe-downloader
  ```



  ```py
  from coop_kobe_downloader import CoopKobeDownloader, Weekday


  login_id = "hoge@example.com"


  password = "hogehoge"


  download_dir = ".output"


  downloader = CoopKobeDownloader(login_id, password, download_dir)


  phase = downloader.get_phase(Weekday.WED)
  print(phase)



  downloader.download(phase)
  ```



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

rpm_license:
  MIT License  Copyright (c) 2024 日高 凌  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: db9fbf4506a076aebaf47f1641c4e7294690d066c38da6f81025af760941ed4c
name: python-coopstarter-data
arch: src
version: 0.2.16
epoch: 0
release: 1
summary: CoopStarter Application
url: http://git.happy-dev.fr/startinblox/applications/coopstarter/coopstarter-data
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coopstarter-data-0.2.16-1.src.rpm
checksum_type: sha256
description:
  This project is a Python module, compatible with Django REST Framework and DjangoLDP additional module, describing the models and the API needed and available on the future coopstarter application.



  Here is the detailed explaination of the preferred installation process.
  Depending on your OS and your python installation, commands could have to be run using either `python` or `python3`.


  If you'll have to work on many projects at the same time, we recommande to use virtualenvwrapper.
  https://virtualenvwrapper.readthedocs.io/en/latest/

  If you're not using virtualenvwrapper, create the python virtual environnement dedicated to the project


  ```shell
  mkdir coopstarter
  cd coopstarter
  pip install virtualenv
  virtualenv venv
  source venv/bin/activate
  ```

  ```shell

  pip install sib-manager

  sib startproject coopstarter

  cd coopstarter
  ```

  Open the file "packages.yml", and replace the content of 'ldppackages :' by :
  ```
  oidc_provider: 'git+https://github.com/jblemee/django-oidc-provider.git@develop'
  django_countries: django_countries
  djangoldp_account: djangoldp_account
  djangoldp_circle: djangoldp_circle
  djangoldp_conversation: djangoldp_conversation
  coopstarter_data: coopstarter_data
  djangoldp_like: djangoldp_like
  djangoldp_uploader: djangoldp_uploader
  ```

  ```shell

  sib install coopstarter
  ```



  ```shell
  python manage.py createsuperuser
  python manage.py creatersakey
  ```

  ```shell
  python manage.py runserver
  ```

  If successful, this command will make available on `127.0.0.1:8000/admin/` the administrator backend. You will then be able to log-in with 'admin' as identifier and as password.



  Warning! At this step, you should can Balessan or Alice

  Nota Bene : If you using virtualenvwrapper, replace "../venv" by "path/to/your/virtualenv"


  As some fixtures are provided to enrich the application database easily, the following command will allow you to properly load them.

  ```
  python manage.py loaddata ../venv/lib/python3.6/site-packages/coopstarter_data/fixtures/*.json
  ```

  If you load the coopstarter_data package locally through a symlink for development purpose, you should use the following command:

  ```
  python manage.py loaddata coopstarter_data/fixtures/*.json
  ```

  If you have some issues with the previous command, such as `Field table does not exist` or equivalent, please run:

  ```
  python manage.py makemigrations
  python manage.py migrate
  ```

  And run the loaddata command once more.

  If you get a error message like : `django.db.utils.OperationalError: no such table: coopstarter_data_mymissingtable, please run :

  ```
  python3 manage.py migrate --run-syncdb
  ```



  ![EULOGO](documentation/EU_logos.png)

  This software has been co-funded by the European Union.
  The contents of this software are the sole responsibility of Cooperatives Europe and can in no way be taken to reflect the views of the European Union.


pkgId: 92c93f203446e04a97fa6524b13633bce147e8420e70652d486c3ab7a61f2b42
name: python-coordinate-calculator
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A Python library to calculate GPS coordinates from detected points in images.
url: https://github.com/ITPATJIDR/Coordinate_Calculator
rpm_license: COSI
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coordinate-calculator-0.1.4-1.src.rpm
checksum_type: sha256
description:
  This library helps calculate the geographical position of detected objects using camera parameters and object detection results.



  ```bash
  pip install object-position-calculator
  ```


  ```python
  if __name__ == "__main__":
      client = DroneYOLOClient("http://10.109.68.49:8000")
      client.connect()
      client.send_message_to_server("Hello, world from YOLO!")
      client.send_drone_command("capture_img")
      client.wait()
  ```


pkgId: aabd2bbd8479a4877259ef11f4e3261f1d9857db0054c1218be8071bc568c6ad
name: python-coordinate-estimate
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A Python library to calculate GPS coordinates from detected points in images.
url: https://github.com/ITPATJIDR/Coordinate_Calculator
rpm_license: COSI
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coordinate-estimate-0.1.4-1.src.rpm
checksum_type: sha256
description:
  This library helps calculate the geographical position of detected objects using camera parameters and object detection results.



  ```bash
  pip install object-position-calculator
  ```


  ```python
  from object_position_calculator import DroneYOLOClient

  if __name__ == "__main__":
      client = DroneYOLOClient("http://10.109.68.49:8000", "best.pt")
      client.connect()
      client.send_message_to_server("Hello, world from YOLO!")
      client.send_drone_command("capture_img")
      client.wait()
  ```


pkgId: 0bc63709b9adcc92e9ad6dddd55160838adad298b0a05a6cdd4e4437422c9ccb
name: python-coordinate-system
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A package for coordinate systems
url: https://github.com/panguojun/Coordinate-System
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coordinate-system-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Create an `__init__.py` file in the `coordinate_system/` directory to mark it as a package. You can add the following content to the `__init__.py` file:

  ```python
  from .coord import coord3



  This package provides a mathematical framework for defining and manipulating three-dimensional coordinate systems in Python. It includes the `vec3`, `quaternion`, and `coord3` classes, allowing users to work with vectors, rotations, and coordinate transformations efficiently.



  You can install the package using pip:

  ```bash
  pip install coordinate-system
  ```



  The `Coord` system is based on group theory and defines a coordinate system in three-dimensional space. It includes an origin, three directional axes, and scaling components that correspond to transformations like translation, rotation, and scaling. This package provides methods to construct coordinate systems from various parameters and perform operations to convert between different coordinate systems.





  Represents a three-dimensional vector.

  - **Constructors:**
    - `vec3()` - Initializes a zero vector.
    - `vec3(float x, float y, float z)` - Initializes with specified components.

  - **Properties:**
    - `x`: Component along the x-axis.
    - `y`: Component along the y-axis.
    - `z`: Component along the z-axis.

  - **Methods:**
    - `__repr__()`: Returns a string representation of the vector.
    - `__add__(vec3 other)`: Computes the sum of two vectors.
    - `__sub__(vec3 other)`: Computes the difference between two vectors.
    - `__mul__(float scalar)`: Multiplies the vector by a scalar.
    - `__truediv__(float scalar)`: Divides the vector by a scalar.
    - `dot(vec3 other)`: Computes the dot product with another vector.
    - `cross(vec3 other)`: Computes the cross product with another vector.
    - `length()`: Returns the length (magnitude) of the vector.
    - `normalize()`: Normalizes the vector to unit length.
    - `isINF()`: Checks if any component is infinite.
    - `flipX()`, `flipY()`, `flipZ()`: Flips the respective component.
    - `serialise()`: Serializes the vector.
    - `len()`, `lenxy()`, `sqrlen()`, `abslen()`: Various length-related calculations.
    - `norm()`, `normcopy()`, `normalized()`: Normalization methods.
    - `min3(vec3 a, vec3 b, vec3 c)`: Returns the minimum of three vectors.
    - `max3(vec3 a, vec3 b, vec3 c)`: Returns the maximum of three vectors.
    - `rnd()`: Generates a random vector.
    - `lerp(vec3 a, vec3 b, float t)`: Performs linear interpolation between two vectors.
    - `angle(vec3 a, vec3 b)`: Computes the angle between two vectors.



  Represents a quaternion for 3D rotations.

  - **Constructors:**
    - `quat()` - Initializes to identity quaternion.
    - `quat(float w, float x, float y, float z)` - Initializes with specified components.
    - `quat(float angle, const vec3& axis)` - Creates a quaternion from an angle and an axis.
    - `quat(const vec3& v1, const vec3& v2)` - Creates a quaternion from two vectors.

  - **Properties:**
    - `w`: Scalar component of the quaternion.
    - `x`, `y`, `z`: Vector components of the quaternion.

  - **Methods:**
    - `__repr__()`: Returns a string representation of the quaternion.
    - `__add__(quaternion other)`: Computes the sum of two quaternions.
    - `__mul__(quaternion other)`: Multiplies two quaternions.
    - `__mul__(vec3 vector)`: Rotates a vector using the quaternion.
    - `__truediv__(quaternion other)`: Divides one quaternion by another.
    - `normalize()`: Normalizes the quaternion.
    - `normalized()`: Returns a normalized copy of the quaternion.
    - `conj()`: Returns the conjugate of the quaternion.
    - `conjcopy()`: Returns a copy of the conjugate quaternion.
    - `length()`: Returns the length of the quaternion.
    - `dot(quaternion other)`: Computes the dot product with another quaternion.
    - `angle_to(quaternion other)`: Computes the angle to another quaternion.
    - `from_eulers(float pitch, float yaw, float roll)`: Creates a quaternion from Euler angles.
    - `fromvectors(vec3 v1, vec3 v2)`: Creates a quaternion from two vectors.
    - `ang_axis(float angle, vec3 axis)`: Creates a quaternion from an angle and axis.
    - `exp()`: Computes the exponential of the quaternion.
    - `log()`: Computes the logarithm of the quaternion.
    - `spherical_cubic_interpolate()`: Performs spherical cubic interpolation.



  Represents a 3D coordinate system.

  - **Constructors:**
    - `coord3()` - Default constructor.
    - `coord3(real x, real y, real z)` - Initializes with specified coordinates.
    - `coord3(real x, real y, real z, real sx, real sy, real sz)` - Initializes with position and scaling.
    - `coord3(const vec3& position)` - Initializes from a position vector.
    - `coord3(const vec3& ux, const vec3& uy, const vec3& uz)` - Initializes from three axis vectors.
    - `coord3(real angle, const vec3& axis)` - Initializes from an angle and axis.
    - `coord3(const quaternion& q)` - Initializes from a quaternion.
    - `coord3(const vec3& position, const quaternion& q, const vec3& scale)` - Initializes from position, quaternion, and scale.

  - **Properties:**
    - `o`: Origin vector.
    - `ux`, `uy`, `uz`: Directional axes.
    - `s`: Scale vector.

  - **Methods:**
    - `__add__(coord3 other)`: Computes the sum of two coordinate systems.
    - `__sub__(coord3 other)`: Computes the difference between two coordinate systems.
    - `__mul__(coord3 other)`: Multiplies two coordinate systems.
    - `__mul__(vec3 vector)`: Transforms a vector using the coordinate system.
    - `__truediv__(coord3 other)`: Divides one coordinate system by another.
    - `__eq__(coord3 other)`: Checks for equality between two coordinate systems.
    - `__ne__(coord3 other)`: Checks for inequality between two coordinate systems.
    - `pos()`: Returns the position vector.
    - `tovec()`: Converts the coordinate system to a vector.
    - `pose()`: Returns the pose of the coordinate system.
    - `rot(real angle, const vec3& axis)`: Rotates the coordinate system by an angle around an axis.
    - `rot(const quaternion& q)`: Rotates the coordinate system by a quaternion.
    - `rotated(real angle, const vec3& axis)`: Returns a new rotated coordinate system.
    - `rotated(const quaternion& q)`: Returns a new coordinate system rotated by a quaternion.
    - `equal_dirs(coord3 other)`: Checks if the directional axes are equal.
    - `hash()`: Returns a hash of the coordinate system.
    - `serialise()`: Serializes the coordinate system.
    - `dump()`: Dumps information about the coordinate system.
    - `lie_cross(coord3 other)`: Computes the Lie cross product.
    - `grad()`: Computes the gradient.
    - `reverse()`: Reverses the coordinate system.
    - `reversed()`: Returns a new reversed coordinate system.
    - `cross(coord3 other)`: Computes the cross product with another coordinate system.
    - `cross(vec3 vector)`: Computes the cross product with a vector.





  You can create a coordinate system using various constructors:

  ```python
  from coordinate_system import coord3, vec3


  C = coord3.from_axes(vec3(1, 0, 0), vec3(0, 1, 0), vec3(0, 0, 1))


  C_angle = coord3.from_angle(90, vec3(0, 0, 1))
  ```



  You can transform vectors between different coordinate systems:

  ```python
  V1 = vec3(1, 2, 3)
  C1 = coord3(...)  # Some coordinate system
  C0 = coord3(...)  # Another coordinate system


  V0 = V1 * C1


  V1 = V0 / C1
  ```





  ```python

  VL = Vw / C
  Vw = VL * C
  ```



  ```python
  V1 = V4 * C4 * C3 * C2
  V4 = V1 / C2 / C3 / C4
  ```



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


pkgId: 539499e728b65b07181f0a254399d1cbc53fd4ae4a5420a729debf8397354d9b
name: python-coordination-network-toolkit
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: Tools for computing networks of coordinated behaviour on social media
url: https://github.com/QUT-Digital-Observatory/coordination-network-toolkit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coordination-network-toolkit-1.5.2-1.src.rpm
checksum_type: sha256
description:
  A small command line tool and set of functions for studying coordination networks
  in Twitter and other social media data.



  <img src="https://i.ibb.co/qJVwBKR/coretweet-min-Weight2-coloured-By-Account-Status.png" alt="Network visualisation of a co-retweet network" width="400" height="400" align="right">

  Social media activity doesn't occur in a vaccuum. Individuals on social media are often taking part in *coordinated activities* such as protest movements or interest-based communities.

  Social media platforms are also used strategically to boost particular messages in line with political campaign goals or for commercial profit and scamming. This involves multiple accounts posting or reposting the same content, repeatedly and within a short time window (e.g. within 1 minute).

  This software provides a toolkit to detect coordinated activity on social media and to generate networks that map the actors and their relationships. It provides a general purpose toolkit for multiple types of coordinated activity on any type of social media platform.

  Fundamentally this toolkit produces networks where the nodes are accounts, and the weighted edges between these accounts are the number of messages from those accounts that meet some criterion for a type of *coordination*. This toolkit already implements several approaches to detecting different types of coordination, and is intended to be extensible to more cases in the future.

  Firstly, it includes functionality for *co-tweeting* and *co-retweeting* (Keller et al., 2019; Schafer et al., 2017), where accounts post exactly the same text (co-tweets) or repost the same post within a short time window (co-retweets). Secondly, it includes functionality for *co-link* analysis, where multiple accounts post the same URLs repeatedly and in a short time window of each other (Giglietto et al., 2020). Thirdly, it adds two new types of network types: *co-reply*, where accounts are replying to the same post repeatedly together; and *co-similarity*, where accounts post similar text (but not exact duplicates), which relaxes the strict assumption of co-tweeting.



  Briefly, the following network types are supported. For more information see the [documentation](docs/network_types.md)

  1. Co-retweet: reposting the same post
  2. Co-tweet: posting identical text
  3. Co-similarity: posting similar text (Jaccard similarity or user-defined)
  4. Co-link: posting the same link
  5. Co-reply: replying to the same post
  6. Co-post: posting any time of message within the same time window

  The default time window is 60 seconds for all network types.



  Giglietto, F., Righetti, N., Rossi, L., & Marino, G. (2020). It takes a village to manipulate the media: coordinated link sharing behavior during 2018 and 2019 Italian elections. Information, Communication and Society, 1–25.

  Graham, T., Bruns, A., Zhu, G., & Campbell, R. (2020). Like a virus: The coordinated spread of coronavirus disinformation. Report commissioned for the Centre for Responsible Technology.

  Keller, F. B., Schoch, D., Stier, S., & Yang, J. (2020). Political Astroturfing on Twitter: How to coordinate a disinformation Campaign. Political Communication, 37(2), 256-280.

  Schafer, F., Evert, S., & Heinrich, P. (2017). Japan’s 2014 General Election: Political Bots, Right-Wing Internet Activism, and Prime Minister Shinz Abe’s Hidden Nationalist Agenda. Big Data, 5(4), 294–309.




  This tool requires a working Python 3.6 (or later) environment.

  This tool can be installed from pip - this will handle installing the necessary
  dependencies.

  `pip install coordination_network_toolkit`

  Once you have installed, you can use the toolkit in either of two ways:

  1. As a command-line tool (run `compute_networks --help` to find out how)
  2. As a Python library (`import coordination_network_toolkit`)




  Using this tool requires:

  1. Collecting data from the social media platform of choice
  2. Preparing or preprocessing the data into one of the formats the tool accepts:
  	- either a specific CSV format that works across all platforms OR
  	- using the platform native format (currently Twitter JSON from both
          V1.1 and V2 APIs, including the Twitter Academic track, are supported)
  3. Preprocessing the raw data into an SQLite database to setup the data structures for
     efficient computation of the different networks
  4. Generating the network of choice, storing the output in a specified file.




  This is just a quick example - see also [the tutorial.](docs/tutorial.md)



  1. Collect Twitter data in the native Twitter JSON format using
  [twarc](https://github.com/docnow/twarc/), from either the V1.1 and V2 APIs

      - `twarc search '#banana' --output banana.json`
      - `twarc2 search --limit 1000 --archive '#purple' purple.json  `

  2. Bring the data into a local database file called processed_bananas.db. The original
  data file is not modified in any way. The toolkit will handle processing the Twitter
  JSON formats into the necessary format, including handling things like retweets, replies,
  urls, and extracting the text of the tweet. It will also handle deduplication, so if a
  tweet is  present more than once only the first instance will be recorded.

      - `compute_networks processed_bananas.db preprocess --format twitter_json banana.json purple.json`

  3. Calculate a retweet network, saving the output to a graphml format that can be
  directly opened in a tool like (Gephi)[https://gephi.org]. These settings indicate that
  if two users have retweeted the same tweet within 60 seconds of each other, there is a
  potential link.

      - `compute_networks processed_bananas.db compute co_retweet --time_window 60 --output_file bananas_retweet_60s.graphml --output_format graphml`

  3. Calculate a co-link network, again saving the output in graphml format. By default
  this will use the plain text of the URL for matching, so the output here will confuse
  urls that are shortened.

      - `compute_networks processed_bananas.db compute co_link --time_window 60 --output_file bananas_colink_unresolved_60s.graphml --output_format graphml`

  4. Resolve collected URLs, to handle link shortening services. Note that this process
  is intentionally rate limited to resolve no more than 25 urls/second. Once resolved,
  URLs will not be retried, so you can safely run this command again.

      - `compute_networks processed_bananas.db resolve_urls`

  5. Calculate the co-link network, this time using the resolved urls.

      - `compute_networks processed_bananas.db compute co_link --time_window 60 --output_file bananas_colink_resolved_60s.graphml --output_format graphml --resolved`




  You can find the following example as a Jupyter notebook you can run yourself in
  `examples/example.ipynb`.

  ```
  import coordination_network_toolkit as coord_net_tk
  import networkx as nx




  db_name = '/path/to/your/db.db'
  coord_net_tk.preprocess.preprocess_csv_files(db_name, ['/path/to/your/csv_file.csv'])


  coord_net_tk.compute_networks.compute_co_similar_tweet(db_name, 60)


  similarity_graph = coord_net_tk.graph.load_networkx_graph(db_name, "co_similar_tweet")


  for g in nx.connected_components(similarity_graph):
      print(g)
  ```






  JSON data from V1.1 and V2 of the Twitter API can be ingested directly.




  To use the CSV ingest format, construct a CSV with a header and the following columns.
  The names of the columns don't matter but the order does.

  - message_id: the unique identifier of the message on the platform
  - user_id: the unique identifier of the user on the platform
  - username: the text of the username (only used for display)
  - repost_id: if the message is a verbatim report of another message (such as a retweet
  	or reblog), this is the identifier of that other message. Empty strings will be
  	converted to null
  - reply_id: if the message is in reply to another message, the identifier for that other
      message. Empty strings will be converted to null.
  - message: the text of the message.
  - timestamp: A timestamp in seconds for the message. The absolute offset does not matter,
      but it needs to be consistent across all rows
  - urls: A space delimited string containing all of the URLs in the message




  Graham, Timothy; QUT Digital Observatory; (2020): Coordination Network Toolkit.
  Queensland University of Technology. (Software)
  https://doi.org/10.25912/RDF_1632782596538




  Are you getting stuck somewhere or want to ask questions about using this toolkit? Please open an issue or bring your questions to the Digital Observatory's fortnightly [office hours](https://research.qut.edu.au/digitalobservatory/office-hours/).


pkgId: 3fa67a696427616d163ebb71e562845dda9879f15f32cd157a92b6afb01a049c
name: python-coordinax
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: Coordinates in JAX
url: https://github.com/GalacticDynamics/coordinax
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coordinax-0.12.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align='center'> coordinax </h1>
  <h2 align="center">Coordinates in JAX</h2>

  Coordinax enables calculations with coordinates in
  [JAX](https://jax.readthedocs.io/en/latest/). Built on
  [Equinox](https://docs.kidger.site/equinox/) and
  [Quax](https://github.com/patrick-kidger/quax).



  [![PyPI platforms][pypi-platforms]][pypi-link]
  [![PyPI version][pypi-version]][pypi-link]

  <!-- [![Conda-Forge][conda-badge]][conda-link] -->

  ```bash
  pip install coordinax
  ```



  [![Documentation Status][rtd-badge]][rtd-link]

  Coming soon. In the meantime, if you've used `astropy.coordinates`, then
  `coordinax` should be fairly intuitive.



  ```python
  import coordinax as cx
  import jax.numpy as jnp
  from unxt import Quantity

  q = cx.CartesianPos3D(
      x=Quantity(jnp.arange(0, 10.0), "km"),
      y=Quantity(jnp.arange(5, 15.0), "km"),
      z=Quantity(jnp.arange(10, 20.0), "km"),
  )
  print(q)







  q2 = cx.represent_as(q, cx.SphericalPos)
  print(q2)







  p = cx.CartesianVel3D(
      d_x=Quantity(jnp.arange(0, 10.0), "m/s"),
      d_y=Quantity(jnp.arange(5, 15.0), "m/s"),
      d_z=Quantity(jnp.arange(10, 20.0), "m/s"),
  )
  print(p)







  p2 = cx.represent_as(p, cx.SphericalVel, q)
  print(p2)






  ```



  [![DOI][zenodo-badge]][zenodo-link]

  If you found this library to be useful in academic work, then please cite.



  [![Actions Status][actions-badge]][actions-link]

  We welcome contributions!

  <!-- prettier-ignore-start -->
  [actions-badge]:            https://github.com/GalacticDynamics/coordinax/workflows/CI/badge.svg
  [actions-link]:             https://github.com/GalacticDynamics/coordinax/actions
  [conda-badge]:              https://img.shields.io/conda/vn/conda-forge/coordinax
  [conda-link]:               https://github.com/conda-forge/coordinax-feedstock
  [pypi-link]:                https://pypi.org/project/coordinax/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/coordinax
  [pypi-version]:             https://img.shields.io/pypi/v/coordinax
  [rtd-badge]:                https://readthedocs.org/projects/coordinax/badge/?version=latest
  [rtd-link]:                 https://coordinax.readthedocs.io/en/latest/?badge=latest
  [zenodo-badge]:             https://zenodo.org/badge/755708966.svg
  [zenodo-link]:              https://zenodo.org/doi/10.5281/zenodo.10850557

  <!-- prettier-ignore-end -->

rpm_license:
  Copyright 2024 Galactic Dynamics maintainers  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: 381a8b6cb6dde59a4ac53da84b63320a4000a164772bf56514f87711e167c108
name: python-coordinax
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Coordinates in JAX
url: https://github.com/GalacticDynamics/coordinax
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coordinax-0.14.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align='center'> coordinax </h1>
  <h2 align="center">Coordinates in JAX</h2>

  Coordinax enables calculations with coordinates in
  [JAX](https://jax.readthedocs.io/en/latest/). Built on
  [Equinox](https://docs.kidger.site/equinox/) and
  [Quax](https://github.com/patrick-kidger/quax).



  [![PyPI platforms][pypi-platforms]][pypi-link]
  [![PyPI version][pypi-version]][pypi-link]

  <!-- [![Conda-Forge][conda-badge]][conda-link] -->

  ```bash
  pip install coordinax
  ```



  [![Documentation Status][rtd-badge]][rtd-link]

  Coming soon. In the meantime, if you've used `astropy.coordinates`, then
  `coordinax` should be fairly intuitive.



  ```python
  import jax.numpy as jnp
  import unxt as u
  import coordinax as cx

  q = cx.CartesianPos3D(
      x=u.Quantity(jnp.arange(0, 10.0), "km"),
      y=u.Quantity(jnp.arange(5, 15.0), "km"),
      z=u.Quantity(jnp.arange(10, 20.0), "km"),
  )
  print(q)







  q2 = cx.represent_as(q, cx.SphericalPos)
  print(q2)







  p = cx.CartesianVel3D(
      d_x=u.Quantity(jnp.arange(0, 10.0), "m/s"),
      d_y=u.Quantity(jnp.arange(5, 15.0), "m/s"),
      d_z=u.Quantity(jnp.arange(10, 20.0), "m/s"),
  )
  print(p)







  p2 = cx.represent_as(p, cx.SphericalVel, q)
  print(p2)






  ```



  [![DOI][zenodo-badge]][zenodo-link]

  If you found this library to be useful in academic work, then please cite.



  [![Actions Status][actions-badge]][actions-link]

  We welcome contributions!

  <!-- prettier-ignore-start -->
  [actions-badge]:            https://github.com/GalacticDynamics/coordinax/workflows/CI/badge.svg
  [actions-link]:             https://github.com/GalacticDynamics/coordinax/actions
  [pypi-link]:                https://pypi.org/project/coordinax/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/coordinax
  [pypi-version]:             https://img.shields.io/pypi/v/coordinax
  [rtd-badge]:                https://readthedocs.org/projects/coordinax/badge/?version=latest
  [rtd-link]:                 https://coordinax.readthedocs.io/en/latest/?badge=latest
  [zenodo-badge]:             https://zenodo.org/badge/755708966.svg
  [zenodo-link]:              https://zenodo.org/doi/10.5281/zenodo.10850557

  <!-- prettier-ignore-end -->

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


pkgId: a2bbbc38fd2e70f95823e0d3b17cd5844d9092d0637dee943ae653189397050c
name: python-coordinax
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Coordinates in JAX
url: https://github.com/GalacticDynamics/coordinax
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coordinax-0.15.0-1.src.rpm
checksum_type: sha256
description:
  Coordinax enables calculations with coordinates in
  [JAX](https://jax.readthedocs.io/en/latest/). Built on
  [Equinox](https://docs.kidger.site/equinox/) and
  [Quax](https://github.com/patrick-kidger/quax).

  [![PyPI platforms][pypi-platforms]][pypi-link]
  [![PyPI version][pypi-version]][pypi-link]
  <!-- [![Conda-Forge][conda-badge]][conda-link] -->
  ```bash
  pip install coordinax
  ```

  [![Read The Docs](https://img.shields.io/badge/read_docs-here-orange)](https://unxt.readthedocs.io/en/)
  Coming soon. In the meantime, if you've used `astropy.coordinates`, then
  `coordinax` should be fairly intuitive.

  ```python
  import jax.numpy as jnp
  import unxt as u
  import coordinax as cx
  q = cx.CartesianPos3D(
      x=u.Quantity(jnp.arange(0, 10.0), "km"),
      y=u.Quantity(jnp.arange(5, 15.0), "km"),
      z=u.Quantity(jnp.arange(10, 20.0), "km"),
  )
  print(q)






  q2 = cx.represent_as(q, cx.SphericalPos)
  print(q2)






  p = cx.CartesianVel3D(
      d_x=u.Quantity(jnp.arange(0, 10.0), "m/s"),
      d_y=u.Quantity(jnp.arange(5, 15.0), "m/s"),
      d_z=u.Quantity(jnp.arange(10, 20.0), "m/s"),
  )
  print(p)






  p2 = cx.represent_as(p, cx.SphericalVel, q)
  print(p2)






  ```

  [![DOI][zenodo-badge]][zenodo-link]
  If you found this library to be useful in academic work, then please cite.

  [![Actions Status][actions-badge]][actions-link]
  [![Documentation Status][rtd-badge]][rtd-link]
  [![codecov][codecov-badge]][codecov-link]
  [![SPEC 0 — Minimum Supported Dependencies][spec0-badge]][spec0-link]
  [![pre-commit][pre-commit-badge]][pre-commit-link]
  [![ruff][ruff-badge]][ruff-link]
  We welcome contributions!
  <!-- prettier-ignore-start -->
  [actions-badge]:            https://github.com/GalacticDynamics/coordinax/workflows/CI/badge.svg
  [actions-link]:             https://github.com/GalacticDynamics/coordinax/actions
  [codecov-badge]:            https://codecov.io/gh/GalacticDynamics/unxt/graph/badge.svg
  [codecov-link]:             https://codecov.io/gh/GalacticDynamics/unxt
  [pre-commit-badge]:         https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit
  [pre-commit-link]:          https://pre-commit.com
  [pypi-link]:                https://pypi.org/project/coordinax/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/coordinax
  [pypi-version]:             https://img.shields.io/pypi/v/coordinax
  [rtd-badge]:                https://readthedocs.org/projects/coordinax/badge/?version=latest
  [rtd-link]:                 https://coordinax.readthedocs.io/en/latest/?badge=latest
  [ruff-badge]:               https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
  [ruff-link]:                https://docs.astral.sh/ruff/
  [spec0-badge]:              https://img.shields.io/badge/SPEC-0-green?labelColor=%23004811&color=%235CA038
  [spec0-link]:               https://scientific-python.org/specs/spec-0000/
  [zenodo-badge]:             https://zenodo.org/badge/755708966.svg
  [zenodo-link]:              https://zenodo.org/doi/10.5281/zenodo.10850557
  <!-- prettier-ignore-end -->

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


pkgId: 204ed1a49e523105610b00e36f748f9333c981cf773b32d5bb8a41a3fa74bee0
name: python-copasi-basico
arch: src
version: 0.80
epoch: 0
release: 1
summary: Simplified COPASI interface for python
url: https://github.com/copasi/basico
rpm_license: Artistic-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copasi-basico-0.80-1.src.rpm
checksum_type: sha256
description:
  ![Python package](https://github.com/copasi/basico/workflows/Python%20package/badge.svg) [![Documentation Status](https://readthedocs.org/projects/basico/badge/?version=latest)](https://basico.readthedocs.io/en/latest/?badge=latest) [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=copasi_basico&metric=alert_status)](https://sonarcloud.io/dashboard?id=copasi_basico) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/copasi/basico.git/HEAD?filepath=docs/notebooks/index.ipynb) [![DOI](https://zenodo.org/badge/148472105.svg)](https://zenodo.org/badge/latestdoi/148472105) [![codecov](https://codecov.io/gh/copasi/basico/branch/master/graph/badge.svg?token=MG54YU29JQ)](https://codecov.io/gh/copasi/basico) [![DOI](https://joss.theoj.org/papers/10.21105/joss.05553/status.svg)](https://doi.org/10.21105/joss.05553)



  This project hosts a simplified python interface to COPASI. While all functionality from COPASI
  is exposed via automatically generated SWIG wrappers, this package aims to add a layer on top of
  that, to hide most of the complexity away when calling COPASI functions.

  ![COPASI Logo](https://raw.githubusercontent.com/copasi/basico/master/./docs/_static/COPASI_Conly_176x176.png)


  The package works with python 3.7+, provided the following packages are installed:

  * python-copasi
  * pandas
  * numpy
  * matplotlib
  * PyYAML

  that are freely available on pypi, they will be automatically installed when installing via setup.py.

  Once done, just have the `basico` directory
  in the `PYTHONPATH` or `sys.path`.

  Or you could directly install everything you need right from pypi

      pip install copasi-basico

  from this git repo:

      pip install git+https://github.com/copasi/basico.git



  The following modules are available:

  * `model_io`: functionality, for creating / loading / saving models.
  * `model_info`: functionality to getting / setting model elements from pandas dataframes
  * `task_timecourse`: a wrapper for running time course simulations
  * `task_parameter_estimation`: a wrapper for parameter estimation
  * `task_optimization`: a wrapper for computing optimizations with arbitrary objective functions
  * `task_steadystate`: a wrapper for computing steady states
  * `task_scan`: a wrapper for parameter scans / repeats
  * `task_sensitivities`: a wrapper for computing sensitivities
  * `compartment_array_tools`: utility for plotting and the like

  Documentation is continually updated at: <https://basico.readthedocs.org/>.

  Please use the [issue tracker](https://github.com/copasi/basico/issues) for bug reports and feature requests.



  basico comes with a number of unit tests based on pytest. To run them, change to the
  root directory of this project and run:

      python3 -m pytest

  that will ensure that `basico` is in the python path, and the test run as expected. Some
  tests require more data, that is not included in the repository, such as tests for PEtab
  and petab select, for those, specify the environment variables to the directories where
  the files are for example:

      PETAB_BENCHMARK_MODELS=/path/to/petab/benchmark/models
      PETAB_SELECT_MODELS=/path/to/petab/select/models

  for example:

      PETAB_BENCHMARK_MODELS=../Benchmark-Models-PEtab/Benchmark-Models PETAB_SELECT_MODELS=../petab_select/test_cases  python3 -m pytest


  This project has been possible thanks to the BMBF funded de.NBI initiative (031L0104A):

  ![de.NBI logo](https://raw.githubusercontent.com/copasi/basico/master/./docs/_static/deNBI_logo.jpg)



  The packages available on this page are provided under the
  [Artistic License 2.0](http://copasi.org/Download/License/),
  which is an [OSI](http://www.opensource.org/) approved license. This license
  allows non-commercial and commercial use free of charge.


pkgId: b3af29c1706ed1cba83ac9d498f1ade2a5e63efb2b92b23f1ebb22491aedbda0
name: python-copepodTCR
arch: src
version: 0.2.12
epoch: 0
release: 1
summary: COmbinatorial PEptide POoling for TCR specificity
url: https://copepodtcr.readthedocs.io/en/latest/index.html
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copepodTCR-0.2.12-1.src.rpm
checksum_type: sha256
description:
  <span style="color:white"> </span>

  <span style="color:#015396">CopepodTCR</span> is a tool for the design of combinatorial peptide pooling schemes for TCR speficity assays.

  <span style="color:#015396">CopepodTCR</span> guides the user through all stages of the experiment design and interpetation:
  - selection of parameters for the experiment (**Balance check**)
  - examination of peptides (**Overlap check**)
  - generation of pooling scheme (**Pooling scheme**)
  - generation of punched cards of efficient peptide mixing (**STL files**)
  - results interpetation using hierarchical Bayesian model (**Interpretation**)



  Kovaleva V. A., et al. "copepodTCR: Identification of Antigen-Specific T Cell Receptors with combinatorial peptide pooling." bioRxiv (2023): 2023-11.

  Or use the following BibTeX entry:

  ```
  @article{
      kovaleva2023copepodtcr,
      title        = {copepodTCR: Identification of Antigen-Specific T Cell Receptors with combinatorial peptide pooling},
      author       = {Kovaleva, Vasilisa A and Pattinson, David J and Barton, Carl and Chapin, Sarah R and Minervina, Anastasia A and Richards, Katherine A and Sant, Andrea J and Thomas, Paul G and Pogorelyy, Mikhail V and Meyer, Hannah V},
      year         = 2023,
      journal      = {bioRxiv},
      publisher    = {Cold Spring Harbor Laboratory},
      pages        = {2023--11}
  }
  ```



  Identification of a cognate peptide for TCR of interest is crucial for biomedical research. Current computational efforts for TCR specificity did not produce reliable tool, so testing of large peptide libraries against a T cell bearing TCR of interest remains the main approach in the field.

  Testing each peptide against a TCR is reagent- and time-consuming. More efficient approach is peptide mixing in pools according to a combinatorial scheme. Each peptide is added to a unique subset of pools ("address"), which leads to matching activation patterns in T cells stimulated by combinatorial pools.

  Efficient combinatorial peptide pooling (CPP) scheme must implement:
  - use of overlapping peptide in the assay to cover the whole protein space;
  - error detection.

  Here, we present <span style="color:#015396">CopepodTCR</span> -- a tool for design of CPP schemes. CopepodTCR detects experimental errors and, coupled with a hierarchical Bayesian model for unbiased results interpretation, identifies the response-eliciting peptide for a TCR of interest out of hundreds of peptides tested using a simple experimental set-up.

  Detailed instructions please see at [copepodTCR.readthedocs](https://copepodtcr.readthedocs.io/en/latest/index.html). Also you can use [copepodTCR app](https://copepodtcr.cshl.edu/).




  The experimental setup starts with defining the protein/proteome of interest and obtaining synthetic peptides tiling its space.

  This set of peptides, containing an overlap of a constant length, is entered into copepodTCR. It creates a peptide pooling scheme and, optionally, provides the pipetting scheme to generate the desired pools as either 384-well plate layouts or punch card models which could be further 3D printed and overlay the physical plate or pipette tip box.

  Following this scheme, the peptides are mixed, and the resulting peptide pools tested in a T cell activation assay. The activation of T cells is measured for each peptide pool (experimental layout, activation assay, and experimental read out) with the assay of choice, such as flow cytometry- or microscopy-based activation assays detecting transcription and translation of a reporter gene.

  The experimental measurements for each pool are entered back into copepodTCR which employs a Bayesian mixture model to identify activated pools.  Based on the activation patterns, it returns the set of overlapping peptides leading to T cell activation (Results interpretation).



  For detailed description of the algorithm and its development refer to Kovaleva et al (2023).

  The Branch-and-Bound part of copepodTCR generates a peptide mixing scheme by optimizing the peptide distribution into a predefined number of pools. The distribution of each peptide is encoded into an address (edges in the graph), which connect nodes in the graph (circles) that represent a union between two addresses. The peptide mixing scheme constitutes the path through these unions and connecting addresses that ensure a balanced pool design.



  For detailed description of the model, refer to Kovaleva et al (2023).

  To accurately interpret results of T cell activation assay, copepodTCR utilizes a Bayesian mixture model.

  The model considers the activation signal to be drawn from two distinct distributions arising from the activated and non-activated pools and provides the probabilities that the value was drawn from either distribution as a criterion for pool classification.



  Can be installed with
  ```python
  pip install copepodTCR
  ```

  or
  ```python
  conda install -c vasilisa.kovaleva copepodTCR
  ```


  Required packages should be installed simulataneously with the copepodTCR packages.

  But if they were not, here is the list of requirements:
  ```python
      pip install "pandas>=1.5.3"
      pip install "numpy>=1.23.5"
      pip install "cvxpy>=1.3.2"
      pip install "trimesh>=3.23.5"
      pip install "trimesh>=3.23.5"
      pip install "pymc>=5.9.2"
      pip install "arviz>=0.16.1"
  ```


pkgId: 42221d38108d6bcaab1459c2c14a5ea69e8537ac600e9633a63e0289eacece9d
name: python-copernicus-marine-client
arch: src
version: 0.10.7
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/copernicus-marine-client/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copernicus-marine-client-0.10.7-1.src.rpm
checksum_type: sha256
description:
  ⚠️⚠️⚠️ The `coernicus-marine-client` PyPI package is deprecated. Please use `copernicusmarine` instead ⚠️⚠️⚠️

  Here is the link to the new pypi repository: [https://pypi.org/project/copernicusmarine/](https://pypi.org/project/copernicusmarine/)"
  Or install it using the following command: `pip install copernicusmarine`

  If you were using this deprecated version, you may also want to delete the following folders:

  - `~/.copernicus-marine-client`
  - `~/.cachier` (⚠️ Be carefull with this one as it can contains other stuffs unrelated to the `copernicus-marine-client` package !)



  The official version 1.0.0 of the package has been released and it has been decided to rename the package to `copernicusmarine`.
  That way, the command will always be the same, no matter what interface you are using (python or CLI).


pkgId: 4de8977d058c067aa3042f4dfbaa93df396728c209cf0c6c780d14d3943dc6b2
name: python-copernicusmarine
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/copernicusmarine/
rpm_license: EUPL-1.2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copernicusmarine-1.3.3-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Copernicus Marine Service Toolbox (CLI & Python)</h1>
  <div align="center">
    <a href="https://pypi.org/project/copernicusmarine/"><img src="https://img.shields.io/pypi/v/copernicusmarine.svg?style=flat-square" alt="PyPI" /></a>
    <a href="https://pypi.org/project/copernicusmarine/"><img src="https://img.shields.io/pypi/pyversions/copernicusmarine.svg?style=flat-square" alt="PyPI Supported Versions" /></a>
    <a href="https://pypi.org/project/copernicusmarine/"><img src="https://img.shields.io/badge/platform-windows | linux | macos-lightgrey?style=flat-square" alt="Supported Platforms" /></a>
    <a href="https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12"><img src="https://img.shields.io/badge/licence-EUPL-lightblue?style=flat-square" alt="Licence" /></a>
  </div>

  ![Copernicus Marine Service and Mercator Ocean international logos](https://www.mercator-ocean.eu/wp-content/uploads/2022/05/Cartouche_CMEMS_poisson_MOi.png)



  The `copernicusmarine` offers capabilities through both **Command Line Interface (CLI)** and **Python API**:

  - **Metadata Information**: List and retrieve metadata information on all variables, datasets, products, and their associated documentation.
  - **Subset Datasets**: Subset datasets to extract only the parts of interest, in preferred format, such as Analysis-Ready Cloud-Optimized (ARCO) Zarr or NetCDF file format.
  - **Advanced Filters**: Apply simple or advanced filters to get multiple files, in original formats like NetCDF/GeoTIFF, via direct Marine Data Store connections.
  - **No Quotas**: Enjoy no quotas, neither on volume size nor bandwidth.



  For installation, multiple options are available depending on your setup:



  A `conda` package is available on [Anaconda](https://anaconda.org/conda-forge/copernicusmarine).

  You can install it using `mamba` (or conda) through the `conda-forge` channel with the following command:

  ```bash
  mamba install conda-forge::copernicusmarine --yes
  ```

  To upgrade the Toolbox with mamba (or conda):

  ```bash
  mamba update --name copernicusmarine copernicusmarine --yes
  ```



  A docker image is also available here: [https://hub.docker.com/r/copernicusmarine/copernicusmarine](https://hub.docker.com/r/copernicusmarine/copernicusmarine)

  First step is to pull the container image:

  ```bash
  docker pull copernicusmarine/copernicusmarine:latest
  ```

  Then run it:

  ```bash
  docker run -it --rm copernicusmarine/copernicusmarine --version
  ```



  Otherwise, if you already have an environment (safer to clone it), the package can be installed using the `pip` command:

  ```bash
  python -m pip install copernicusmarine
  ```

  And to **upgrade the package** to the newest available version, run:

  ```bash
  python -m pip install copernicusmarine --upgrade
  ```



  For more comprehensive details on how to use the `copernicusmarine` Toolbox, please refer to our [Help Center](https://help.marine.copernicus.eu/en/collections/9080063-copernicus-marine-toolbox). It ensures a smooth migration for existing users of legacy services such as MOTU, OPeNDAP or FTP.





  Cachier library is used for caching part of the requests (as result of `describe` or `login`). By default, the cache will be located in the home folder. If you need to change the location of the cache, you can set the environment variable `COPERNICUSMARINE_CACHE_DIRECTORY` to point to the desired directory:

  - on **UNIX** platforms: `export COPERNICUSMARINE_CACHE_DIRECTORY=<PATH>`
  - on **Windows** platforms: `set COPERNICUSMARINE_CACHE_DIRECTORY=<PATH>`





  A global SSL context is used when making HTTP calls using the `copernicusmarine` Toolbox. For some reason, it can lead to unexpected behavior depending on your network configuration. You can set the `COPERNICUSMARINE_DISABLE_SSL_CONTEXT` environment variable to any value to globally disable the usage of SSL in the toolbox:

  - on **UNIX** platforms: `export COPERNICUSMARINE_DISABLE_SSL_CONTEXT=True`
  - on **Windows** platforms: `set COPERNICUSMARINE_DISABLE_SSL_CONTEXT=True`



  To do HTTP calls, the Copernicus Marine Toolbox uses two python libraries: requests and aiohttp. By default, those libraries will have `trust_env` values set to `True`. If you want to deactivate this, you can set `COPERNICUSMARINE_TRUST_ENV=False` (default `True`). This can be useful for example if you don't want those libraries to read your `.netrc` file as it has been reported that having a `.netrc` with a line: "default login anonymous password user@site" is incompatible with S3 connection required by the toolbox.



  To use proxies, as describe in the [aiohttp documentation](https://docs.aiohttp.org/en/stable/client_advanced.html#proxy-support) you can use two options:

  - set the `HTTPS_PROXY` variable. For eg: `HTTPS_PROXY="http://user:pass@some.proxy.com"`. It should work even with `COPERNICUSMARINE_TRUST_ENV=False`.
  - use a `.netrc` file but be aware that having a line: "default login anonymous password user@site" is incompatible with S3 connection required by the toolbox. Also note that if you have `COPERNICUSMARINE_TRUST_ENV=True` (the default value) then if `NETRC` environment variable is set with a specified location, the `.netrc` file will be read from the specified location there rather than from `~/.netrc`.



  The toolbox makes many requests to STAC to be able to parse the full marine data store STAC catalog. For that, it uses asynchronous calls. It can be problematic to do too many requests at the same time. To limit the number of requests at the same time you can use: `COPERNICUSMARINE_MAX_CONCURRENT_REQUESTS`. The default value is `15` and minimum value is `1`.

  Note, that this concerns only the catalog parsing step so the describe command and the start of the get and subset command. It does not apply when downloading files or listing files from the get command or when requesting the data chunks for the subset command.

  For the `get` command, you can use the `COPERNICUSMARINE_GET_CONCURRENT_DOWNLOADS` to set the number of threads open to download in parallel. There are no default value. By default the toolbox uses the python `multiprocessing.pool.ThreadPool`. You can set the environment variable to 0 if you don't want to use the `multiprocessing` library at all, the download will be used only through `boto3`.





  To discover commands and their available options, consider appending `--help` on any command line.

  Example:

  ```bash
  copernicusmarine --help
  ```

  Returns:

  ```bash
  Usage: copernicusmarine [OPTIONS] COMMAND [ARGS]...

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

  Commands:
    describe  Print Copernicus Marine catalog as JSON.
    get       Download originally produced data files.
    login     Create a configuration file with your Copernicus Marine credentials.
    subset    Download subsets of datasets as NetCDF files or Zarr stores.
  ```



  Retrieve metadata information about all products/datasets and display as JSON output:

  ```bash
  copernicusmarine describe --include-datasets
  ```

  The JSON output can also be saved as follows:

  ```bash
  copernicusmarine describe --include-datasets > all_datasets_copernicusmarine.json
  ```



  Create a single configuration file `.copernicusmarine-credentials` allowing to access all Copernicus Marine Data Store data services. By default, the file is saved in user's home directory.

  Example:

  ```bash
  > copernicusmarine login
  username : johndoe
  password :
  INFO - Configuration files stored in /Users/foo/.copernicusmarine
  ```

  If `.copernicusmarine-credentials` already exists, the user is asked for confirmation to overwrite (`--overwrite`/`--overwrite-configuration-file`).

  You can use the `--skip-if-user-logged-in` option to skip the configuration file overwrite if the user is already logged in.



  If you still have a configuration for legacy services (e.g. `~/motuclient/motuclient-python.ini`, `~/.netrc` or `~/_netrc`) in your home directory, it will automatically be taken into account with commands `get` and `subset` without the need for running the `login` command.
  If the configuration files are already available in another directory, when running commands `subset` or `get`, you can use the `--credentials-file` option to point to the files.



  Remotely subset a dataset, based on variable names, geographical and temporal parameters.

  Example:

  ```bash
  copernicusmarine subset --dataset-id cmems_mod_ibi_phy_my_0.083deg-3D_P1D-m --variable thetao --variable so --start-datetime 2021-01-01 --end-datetime 2021-01-03 --minimum-longitude 0.0 --maximum-longitude 0.1 --minimum-latitude 28.0 --maximum-latitude 28.1
  ```

  Returns:

  ```bash
  INFO - 2024-04-03T10:18:18Z - <xarray.Dataset> Size: 3kB
  Dimensions:    (depth: 50, latitude: 2, longitude: 1, time: 3)
  Coordinates:
    * depth      (depth) float32 200B 0.5058 1.556 2.668 ... 5.292e+03 5.698e+03
    * latitude   (latitude) float32 8B 28.0 28.08
    * longitude  (longitude) float32 4B 0.08333
    * time       (time) datetime64[ns] 24B 2021-01-01 2021-01-02 2021-01-03
  Data variables:
      thetao     (time, depth, latitude, longitude) float32 1kB dask.array<chunksize=(3, 1, 2, 1), meta=np.ndarray>
      so         (time, depth, latitude, longitude) float32 1kB dask.array<chunksize=(3, 1, 2, 1), meta=np.ndarray>
  Attributes: (12/20)
      Conventions:               CF-1.0
      bulletin_date:             2020-12-01
      ...                        ...
      references:                http://marine.copernicus.eu
      copernicusmarine_version:  1.1.0
  INFO - 2024-04-03T10:18:18Z - Estimated size of the dataset file is 0.002 MB.

  Do you want to proceed with download? [Y/n]:
  ```

  By default, after the display of the summary of the dataset subset, a download confirmation is asked. To skip this confirmation, use the option `--force-download`.



  By default, the `subset` feature uses the `nearest` method of xarray. By specifying `--subset-method strict`, you can only request dimension strictly inside the dataset, useful for **operational use-case**.



  Options `--minimum-longitude` and `--maximum-longitude` work as follows:

  - If the result of the substraction ( `--maximum-longitude` minus `--minimum-longitude` ) is superior or equal to 360, then return the full dataset.
  - If the requested longitude range:
    - **does not cross** the antemeridian, then return the dataset between range -180 and 180.
    - **does cross** the antemeridian, then return the dataset between range 0 and 360.

  Note that you can request any longitudes you want. A modulus is applied to bring the result between -180° and 360°. For example, if you request [530, 560], the result dataset will be in [170, 200].



  When subsetting data, if you decide to write your data as a NetCDF file (which is the default behavior), then you can provide the extra option `--netcdf-compression-enabled`. The downloaded file will be lighter but it will take more time to write it (because of the compression task). If you don't provide it, the task will be faster, but the file heavier.
  Otherwise, if you decide to write your data in Zarr format (`.zarr` extension), the original compression used in the Copernicus Marine Data Store will be applied, which means that the download task will be fast **and** the file compressed. In that case, you cannot use the `--netcdf-compression-enabled`.

  Here are the default parameters added to xarray in the background when using the option: `{'zlib': True, 'complevel': 1, 'contiguous': False, 'shuffle': True}`

  In addition to this option, you can also provide the `--netcdf-compression-level` option and customize the NetCDF compression level between 0 (no compression) and 9 (maximal compression).



  The `--netcdf3-compatible` option has been added to allow the downloaded dataset to be compatible with the netCDF3 format. It uses the `format="NETCDF3_CLASSIC"` of the xarray [to_netcdf](https://docs.xarray.dev/en/latest/generated/xarray.Dataset.to_netcdf.html) method.



  Download the dataset file(s) as originally produced, based on the datasetID or the path to files.

  Example:

  ```bash
  copernicusmarine get --dataset-id cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m --service original-files
  ```

  Returns:

  ```bash
  INFO - 2024-04-03T11:39:18Z - Dataset version was not specified, the latest one was selected: "202211"
  INFO - 2024-04-03T11:39:18Z - Dataset part was not specified, the first one was selected: "default"
  INFO - 2024-04-03T11:39:18Z - Service was not specified, the default one was selected: "original-files"
  INFO - 2024-04-03T11:39:18Z - Downloading using service original-files...
  INFO - 2024-04-03T11:39:19Z - You requested the download of the following files:
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_19930101_19931231_R20221101_RE01.nc - 8.83 MB - 2023-11-12T23:47:13Z
  [... truncated for brevity..]
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20120101_20121231_R20221101_RE01.nc - 8.62 MB - 2023-11-12T23:47:14Z
  Printed 20 out of 29 files

  Total size of the download: 252.94 MB
  Do you want to proceed with download? [Y/n]:
  ```

  By default:

  - After the header displays a summary of the request, a download confirmation is asked. To skip this user's action, add option `--force-download`.
  - Files are downloaded to the current directory applying the original folder structure. To avoid this behavior, add `--no-directories` and specify a destination with `-o/--output-directory`.

  Option `--show-outputnames` displays the full paths of the output files, if required.

  Option `--create-file-list` only creates a file containing the names of the targeted files instead of downloading them. You have to input a file name, e.g. `--create-file-list my_files.txt`. The format needs to be `.txt` or `.csv`:

  - If the user inputs a filename that ends in `.txt`, then the file contains only the full s3 path to the targeted files and is compatible with the `--file-list` option.

  Example:

  ```bash
  copernicusmarine get --dataset-id cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m --filter "*2021*" --create-file-list selected_files_for_2021.txt
  ```

  The content of `selected_files_for_2021.txt` would be:

  ```txt
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210101_20210131_R20230101_RE01.nc
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210201_20210228_R20230101_RE01.nc
  [... truncated for brevity..]
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20211101_20211130_R20230101_RE01.nc
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20211201_20211231_R20230101_RE01.nc
  ```

  - If the user inputs a filename that ends in `.csv` the file contains the following columns, separated by a comma: `filename`, `size` (in Bytes), `last_modified_datetime`, and `etag`. It is **not** compatible "as is" with the `--file-list` option and would need further post-processing from user's side.

  Example:

  ```bash
  copernicusmarine get --dataset-id cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m --filter "*2021*" --create-file-list selected_files_for_2021.csv
  ```

   The content of `selected_files_for_2021.csv` would be:

  ```txt
  filename,size,last_modified_datetime,etag
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210101_20210131_R20230101_RE01.nc,12295906,2023-11-12 23:47:05.466000+00:00,"e8a7e564f676a08bf601bcdeaebdc563"
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210201_20210228_R20230101_RE01.nc,12436177,2023-11-12 23:47:05.540000+00:00,"d4a22dfb6c7ed85860c4a122c45eb953"
  [... truncated for brevity..]
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20211101_20211130_R20230101_RE01.nc,12386940,2023-11-12 23:47:06.358000+00:00,"ea15d1f70fcc7f2ce404184d983530ff"
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20211201_20211231_R20230101_RE01.nc,12398208,2023-11-12 23:47:06.456000+00:00,"585f49867aaefa2ce9d6e68dd468b5e1"
  ```

  If specified, no other action will be performed.



  Option `--sync` allows to download original files only if not exist and not up to date. The Toolbox checks the destination folder against the source folder. It can be combined with filters. Note that if set with `--overwrite-output-data`, the latter will be ignored.
  The logic is largely inspired from [s5cmd package sync command](https://github.com/peak/s5cmd#sync).
  Option `--sync-delete` will work as `--sync` with the added fonctionnality that it deletes any local file that has not been found on the remote server. Note that the files found on the server are also filtered. Hence, a file present locally might be deleted even if it is on the server because, for example, the executed `get` command contains a filter that excludes this specific file.

  Limitations:

  - `--sync` is not compatible with `--no-directories`.
  - `--sync` only works with `--dataset-version`.
  - `--sync` functionality is not available for datasets with several parts (like INSITU or static datasets for example).



  Option `--filter` allows to specify a Unix shell-style wildcard pattern (see [fnmatch — Unix filename pattern matching](https://docs.python.org/3/library/fnmatch.html)) and select specific files:

  ```bash
  copernicusmarine get --dataset-id cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m --filter "*01yav_200[0-2]*"
  ```

  Returns:

  ```bash
  INFO - 2024-04-03T11:51:15Z - Dataset version was not specified, the latest one was selected: "202211"
  INFO - 2024-04-03T11:51:15Z - Dataset part was not specified, the first one was selected: "default"
  INFO - 2024-04-03T11:51:15Z - Service was not specified, the default one was selected: "original-files"
  INFO - 2024-04-03T11:51:15Z - Downloading using service original-files...
  INFO - 2024-04-03T11:51:17Z - You requested the download of the following files:
  s3://mdl-native/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20000101_20001231_R20221101_RE01.nc - 8.93 MB
  s3://mdl-native/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20010101_20011231_R20221101_RE01.nc - 8.91 MB
  s3://mdl-native/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20020101_20021231_R20221101_RE01.nc - 8.75 MB

  Total size of the download: 26.59 MB
  Do you want to proceed with download? [Y/n]:
  ```

  Option `--regex` allows to specify a regular expression for more advanced files selection:

  ```bash
  copernicusmarine get -i cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m --regex ".*01yav_20(00|01|02).*.nc"
  ```

  Returns:

  ```bash
  INFO - 2024-04-03T11:52:43Z - Dataset version was not specified, the latest one was selected: "202211"
  INFO - 2024-04-03T11:52:43Z - Dataset part was not specified, the first one was selected: "default"
  INFO - 2024-04-03T11:52:43Z - Service was not specified, the default one was selected: "original-files"
  INFO - 2024-04-03T11:52:43Z - Downloading using service original-files...
  INFO - 2024-04-03T11:52:44Z - You requested the download of the following files:
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20000101_20001231_R20221101_RE01.nc - 8.93 MB - 2023-11-12T23:47:13Z
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20010101_20011231_R20221101_RE01.nc - 8.91 MB - 2023-11-12T23:47:13Z
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20020101_20021231_R20221101_RE01.nc - 8.75 MB - 2023-11-12T23:47:13Z

  Total size of the download: 26.59 MB
  Do you want to proceed with download? [Y/n]:
  ```



  Option `--file-list` allows to specify a list of files for more advanced files selection.
  The file can contain complete absolute paths for each target file (default behavior) or only a partial path defined by the user, as shown below.

  By default, the get functionality lists all the files on the bucket to be able to select the requested ones. This create some overhead when there are a lot of files for a specific dataset. For example, a dataset with more than 100 000 files would create an overhead of around two minutes. The file list option will directly download the files and avoid the listings if all the files listed are found.

  Careful, a path can easily be mispelled or wrongly queried. The toolbox will display a warning if the file is not found on the bucket and try to find the file by listing all the files on the bucket.

  Example of `file_list.txt` with paths that would be directly downloaded without the listing overhead:

  ```txt

  > s3://mdl-native-01/native/INSITU_GLO_PHYBGCWAV_DISCRETE_MYNRT_013_030/cmems_obs-ins_glo_phybgcwav_mynrt_na_irr_202311/history/BO/AR_PR_BO_58JM.nc
  > INSITU_GLO_PHYBGCWAV_DISCRETE_MYNRT_013_030/cmems_obs-ins_glo_phybgcwav_mynrt_na_irr_202311/history/BO/AR_PR_BO_58JM.nc
  > cmems_obs-ins_glo_phybgcwav_mynrt_na_irr_202311/history/BO/AR_PR_BO_58JM.nc
  > history/BO/AR_PR_BO_58JM.nc
  > index_history.txt



  > INSITU_GLO_PHYBGCWAV_DISCRETE_MYNRT_013_030/cmems_obs-ins_glo_phybgcwav_mynrt_na_irr/history/BO/AR_PR_BO_58JM.nc

  > AR_PR_BO_58JM.nc

  > another_dataset/history/BO/AR_PR_BO_58JM.nc
  ```


  Example of `file_list.txt` with absolute paths:

  ```txt
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210101_20210131_R20230101_RE01.nc
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210201_20210228_R20230101_RE01.nc
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210301_20210331_R20230101_RE01.nc
  ```

  Note that a path to a file can be seen in 3 parts:

  - the provenance that indicates in which bucket the data is. For example, `s3://mdl-native-10/`. It can be found in the metadata.
  - the productID and datasetID. For example, `IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1M-m_202012/`. It also contains the version when the dataset has one.
  - the filename which is everything that comes after the dataset id. For example, `2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210301_20210331_R20230101_RE01.nc`. It should be considered like a filename. If any components are absent, the file name is not complete and the file cannot be directly downloaded. Thus a listing of all the files is necessary in order to download the file. For example, `2021/CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210301_20210331_R20230101_RE01.nc` is a filename and `CMEMS_v5r1_IBI_PHY_MY_PdE_01mav_20210301_20210331_R20230101_RE01.nc` is an incomplete filename.

  > **_NOTE:_** This option is compatible with the file generated by the `--create-file-list` option if you generated a ".txt" file.

  Then the following command:

  ```bash
  copernicusmarine get -i cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m --file-list file_list.txt
  ```

  Returns:

  ```bash
  INFO - 2024-04-03T12:57:44Z - Dataset version was not specified, the latest one was selected: "202211"
  INFO - 2024-04-03T12:57:44Z - Dataset part was not specified, the first one was selected: "default"
  INFO - 2024-04-03T12:57:44Z - Service was not specified, the default one was selected: "original-files"
  INFO - 2024-04-03T12:57:44Z - Downloading using service original-files...
  INFO - 2024-04-03T12:57:45Z - You requested the download of the following files:
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20000101_20001231_R20221101_RE01.nc - 8.93 MB - 2023-11-12T23:47:13Z
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20010101_20011231_R20221101_RE01.nc - 8.91 MB - 2023-11-12T23:47:13Z
  s3://mdl-native-10/native/IBI_MULTIYEAR_PHY_005_002/cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m_202211/CMEMS_v5r1_IBI_PHY_MY_NL_01yav_20020101_20021231_R20221101_RE01.nc - 8.75 MB - 2023-11-12T23:47:13Z

  Total size of the download: 26.59 MB
  Do you want to proceed with download? [Y/n]:
  ```

  Also, there is a specific command `--index-parts` to retrieve the index files of INSITU datasets (as listed on the [Copernicus Marine File Browser](https://data.marine.copernicus.eu/product/INSITU_BLK_PHYBGCWAV_DISCRETE_MYNRT_013_034/files?subdataset=cmems_obs-ins_blk_phybgcwav_mynrt_na_irr_202311--ext--history&path=INSITU_BLK_PHYBGCWAV_DISCRETE_MYNRT_013_034%2Fcmems_obs-ins_blk_phybgcwav_mynrt_na_irr_202311%2F)).
  > **_NOTE:_** In the future, it is planned to have the index files for those datasets directly available through the `--filter`, `--regex` and/or `--file-list` options. Meanwhile, check this [Help Center article for a working example](https://help.marine.copernicus.eu/en/articles/9133855-how-to-download-insitu-data-using-index-files).

  Then the following command:

  ```bash
  copernicusmarine get --dataset-id cmems_obs-ins_blk_phybgcwav_mynrt_na_irr --index-parts
  ```

  Returns:

  ```txt
  INFO - 2024-04-03T12:58:40Z - Dataset version was not specified, the latest one was selected: "202311"
  INFO - 2024-04-03T12:58:40Z - Dataset part was not specified, the first one was selected: "history"
  INFO - 2024-04-03T12:58:40Z - You forced selection of service: original-files
  INFO - 2024-04-03T12:58:40Z - Downloading using service original-files...
  INFO - 2024-04-03T12:58:41Z - You requested the download of the following files:
  s3://mdl-native-08/native/INSITU_BLK_PHYBGCWAV_DISCRETE_MYNRT_013_034/cmems_obs-ins_blk_phybgcwav_mynrt_na_irr_202311/index_history.txt - 333.13 kB - 2024-04-02T08:40:30Z
  s3://mdl-native-08/native/INSITU_BLK_PHYBGCWAV_DISCRETE_MYNRT_013_034/cmems_obs-ins_blk_phybgcwav_mynrt_na_irr_202311/index_latest.txt - 466.38 kB - 2024-04-03T12:51:52Z
  s3://mdl-native-08/native/INSITU_BLK_PHYBGCWAV_DISCRETE_MYNRT_013_034/cmems_obs-ins_blk_phybgcwav_mynrt_na_irr_202311/index_monthly.txt - 1.51 MB - 2024-03-05T18:09:43Z
  s3://mdl-native-08/native/INSITU_BLK_PHYBGCWAV_DISCRETE_MYNRT_013_034/cmems_obs-ins_blk_phybgcwav_mynrt_na_irr_202311/index_platform.txt - 209.27 kB - 2024-04-03T08:33:37Z

  Total size of the download: 2.52 MB
  Do you want to proceed with download? [Y/n]:
  ```



  Both `subset` and `get` commands provide these options:



  When specified, the existing files will be overwritten.
  Otherwise, if the files already exist on destination, new ones with a unique index will be created once the download has been accepted (or once `--force-download` is provided).



  Option to create a file in your current directory containing request parameters. If specified, no other action will be performed.
  It will create the following files depending on the feature:

  - `subset`

  Example:

  ```bash
  copernicusmarine subset --create-template
  ```

  Returns:

  ```txt
  INFO - 2024-04-04T14:38:09Z - Template created at: subset_template.json
  ```

  - `get`
  Example:

  ```bash
  copernicusmarine get --create-template
  ```

  Returns:

  ```txt
  INFO - 2024-04-04T14:38:09Z - Template created at: get_template.json
  ```



  This option allows to specify request parameters but in a provided `.json` file, useful for batch processing.
  You can try the following templates or use the `--create-template` option to create both `subset` or `get` template request files.

  - Template for `subset` data request:

  ```json
  {
      "dataset_id": "cmems_mod_glo_phy-thetao_anfc_0.083deg_P1D-m",
      "start_datetime": "2022-04-11",
      "end_datetime": "2023-08-11",
      "minimum_longitude": -182.79,
      "maximum_longitude": -179.69,
      "minimum_latitude": -40,
      "maximum_latitude": -36,
      "minimum_depth": 0,
      "maximum_depth": 0,
      "variables": ["thetao"],
      "output_directory": "./data/",
      "force_download": true
  }
  ```

  Example:

  ```bash
  copernicusmarine subset --request-file template_subset_data_request.json
  ```

  - Template for `get` data request:

  ```json
  {
      "dataset_id": "cmems_mod_ibi_phy_my_0.083deg-3D_P1Y-m",
      "filter": "*01yav_200[0-2]*",
      "force_download": false,
      "log_level": "INFO",
      "no_directories": false,
      "no_metadata_cache": false,
      "output_directory": "./data/",
      "overwrite_output_data": false,
      "overwrite_metadata_cache": false,
      "show_outputnames": true
  }
  ```

  Example:

  ```bash
  copernicusmarine get --request-file template_get_data_request.json
  ```



  You can use the `--credentials-file` option to point to a credentials file. The file can be either `.copernicusmarine-credentials`, `motuclient-python.ini`, `.netrc` or `_netrc`.



  You can use the `--dataset-version` option to fetch a specific dataset version. Particularly useful to keep an operational chain working when an evolution impact the chosen dataset.



  You can use the `--dataset-part` option to fecth a specific part for the chosen dataset version.



  Set the details printed to console by the command (based on standard logging library).
  Available values are: `[DEBUG|INFO|WARN|ERROR|CRITICAL|QUIET]`

  All logs of the library are by default logged in stderr except the output of the `describe` command and the output of `--show-outputnames` option that are sent to stdout.

  _For versions <=1.2.4_, all logs are sent to stdout by default.



  The `copernicusmarine` exposes a Python interface to allow you to [call commands as functions](https://help.marine.copernicus.eu/en/collections/9054839-main-functionalities).



  A detailed standalone API documentation is under construction and will come at a later stage. For the moment, see the [Help Center](https://help.marine.copernicus.eu/en/collections/9080063-copernicus-marine-toolbox).



  We are using semantic versioning X.Y.Z → for example 1.0.2

  - Z is bumped on minor non-breaking changes.
  - Y is bumped on breaking changes.
  - X is bumped on demand to highlight a new significant feature or for communication purposes (new Copernicus Marine Service release for example).



  We welcome contributions from the community to enhance this package. If you find any issues or have suggestions for improvements, please check out our [Report Template](https://help.marine.copernicus.eu/en/articles/8218546-reporting-an-issue-or-feature-request).



  To keep up to date with the most recent and planned advancements, including revisions, corrections, and feature requests generated from users' feedback, please refer to our [Roadmap](https://help.marine.copernicus.eu/en/articles/8218641-next-milestones-and-roadmap).



  Get in touch!

  - Create your [Copernicus Marine Account](https://data.marine.copernicus.eu/register?redirect=%2Fproducts)
  - [Log in](https://data.marine.copernicus.eu/login?redirect=%2Fproducts) and chat with us (bottom right corner of [Copernicus Marine Service](https://marine.copernicus.eu/))
  - Join our [training workshops](https://marine.copernicus.eu/services/user-learning-services)
  - Network y/our [Copernicus Stories](https://twitter.com/cmems_eu)
  - Watch [our videos](https://www.youtube.com/channel/UC71ceOVy7WtVC7F04BKoEew)



  Licensed under the [EUPL](https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12)


pkgId: bcba45d3a20eb2ca995374e5721107d2203b399173e4a49c41ad6d70884fa904
name: python-copick
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Definitions for a collaborative cryoET annotation tool.
url: https://pypi.org/project/copick/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copick-0.7.0-1.src.rpm
checksum_type: sha256
description:
  **copick** is a cross-platform, storage-agnostic and server-less dataset API for cryoET datasets. Access to the data is
  provided through an object-oriented API that abstracts away the underlying storage using the
  [fsspec](https://filesystem-spec.readthedocs.io/en/latest/)-family of libraries.



  - **storage-agnostic**: Access data on local or shared filesystems, via SSH or on the cloud with the same API. No
      need for your own boilerplate!
  - **cloud-ready**: Access image data quickly and in parallel thanks to multiscale OME-Zarr!
  - **server-less**: No need for a dedicated server or database to access your data, just point **copick** to your data
      and go!
  - **cross-platform**: **copick** works on any platform that supports Python. Compute on Linux, visualize on Windows or
      Mac, all with the same dataset API!
  - **ecosystem**: Using the **copick** API allows visualizing and curating data in ChimeraX and Napari right away!



  For more information, see the [documentation](https://copick.github.io/copick/).



  copick can be installed using pip. Using the `all` extra installs necessary requirements for all tested filesystem
  implementations from the fsspec family (`local`, `s3fs`, `smb`, `sshfs`). Separate `s3`, `smb`, and `ssh` extras are available.

  ```shell
  pip install "copick[all]"
  ```



  An example dataset can be obtained from [Zenodo](https://doi.org/10.5281/zenodo.11238625).

  To test with the example dataset:

  1. Download and unpack the example dataset
  2. Add the location of the `sample_project`-directory in the unpacked dataset to `filesystem_overlay_only.json`
      ```json
      {
          "name": "test",
          "description": "A test project.",
          "version": "1.0.0",

          "pickable_objects": [
              {
                  "name": "proteasome",
                  "is_particle": true,
                  "pdb_id": "3J9I",
                  "label": 1,
                  "color": [255, 0, 0, 255],
                  "radius": 60,
                  "map_threshold": 0.0418
              },
              {
                  "name": "ribosome",
                  "is_particle": true,
                  "pdb_id": "7P6Z",
                  "label": 2,
                  "color": [0, 255, 0, 255],
                  "radius": 150,
                  "map_threshold": 0.037

              },
              {
                  "name": "membrane",
                  "is_particle": false,
                  "label": 3,
                  "color": [0, 0, 0, 255]
              }
          ],

          // Change this path to the location of sample_project
          "overlay_root": "local:///PATH/TO/EXTRACTED/PROJECT/",

          "overlay_fs_args": {
              "auto_mkdir": true
          }
      }
      ```

  3. Start copick with the configuration file

      ```python
      from copick.impl.filesystem import CopickRootFSSpec
      root = CopickRootFSSpec.from_file('path/to/filesystem_overlay_only.json')
      ```

  4. Access the data using the copick API

      ```python
      import zarr

      from copick.impl.filesystem import CopickRootFSSpec
      root = CopickRootFSSpec.from_file('path/to/filesystem_overlay_only.json')

      
      run = root.get_run("TS_001")

       
      tomogram = run.get_voxel_spacing(10).get_tomogram("wbp")

      
      group = zarr.open(tomogram.zarr())
      arrays = list(group.arrays())
      _, array = arrays[0]
      ```



  This project adheres to the Contributor Covenant [code of conduct](https://github.com/chanzuckerberg/.github/blob/main/CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to [opensource@chanzuckerberg.com](mailto:opensource@chanzuckerberg.com).



  If you believe you have found a security issue, please responsibly disclose by contacting us at [security@chanzuckerberg.com](mailto:security@chanzuckerberg.com).

rpm_license:
  MIT License  Copyright (c) 2024 Utz Ermel  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: c7755484d150426ec3f61275dad19648a78f7e360ba2c826cae6e639e26309db
name: python-copier
arch: src
version: 9.3.1
epoch: 0
release: 1
summary: A library for rendering project templates.
url: https://github.com/copier-org/copier
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copier-9.3.1-1.src.rpm
checksum_type: sha256
description:
  [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json)](https://github.com/copier-org/copier)
  [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/copier-org/copier)
  [![codecov](https://codecov.io/gh/copier-org/copier/branch/master/graph/badge.svg)](https://codecov.io/gh/copier-org/copier)
  [![CI](https://github.com/copier-org/copier/workflows/CI/badge.svg)](https://github.com/copier-org/copier/actions?query=branch%3Amaster)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  ![Python](https://img.shields.io/pypi/pyversions/copier?logo=python&logoColor=%23959DA5)
  [![PyPI](https://img.shields.io/pypi/v/copier?logo=pypi&logoColor=%23959DA5)](https://pypi.org/project/copier/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Documentation Status](https://img.shields.io/readthedocs/copier/latest?logo=readthedocs)](https://copier.readthedocs.io/en/latest)

  A library and CLI app for rendering project templates.

  -   Works with **local** paths and **Git URLs**.
  -   Your project can include any file and Copier can dynamically replace values in any
      kind of text file.
  -   It generates a beautiful output and takes care of not overwriting existing files
      unless instructed to do so.

  ![Sample output](https://github.com/copier-org/copier/raw/master/img/copier-output.png)



  1. Install Python 3.8 or newer.
  1. Install Git 2.27 or newer.
  1. To use as a CLI app: `pipx install copier`
  1. To use as a library: `pip install copier` or `conda install -c conda-forge copier`



  To install latest Copier release with 100% reproducibility:

  ```shell
  nix profile install 'https://flakehub.com/f/copier-org/copier/*.tar.gz'
  ```



  To create a template:

  ```shell
  📁 my_copier_template                        # your template project
  ├── 📄 copier.yml                            # your template configuration
  ├── 📁 .git/                                 # your template is a Git repository
  ├── 📁 {{project_name}}                      # a folder with a templated name
  │   └── 📄 {{module_name}}.py.jinja          # a file with a templated name
  └── 📄 {{_copier_conf.answers_file}}.jinja   # answers are recorded here
  ```

  ```yaml title="copier.yml"

  project_name:
      type: str
      help: What is your project name?

  module_name:
      type: str
      help: What is your Python module name?
  ```

  ```python+jinja title="{{project_name}}/{{module_name}}.py.jinja"
  print("Hello from {{module_name}}!")
  ```

  ```yaml+jinja title="{{_copier_conf.answers_file}}.jinja"

  {{ _copier_answers|to_nice_yaml -}}
  ```

  To generate a project from the template:

  -   On the command-line:

      ```shell
      copier copy path/to/project/template path/to/destination
      ```

  -   Or in Python code, programmatically:

      ```python
      from copier import run_copy

      
      run_copy("path/to/project/template", "path/to/destination")

      
      run_copy("https://github.com/copier-org/copier.git", "path/to/destination")

      
      run_copy("gh:copier-org/copier.git", "path/to/destination")

      
      run_copy("gl:copier-org/copier.git", "path/to/destination")
      ```



  Copier is composed of these main concepts:

  1. **Templates**. They lay out how to generate the subproject.
  1. **Questionnaires**. They are configured in the template. Answers are used to generate
     projects.
  1. **Projects**. This is where your real program lives. But it is usually generated
     and/or updated from a template.

  Copier targets these main human audiences:

  1.  **Template creators**. Programmers that repeat code too much and prefer a tool to do
      it for them.

      **_Tip:_** Copier doesn't replace the DRY principle... but sometimes you simply
      can't be DRY and you need a DRYing machine...

  1.  **Template consumers**. Programmers that want to start a new project quickly, or
      that want to evolve it comfortably.

  Non-humans should be happy also by using Copier's CLI or API, as long as their
  expectations are the same as for those humans... and as long as they have feelings.

  Templates have these goals:

  1. **[Code scaffolding](<https://en.wikipedia.org/wiki/Scaffold_(programming)>)**. Help
     consumers have a working source code tree as quickly as possible. All templates allow
     scaffolding.
  1. **Code lifecycle management**. When the template evolves, let consumers update their
     projects. Not all templates allow updating.

  Copier tries to have a smooth learning curve that lets you create simple templates that
  can evolve into complex ones as needed.



  You can browse public Copier templates on GitHub using
  [the `copier-template` topic](https://github.com/topics/copier-template). Use them as
  inspiration!

  If you want your template to appear in that list, just add the topic to it! 🏷



  If you're using Copier, consider adding the Copier badge to your project's `README.md`:

  ```md
  [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-orange.json)](https://github.com/copier-org/copier)
  ```

  ...or `README.rst`:

  ```rst
  .. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-orange.json
      :target: https://github.com/copier-org/copier
      :alt: Copier
  ```

  ...or, as HTML:

  <!-- prettier-ignore-start -->
  ```html
  <a href="https://github.com/copier-org/copier"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-orange.json" alt="Copier" style="max-width:100%;"/></a>
  ```
  <!-- prettier-ignore-end -->



  1. Badge Grayscale Border
     [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-border.json)](https://github.com/copier-org/copier)

  1. Badge Grayscale Inverted Border
     [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border.json)](https://github.com/copier-org/copier)

  1. Badge Grayscale Inverted Border Orange
     [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-orange.json)](https://github.com/copier-org/copier)

  1. Badge Grayscale Inverted Border Red
     [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-red.json)](https://github.com/copier-org/copier)

  1. Badge Grayscale Inverted Border Teal
     [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-teal.json)](https://github.com/copier-org/copier)

  1. Badge Grayscale Inverted Border Purple
     [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json)](https://github.com/copier-org/copier)

  1. Badge Black
     [![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-black.json)](https://github.com/copier-org/copier)



  Special thanks go to [jpsca](https://github.com/jpsca) for originally creating `Copier`.
  This project would not be a thing without him.

  Many thanks to [pykong](https://github.com/pykong) who took over maintainership on the
  project, promoted it, and laid out the bases of what the project is today.

  Big thanks also go to [yajo](https://github.com/yajo) for his relentless zest for
  improving `Copier` even further.

  Thanks a lot, [pawamoy](https://github.com/pawamoy) for polishing very important rough
  edges and improving the documentation and UX a lot.

  Also special thanks to [sisp](https://github.com/sisp) for being very helpful in
  polishing documentation, fixing bugs, helping the community and cleaning up the
  codebase.

  And thanks to all financial supporters and folks that give us a shiny star! ⭐

  <a href="https://star-history.com/#copier-org/copier&Date">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=copier-org/copier&type=Date&theme=dark" />
      <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=copier-org/copier&type=Date" />
      <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=copier-org/copier&type=Date" />
    </picture>
  </a>


pkgId: ede83ffbfcc87e893986dda7d171e96734905306fdf9d21e8841740201daa9ef
name: python-copier_template_tester
arch: src
version: 2.1.3
epoch: 0
release: 1
summary: Test copier templates
url: https://github.com/kyleking/copier-template-tester
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copier_template_tester-2.1.3-1.src.rpm
checksum_type: sha256
description:
  ![./ctt-logo.png](./ctt-logo.png)

  Parametrize copier templates to test for syntax errors, check the expected output, and to check against copier versions.

  Note that `ctt` only tests the `copier copy` operation and doesn't check the `update` behavior and any version-specific logic that your template may contain because of how quickly those tests become complex.





  When creating a copier template repository, I recommend following the nested ["subdirectory" approach](https://copier.readthedocs.io/en/latest/configuring/#subdirectory) so that the directory looks like this:

  ```sh
  └── template_dir
  │   └── {{ _copier_conf.answers_file }}.jinja
  ├── README.md
  ├── copier.yml
  └── ctt.toml
  ```

  Create a new `ctt.toml` file in the top-level directory of your copier repository. Populate the file to look like the below example.

  ```toml


  [defaults]
  project_name = "placeholder"
  copyright_year = 2022


  [output.".ctt/defaults"]

  [output.".ctt/no_all"]
  package_name = "testing-no-all"
  include_all = false
  ```



  First, add this section to your `.pre-commit-config.yml` file:

  ```yaml
  repos:
    - repo: https://github.com/KyleKing/copier-template-tester
      rev: main
      hooks:
        - id: copier-template-tester
  ```

  Install and update to the latest revision:

  ```sh
  pre-commit autoupdate
  ```

  The run with `pre-commit`:

  ```sh
  pre-commit run --all-files copier-template-tester
  ```



  You can also try `ctt` as a CLI tool by installing with `pipx`:

  ```sh
  pipx install copier-template-tester

  cd ~/your/copier/project
  ctt
  ```



  For more example code, see the [scripts] directory or the [tests].



  See the `Open Issues` and/or the [CODE_TAG_SUMMARY]. For release history, see the [CHANGELOG].



  We welcome pull requests! For your pull request to be accepted smoothly, we suggest that you first open a GitHub issue to discuss your idea. For resources on getting started with the code base, see the below documentation:

  - [DEVELOPER_GUIDE]
  - [STYLE_GUIDE]



  We follow the [Contributor Covenant Code of Conduct][contributor-covenant].



  We try to reasonably meet most aspects of the "OpenSSF scorecard" from [Open Source Insights](https://deps.dev/pypi/copier-template-tester)



  If you have any security issue to report, please contact the project maintainers privately. You can reach us at [dev.act.kyle@gmail.com](mailto:dev.act.kyle@gmail.com).



  [LICENSE]

  [changelog]: https://copier-template-tester.kyleking.me/docs/CHANGELOG
  [code_tag_summary]: https://copier-template-tester.kyleking.me/docs/CODE_TAG_SUMMARY
  [contributor-covenant]: https://www.contributor-covenant.org
  [developer_guide]: https://copier-template-tester.kyleking.me/docs/DEVELOPER_GUIDE
  [license]: https://github.com/kyleking/copier-template-tester/blob/main/LICENSE
  [scripts]: https://github.com/kyleking/copier-template-tester/blob/main/scripts
  [style_guide]: https://copier-template-tester.kyleking.me/docs/STYLE_GUIDE
  [tests]: https://github.com/kyleking/copier-template-tester/blob/main/tests


pkgId: ae0b32f7eb049147af47dd7e336f6a9b7c395634623d81785336a302159c734f
name: python-copilot-api
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: An unofficial Python API wrapper for Microsoft Copilot
url: https://github.com/OE-LUCIFER/copilot-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copilot-api-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <sub>Built with ❤️ by <a href="https://github.com/OE-LUCIFER">OEvortex</a></sub>
  </div>


pkgId: 4d00a53227a7501178c88271fbde2a78e3db7b2cab2d0a96b865a41893b9cb17
name: python-copious
arch: src
version: 0.1.24
epoch: 0
release: 1
summary: A handy tool that make your day to day programming much easier.
url: https://gitlab.com/rlan/copious
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copious-0.1.24-1.src.rpm
checksum_type: sha256
description:
  A handy tool that make your day to day programming much easier.

  The name comes from the latin word cornucopia.


pkgId: 8e157f6c6426fd9e16fdf3a2b7bbb5b291447ae507c968cc0f14b4b0f2675cbc
name: python-coplin-db2
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Um módulo de conveniência para manipulação de bancos de dados IBM DB2 em Python.
url: https://github.com/COPLIN-UFSM/db2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coplin-db2-2.1.2-1.src.rpm
checksum_type: sha256
description:
  A biblioteca coplin-db2 é um módulo de conveniência para acessar bancos de dados do tipo IBM DB2, desenvolvido pela
  Coordenadoria de Planejamento Informacional da UFSM (COPLIN).

  Com esta biblioteca, é possível definir um arquivo com credenciais de acesso ao banco de dados, no formato `json`, que
  podem ser utilizadas posteriormente:

  Arquivo `credentials.json`:

  ```json
  {
    "user": "nome_de_usuário",
    "password": "sua_senha_aqui",
    "host": "URL_do_host",
    "port": 50000,
    "database": "nome_do_banco"
  }
  ```

  Arquivo `db2_schema.sql`:

  ```sql
  CREATE TABLE USERS_TEST_IBMDB2(
      ID INTEGER NOT NULL PRIMARY KEY,
      NAME VARCHAR(10) NOT NULL,
      AGE INTEGER NOT NULL
  );

  INSERT INTO USERS_TEST_IBMDB2(ID, NAME, AGE) VALUES (1, 'HENRY', 32);
  INSERT INTO USERS_TEST_IBMDB2(ID, NAME, AGE) VALUES (2, 'JOHN', 20);

  ```

  Arquivo `main.py`:

  ```python
  import os
  from db2 import DB2Connection


  credentials = 'credentials.json'

  with DB2Connection(credentials) as db2_conn:
      db2_conn.create_tables('db2_schema.sql')
      query_str = '''
          SELECT *
          FROM USERS_TEST_IBMDB2;
       '''
      df = db2_conn.query_to_dataframe(query_str)

      print(df)

      
      
  ```

  A saída esperada deve ser:

  ```bash
     ID   NAME  AGE
  0   1  HENRY   32
  1   2   JOHN   20
  ```



  Para instalar o pacote pelo pip, digite o seguinte comando:

  ```bash
  pip install coplin-db2
  ```



  A documentação está disponível em https://coplin-ufsm.github.io/db2



  Para instruções de desenvolvimento do pacote, consulte [este arquivo](https://github.com/COPLIN-UFSM/db2/blob/main/DEVELOPMENT.md).



  Biblioteca desenvolvida originalmente por Henry Cagnini: [henry.cagnini@ufsm.br]()

  Caso encontre algum problema no uso, abra um issue no [repositório da biblioteca](https://github.com/COPLIN-UFSM/db2).

  Pull requests são bem-vindos!


pkgId: c4bf0ee8e3c4c6bc9fb3b670091003a925693375dd622b91ccb516d8a3ef480c
name: python-coppeliasim-zmqremoteapi-client
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: Client for the CoppeliaSim's zmqRemoteApi (protocol version 2)
url: https://github.com/CoppeliaRobotics/zmqRemoteApi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coppeliasim-zmqremoteapi-client-2.0.4-1.src.rpm
checksum_type: sha256
description:
  Python client for the zmqRemoteApi, [protocol verison 2](https://github.com/CoppeliaRobotics/zmqRemoteApi/blob/master/PROTOCOL.md#versions) (note: starting from pip package version 2.x, the major version number (e.g. 2) matches with the protocol version used by CoppeliaSim).



  ```sh
  python3 -m pip install coppeliasim-zmqremoteapi-client
  ```



  ```python
  from coppeliasim_zmqremoteapi_client import *




  client = RemoteAPIClient()


  sim = client.require('sim')


  h = sim.getObject('/Floor')
  print(h)
  ```

  There is also an `asyncio` version of the client. Normal `asyncio` principles apply, and all methods are async:

  ```python
  from coppeliasim_zmqremoteapi_client.asyncio import *

  client = RemoteAPIClient()

  async def main():
      async with RemoteAPIClient() as client:
          sim = await client.require('sim')
          h = await sim.getObject('/Floor')
          print(h)

  asyncio.run(main())
  ```

  on Windows, if it doesn't work properly, before calling `asyncio.run(...)` call:

  ```python
  asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
  ```

  A note about performance of sequential requests: if performing many commands in one shot, and results will be used later, consider using `asyncio.gather` for improved throughput.

  E.g. getting the handles of 100 objects:

  ```python
  handles = await asyncio.gather(*[sim.getObject(f'/Object{i+1}') for i in range(100)])
  ```

  Also check out the examples in [`clients/python`](https://github.com/CoppeliaRobotics/zmqRemoteApi/blob/master/clients/python).


pkgId: 6c358f168770f70dbabb20b875b331404b1249ba0fd590cdb0a585718ab5c097
name: python-copr
arch: src
version: 2.0
epoch: 0
release: 1
summary: Python client for copr service.
url: https://github.com/fedora-copr/copr
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copr-2.0-1.src.rpm
checksum_type: sha256
description:
  Copr is designed to be a lightweight buildsystem that allows contributors
  to create packages, put them in repositories, and make it easy for users
  to install the packages onto their system. Within the Fedora Project it
  is used to allow packagers to create third party repositories.

  This part is a python client to the copr service.


pkgId: 168b017930acd4e248f116c85be7336d8a2d885756dc93ebc73605313dbdc94e
name: python-copr-cli
arch: src
version: 2.0
epoch: 0
release: 1
summary: CLI tool to run copr
url: https://github.com/fedora-copr/copr
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copr-cli-2.0-1.src.rpm
checksum_type: sha256
description:
  Copr is designed to be a lightweight buildsystem that allows contributors
  to create packages, put them in repositories, and make it easy for users
  to install the packages onto their system. Within the Fedora Project it
  is used to allow packagers to create third party repositories.

  This part is a command line interface to use copr.


pkgId: b41763d61b36b5bd583d7e6e0ce28f235b58a9dcd0149475cff3809fedeb5002
name: python-copr-common
arch: src
version: 1.0
epoch: 0
release: 1
summary: Common python code used by Copr.
url: https://github.com/fedora-copr/copr
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copr-common-1.0-1.src.rpm
checksum_type: sha256
description:
  COPR is lightweight build system. It allows you to create new project
  in WebUI, and submit new builds and COPR will create yum repository from latest builds.

  This package contains python code used by other Copr packages. Mostly
  useful for developers only.


pkgId: d1971604f16c2a9e16f0a2c6f30de95ad1811a9a9b4b43e6070de0f820c602e0
name: python-copt
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Library for composite optimization in Python
url: http://pypi.python.org/pypi/copt
rpm_license: New BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copt-0.9.2-1.src.rpm
checksum_type: sha256
description:
  copt is an optimization library for Python. Its goal is to provide a high quality implementation of classical optimization algorithms under a consistent API.
  `Docs <http://openopt.github.io/copt/>`_ | `Examples <http://openopt.github.io/copt/auto_examples/index.html>`_


pkgId: b0fbb5574c518050b8aa43600d4bc6b2446c1c1204dc32f439bcae4b0dd62c15
name: python-copula-wrapper
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Top-level package for statsmodels copula wrapper.
url: https://github.com/tadamcz/copula-wrapper
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copula-wrapper-0.1.6-1.src.rpm
checksum_type: sha256
description:
  Suppose we want to specify a continuous `n`-dimensional joint probability distribution by giving:

  - `n` arbitrary marginal distributions
  - a set of pairwise correlations between the dimensions

  [Copulas](https://www.mathworks.com/help/stats/copulas-generate-correlated-samples.html) are a good way to achieve this separate specification of marginal distribution and dependence.

  This is a wrapper around the ``CopulaDistribution`` class from the [`statsmodels` package](https://www.statsmodels.org/), providing an interface that I prefer. (The rationale is disused in more detail [below](#discussion-of-interface)).


  ```shell
  pip install copula_wrapper  # or `poetry add copula_wrapper`
  ```


  Dictionary arguments and Kendall's tau:

  ```python
  from copula_wrapper import CopulaJoint
  from scipy import stats
  import seaborn as sns

  marginals = {
      "consumption elasticity": stats.uniform(0.75, 3),
      "market return": stats.lognorm(0.05, 0.05),
      "risk of war": stats.beta(1, 50)
  }

  tau = {
      
      ("risk of war", "market return"): -0.5,
  }


  dist = CopulaJoint(marginals, kendall_tau=tau)


  p = dist.cdf({
      "consumption elasticity": 1.5,
      "market return": 1.5,
      "risk of war": 0.5
  })


  sample = dist.rvs(100_000)


  sns.pairplot(sample, plot_kws={"s": 1})
  ```
  ![](plot1.png)

  Array arguments and Spearman's rho:

  ```python
  import pandas as pd
  import numpy as np
  from copula_wrapper import CopulaJoint
  from scipy import stats
  import seaborn as sns

  marginals = [
      stats.uniform(0.75, 3),
      stats.lognorm(0.05, 0.05),
      stats.beta(1, 50)
  ]

  spearman = np.eye(3)
  spearman[1, 2] = spearman[2, 1] = -0.5


  dist = CopulaJoint(marginals, spearman_rho=spearman)


  p = dist.cdf([1.5, 1.5, 0.5])


  sample = dist.rvs(10_000)


  sns.pairplot(pd.DataFrame(sample), plot_kws={"s": 1})
  ```
  ![img_2.png](plot2.png)



  ``CopulaJoint`` is a wrapper around ``CopulaDistribution`` from ``statsmodels``.

  The context that motivated this wrapper was:
  - A Monte Carlo simulation model with 10+ input dimensions
  - The correlations come from subjective judgments / expert elicitation
  - Many correlations are zero
  - Users may not be familiar with or care about the mathematics of copulas (I wasn't) and may not be familiar with API conventions of SciPy (that also influenced `statsmodels`).
  - In my opinion, the terminology in the area invites confusion between a copula and the joint distribution (with arbitrary marginals) that it induces.




  In ``statsmodels``, you'd do something like the following

  ```python
  from statsmodels.distributions.copula.api import CopulaDistribution, GaussianCopula
  from scipy import stats
  corr = [
  	[1.0, 0.5],
  	[0.5, 1.0],
  ]
  joint = CopulaDistribution(GaussianCopula(corr=corr), marginals=[stats.beta(2,2), stats.norm()])
  ```

  where ``corr`` is the matrix of Pearson's rho correlations (the standard linear correlation coefficient most people are familiar with). IMO, this surfaces implementation details and requires the user to engage with the internals of their joint distribution, which they may not understand or care about. It also invites the misunderstanding that the joint distribution will have a Pearson's rho matching the ``corr`` we pass in. This is not the case, as the following example shows:

  ```python
  import numpy as np
  from scipy import stats
  from statsmodels.distributions.copula.api import CopulaDistribution, GaussianCopula

  c = 0.8
  corr = [
      [1.0, c],
      [c, 1.0],
  ]
  joint = CopulaDistribution(GaussianCopula(corr=corr),
                             marginals=[stats.norm(2, 2), stats.lognorm(loc=0, s=1)])

  samples = joint.rvs(int(1e6))
  joint_r = stats.pearsonr(samples[:, 0], samples[:, 1])[0]  # about 0.6
  assert not np.isclose(joint_r, c)
  ```

  Therefore, this wrapper instead takes rank correlations as input, and these are satisfied by the resulting joint distribution. It converts these to the appropriate correlation measure for the underlying copula. You must explicitly provide ``kendall_tau`` or ``spearman_rho``.

  (For now, only the Gaussian copula is supported. But I've written the class to be extensible easily and even put some hints as code comments. PRs welcome. If more copulas are supported, there will be a parameter ``family`` with values like ``"Gaussian"``, ``"Clayton"``...)


  if dimensions are to be named, ``marginals`` must be a dict, and ``rank_corr`` must be a dict
  of tuples, e.g.

  ```python
  from scipy import stats
  marginals = {
  	"a": stats.uniform(0, 1),
  	"b": stats.lognorm(2, 3),
  	"c": stats.norm(4, 5),
  }

  rank_corr = {
  	
  	("a", "b"): 0.5,
  }
  ```

  and the first argument to ``.pdf``, ``.cdf``, and ``.logpdf`` must be a dict with the same keys as ``marginals``.
  (I originally had these methods support dimensions as keyword arguments, but I thought it was better not to
  modify the API even more, plus dictionary keys can be any hashable object, not just strings.).

  If dimensions are named,
  ``.rvs`` returns a Pandas DataFrame with dimension names as column names.

  Otherwise, ``marginals`` must be a list and ``rank_corr`` must be a square matrix, and ``.rvs``
  returns a numpy array, just like in statsmodels.


  For background, the Scipy pattern is that there is e.g. a ``norm_gen`` subclass of ``rv_continuous`` that is used to create the
  ``norm`` instance, which can then optionally be 'frozen'.

  The statsmodels ``CopulaDistribution`` does not follow this pattern. It acts 'frozen' in sofar
  as the underlying copula (e.g. Gaussian) and its correlation matrix are specified at
  initialization. However, it acts 'unfrozen' in that ``cop_args`` and ``marg_args`` can
  be passed to ``.pdf``, ``.cdf``, and ``.logpdf``. As a result, ``CopulaDistribution`` does not subclass
  any of the ``scipy.stats`` classes.

  I find this a bit inconsistent, and don't find ``cop_args`` and ``marg_args`` useful, so I
  drop them in this wrapper.	The benefit is that the wrapper now satisfies the interface of
  a SciPy multivariate frozen distribution.

  This means that the marginals provided to ``CopulaJoint`` must be frozen as well.

  It also means I use `size` (SciPy) instead of `nobs` (statsmodels) for the call to `rvs`.



  While the copula tests in `statsmodels` are likely to be good for their intended purpose, I couldn't quickly decipher
  exactly what behaviour these tests were checking for. In order to make sure this wrapper behaves in the way that its
  interface promises, I created a set of end-to-end tests. These tests that check that random samples from the
  joint distribution have:

  1. The expected rank correlation matrix
  2. The expected marginal distributions (using the Kolmogorov-Smirnov statistic)

  The tests are parametrized (run for many inputs).

  As they involve large numbers of random samples, they are slow.

  There are also a few simple unit tests.


pkgId: 7c3a1efb60b33c5af779e7ff1096d709c942a8d64e917f40ae569ccc03b45087
name: python-copulae
arch: src
version: 0.7.9
epoch: 0
release: 1
summary: Python copulae library for dependency modelling
url: https://pypi.org/project/copulae/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copulae-0.7.9-1.src.rpm
checksum_type: sha256
description:
  Probably the second most popular copula package in Python. 😣

  Copulae is a package used to model complex dependency structures. Copulae implements common and popular copula
  structures to bind multiple univariate streams of data together. All copula implemented are multivariate by default.



  [![Anaconda Version](https://anaconda.org/conda-forge/copulae/badges/version.svg)](https://anaconda.org/conda-forge/copulae/badges/version.svg)
  [![PyPI version](https://badge.fury.io/py/copulae.svg)](https://badge.fury.io/py/copulae)



  [![Build Status](https://travis-ci.com/DanielBok/copulae.svg?branch=master)](https://travis-ci.com/DanielBok/copulae)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/copulae/badges/latest_release_date.svg)](https://anaconda.org/conda-forge/copulae)
  [![Downloads](https://pepy.tech/badge/copulae)](https://pepy.tech/project/copulae)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/copulae/badges/downloads.svg)](https://anaconda.org/conda-forge/copulae)



  [![Documentation Status](https://readthedocs.org/projects/copulae/badge/?version=latest)](https://copulae.readthedocs.io/en/latest/?badge=latest)



  [![Coverage Status](https://coveralls.io/repos/github/DanielBok/copulae/badge.svg?branch=master)](https://coveralls.io/github/DanielBok/copulae?branch=master)



  Install and update using [pip](https://pip.pypa.io/en/stable/quickstart/) and on conda.

  ```bash

  conda install -c conda-forge copulae

  ```

  ```bash

  pip install -U copulae
  ```



  The documentation is located at https://copulae.readthedocs.io/en/latest/. Please check it out. :)




  ```python
  from copulae import NormalCopula
  import numpy as np

  np.random.seed(8)
  data = np.random.normal(size=(300, 8))
  cop = NormalCopula(8)
  cop.fit(data)

  cop.random(10)  # simulate random number


  p = cop.params



  cop.summary()


  cop[:] = np.eye(8)  # in this case, this will be equivalent to an Independent Copula
  ```

  Most of the copulae work roughly the same way. They share pretty much the same API. The difference lies in the way they are parameterized. Read the docs to learn more about them. 😊




  Most of the code has been implemented by learning from others. Copulas are not the easiest beasts to understand but here are some items that helped me along the way. I would recommend all the works listed below.



  I referred quite a lot to the textbook when first learning. The authors give a pretty thorough explanation of copula from ground up. They go from describing when you can use copulas for modeling to the different classes of copulas to how to fit them and more.



  This blogpost gives a very gentle introduction to copulas. Before diving into all the complex math you'd find in textbooks, this is probably the best place to start.



  I started working on the copulae package because I couldn't find a good existing package that does multivariate copula modeling. Presently, I'm building up the package according to my needs at work. If you feel that you'll need some features, you can drop me a message. I'll see how I can schedule it. 😊



  - [x] Set up package for pip and conda installation
  - [ ] More documentation on usage and post docs on rtd (Permanently in the works 😊)
  - [x] Elliptical Copulas
      - [x] Gaussian (Normal)
      - [x] Student (T)
  - [ ] Implement in Archimedean copulas
      - [x] Clayton
      - [x] Gumbel
      - [x] Frank
      - [x] Empirical
      - [ ] Joe
      - [ ] AMH
      - [ ] Rho finding via Cubatures
  - [ ] Mixture copulas
      - [X] Gaussian Mixture Copula
      - [ ] Generic Mixture Copula
      - [x] Marginal Copula
  - [ ] Vine Copulas
  - [ ] Copula Tests
      - [x] Radial Symmetry
      - [x] Exchangeability
      - [ ] Goodness of Fit
          - [ ] Pairwise Rosenblatt
          - [ ] Multi-Independence
          - [x] General GOF
      - [ ] Model Selection
          - [ ] Cross-Validated AIC/BIC


pkgId: 5a2d1524eabd4ec5108cf9ed5700faedfa75cbc6c33b52d8b94cc72c7f28f66a
name: python-copulas
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: Create tabular synthetic data using copulas-based modeling.
url: https://pypi.org/project/copulas/
rpm_license: BSL-1.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copulas-0.11.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <a href="https://datacebo.com"><img align="center" width=40% src="https://github.com/sdv-dev/SDV/blob/stable/docs/images/DataCebo.png"></img></a>
  </div>
  <br/>
  <br/>
  [The Synthetic Data Vault Project](https://sdv.dev) was first created at MIT's [Data to AI Lab](
  https://dai.lids.mit.edu/) in 2016. After 4 years of research and traction with enterprise, we
  created [DataCebo](https://datacebo.com) in 2020 with the goal of growing the project.
  Today, DataCebo is the proud developer of SDV, the largest ecosystem for
  synthetic data generation & evaluation. It is home to multiple libraries that support synthetic
  data, including:
  * 🔄 Data discovery & transformation. Reverse the transforms to reproduce realistic data.
  * 🧠 Multiple machine learning models -- ranging from Copulas to Deep Learning -- to create tabular,
    multi table and time series data.
  * 📊 Measuring quality and privacy of synthetic data, and comparing different synthetic data
    generation models.
  [Get started using the SDV package](https://sdv.dev/SDV/getting_started/install.html) -- a fully
  integrated solution and your one-stop shop for synthetic data. Or, use the standalone libraries
  for specific needs.


pkgId: 59a848fd9dc0b8bbeecccd8a7e79c53e3ca1d1d33f5a1c290f12bdc3c07c9f27
name: python-copy-to
arch: src
version: 1.4.5
epoch: 0
release: 1
url: https://github.com/excited-bore/copy-to
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copy-to-1.4.5-1.src.rpm
checksum_type: sha256
summary:
  A little commandline tool to copy and paste multiple files and directories to single directory with use of configuration

description:
  A little python script I use in conjunction with git so you can easily copy (config) files located outside of a git repository to one (or to wherever you want to). Useful for configuration files.

  Available on with pip/pipx: https://pypi.org/project/copy-to/

  Depends on [argcomplete](https://pypi.org/project/argcomplete/), [GitPython](https://pypi.org/project/GitPython/), [prompt_toolkit](https://pypi.org/project/prompt_toolkit/)



  Linux:
  ```
  sudo apt install pipx / sudo pacman -S python-pipx
  pipx install copy-to
  ```

  Windows Powershell:
  ```
  winget install python3
  python -m pip install --user pipx
  python -m pipx ensurepath
  python -m pipx install copy-to
  ```

  Then, restart you shell.

  For autocompletion on Windows Powershell v5.1, first run:
  ```
  Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted
  ```

  Then, for Powershell autocompletion in general, run:
  ```
  mkdir -p $HOME\Documents\WindowsPowerShell\Modules
  python ((where.exe register-python-argcomplete).Split([Environment]::NewLine) | Select -First 1) --shell powershell copy-to.exe > $HOME\Documents\WindowsPowerShell\Modules/copy-to.psm1
  ```

  Then check your Profile folder using `echo $PSHOME`, and (using for example notepad) open a file in that path called `Profile.ps1`. This requires administrator access.
  For powershell v5.1, this is `C:\Windows\System32\WindowsPowerShell\v1.0\Profile.ps1`. Open notepad as an administrator and create the file if it doesn't exist yet.
  Then in that file, put this:
  ```
  Import-Module $HOME\Documents\WindowsPowerShell\Modules/copy-to.psm1
  ```

  For Linux / MacOs, try running it once if autocompletions aren't working

  You can also run:
  ```
  sudo activate-global-python-argcomplete
  ```



  Add a pairset of destination folder - source files and/or directories with
  ```
  copy-to add myname destination_folder sourcefile1 (sourcefolder1 sourcefile2 sourcefile3 sourcefolder2/*) ...
  ```

  Copy the files to their destination by running
  ```
  copy-to run myname1 (myname2)
  ```

  Or copy the files back to source by running
  ```
  copy-to run-reverse myname1 (myname2)
  ```

  When the destination is missing, a prompt will ask you if you want to create the destination folder.

  Run and run-reverse can also run without arguments when git is installed and present in a git local repository that has configured copy-to. This is so it can be hooked to a git macro more easily, f.ex. with an alias/function

  Windows Powershell: (put in your profile - `notepad $PSHOME\Profile.ps1`)
  ```
  function git-status { copy-to.exe run && git.exe status }
  ```

  Linux bash (put in your .bashrc - `nano ~/.bashrc`):
  ```
  alias git-status="copy-to run && git status"
  ```

  or for those who use it, on startup of [Lazygit](https://github.com/jesseduffield/lazygit):

  Windows Powershell:
  ```
  function lazygit { copy-to.exe run && lazygit.exe }
  ```

  Linux bash:
  ```
  alias lazygit="copy-to run && lazygit"
  ```

  Local git config:
  ```
  [copy-to]
      run = myname1 myname2
      file = myconf.json
  ```
  This can be setup with `copy-to add myname` and `copy-to set-git myname` or
  `copy-to add myname` and `copy-to run`/`copy-to run-reverse` after wich a prompt will ask if you want to set it up with git. Both `copy-to run` and `copy-to run-reverse` will run using the same `run` arguments possibly given in a local gitconfig. A custom conf.json can be also be setup and will always take precedence over other file options when set up.




  This will setup a git repository for your firefox configuration files using copy-to on Windows.



  We start with installing git if it's not installed already.

  ```
  winget install Git.Git
  ```

  (Optional: get latest version of PowerShell)

  ```
  winget install Microsoft.PowerShell
  ```

  ![Setup git](https://raw.githubusercontent.com/excited-bore/copy-to/main/images/Setup_git.gif "Setup git")

  This guide shows you how to use copy-to to and git to backup (and restore) your firefox profile following the [officical mozilla docs](https://support.mozilla.org/en-US/kb/back-and-restore-information-firefox-profiles)

  First we create a local git repository and cd into it.

  We can make this repostitory for firefox only `firefox`, or make it for all our dotfiles `dotfiles`

  ```
  git init dotfiles
  cd dotfiles
  ```

  Now, we could just start and copy-to will put all your configurations in the default location (`$HOME/.config/copy-to/confs.json`), or we could set it up so our configuration file is also in our git repository.

  Since we're in a git repostitory, we could accomplish this using `copy-to set-git file confs.json` and copy-to will make the config file `confs.json` in our current folder while also using this specific file to read files and folders from when we `cd` into this git repository. You can see this whether or not this is done by running `git config -e`.

  We could change the confs.json file from the default path by setting the environment variable `COPY_TO` or by using the `--file` parameter.

  Then we add everything in the firefox 'profile' folder programmatically using copy-to:
      - First we open the profile folder by opening firefox-> Help-> More Troubleshooting Information-> Open 'Profile' Folder and copy the folder path.
      - Then we run `copy-to add firefox firefox ` to add a the target folder but without the source files. This will also create a subfolder `firefox` in our git repository wich will be our destination.

  We can handpick what parts of our firefox config we want to backup, for example to keep only our bookmarks, we could store <em>places.sqlite</em>, <em>bookmarksbackups/</em> and <em>favicons.sqlite</em> (See [this](https://support.mozilla.org/en-US/kb/profiles-where-firefox-stores-user-data)) from
  `"C:\Users\username\AppData\Roaming\Mozilla\Firefox\Profiles\random_release\"`.
  Don't forget to *close* firefox <em>first</em> and change this folder to *your* <em>profile folder</em> and/or <em>username</em>.

  ```
  copy-to add-source firefox "C:\Users\username\AppData\Roaming\Mozilla\Firefox\Profiles\random_release\places.sqlite" "C:\Users\username\AppData\Roaming\Mozilla\Firefox\Profiles\random_release\bookmarksbackups/" "C:\Users\username\AppData\Roaming\Mozilla\Firefox\Profiles\random_release\favicons.sqlite"
  ```

  Folders added to source will automatically copy recursively.

  On the other hand, we could also iterate over each file in our profile folder (dont forget to replace the path with the path you copied earlier):

  ```
  Get-ChildItem "C:\Users\username\AppData\Roaming\Mozilla\Firefox\Profiles\random_release" -Filter * |
  ForEach-Object {copy-to add-source firefox "C:\Users\username\AppData\Roaming\Mozilla\Firefox\Profiles\random_release\$_" }
  ```

  For Linux (and presumably MacOs), this would be:
  ```
  copy-to add-source firefox /home/username/.mozilla/firefox/random_release/*
  ```
  If you get an error along the lines of `The file/directory /home/username/.mozilla/firefox/9mw2xroo.default-release/lock does not exist!`, try removing the file and running the command again.

  Then we run `copy-to run firefox` to copy the files to the target folder.

  Now that everything we want related to firefox is inside our local git repository, we can start setting up our remote repository.



  ![Setup git_ssh](https://raw.githubusercontent.com/excited-bore/copy-to/main/images/Setup_git_ssh.gif "Setup git ssh")

  Following the instructions on [Github](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent):
      - We create a public/private keypair using `ssh-keygen -t ed25519`. This will save our keypair inside `C:\Users\username\.ssh\id_ed25519` and `C:\Users\username\.ssh\id_ed25519.pub` respectively.
      - Then we open up an administrator powershell and run:

  ```
  Get-Service -Name ssh-agent | Set-Service -StartupType Manual
  Start-Service ssh-agent
  ```

  to startup the ssh-agent.
      - Back inside a regular powershell, we add our private key using
      `ssh-add C:\Users\username\.ssh\id_ed25519`.
      - Then we add the ssh key to our github account and test our connecting using `ssh -T git@github.com`.



  ![Setup git_remote](https://raw.githubusercontent.com/excited-bore/copy-to/main/images/Setup_git_remote.gif "Setup git remote")

  First we make sure we've made our first commit adding every new change:

  ```
  git add --all
  git commit -m "Initial commit"
  ```

  Next we got to our github account and create a new private repository.
  After that, we configure the remote repository using `git remote add origin git@github.com/username/dotfiles.git`.
  Then if everything went well, we can just push to our remote repository using `git push -u origin main`.

  We can keep this up-to-date regularly by running `copy-to run firefox`, `cd C:/Users/username/dotfiles` and `git push` whenever we make changes.

  Now, if we ever need to freshly install firefox, we have a backup ready to go that we can use by running `copy-to run-reverse`.
  Or, if we ever decide to use a different operating system, we clone our repository after installing firefox and relocate the firefox profile folder.
  If we made a private repository we use:
  ```
  git clone git@github.com:<username>/dotfiles
  ```
  because otherwise we run into authentication problems.

  Then we run:
  ```
  copy-to set-git file confs.json
  copy-to reset-destination firefox "new-profile-folder"
  copy-to run-reverse firefox
  ```

  We have reconfigure our file because git doesn't upload the local .git/ files.
  As an alternative for backing up application configurationfiles accross operating systems, you could add multiple configuration names for each os. (`copy-to add firefox-windows .. ` / `copy-to add firefox-linux ..`)



  List configured paths and files with
  ```
  copy-to list myname/mygroupname/all/all-no-group/groups/all-groups/names/groupnames/all-names
  ```
  or as a flag
  ```
  copy-to --list othercommand
  ```
  'all-no-group' and 'groups' to list all regular configs and groups respectively
  'names' and 'groupnames' to list just the regular names and groupnames respectively
  You can also use 'all' to list/run all known configurations


  Delete set of dest/src by name with
  ```
  copy-to delete myname1 (myname2)
  ```

  Add sources with
  ```
  copy-to add-source myname folder1 file1
  ```

  Delete source by index with
  ```
  copy-to delete-source myname 1 4 7
  ```

  Reset source and destination folders
  ```
  copy-to reset-source myname
  copy-to reset-destination myname newDest
  ```

  Set the path of source files/folders by index with
  ```
  copy-to set-source-path myname1 /home/user/ 1 2-4
  ```

  Groups are based on names. For copying to multiple directories in one go.
  Groupnames 'group'/'all' cannot be used.

  Add groupname
  ```
  copy-to add-group mygroupname myname1 myname2
  ```

  Delete groupname
  ```
  copy-to delete-group mygroupname
  ```

  Add name to group
  ```
  copy-to add-to-group mygroupname myname1 myname2
  ```

  Delete name from group
  ```
  copy-to delete-from-group mygroupname myname1 myname2
  ```

  At default the configuration file is located at `~/.config/copy-to/confs.json`, but you can set a environment variable `COPY_TO` to change this, or pass a `-f, --file` flag.

  Mac not tested


pkgId: c5680abf363a2eb5b30e0fe1a6ab774aceb5ff7e784cd692d124a9dc0303321b
name: python-copybook
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: python copybook parser
url: https://github.com/zalmane/copybook
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copybook-1.0.16-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/copybook)](https://pepy.tech/project/copybook)



  Copybook is a python module for parsing VSAM copybooks.



  - Supports all numeric PIC variations including:
    - integers
    - floats described with dot notation
    - floats described with V notation
    - leading SIGNED
    - trailing SIGNED
  - Character PIC notations
  - Groups
  - OCCURS clauses
  - REDEFINES clauses

  In addition, it provides indexes of column locations to help with parsing fixed width files based on positions within each line



  ```
  pip install copybook
  ```



  Copybook provides two methods for parsing copybooks: `parse_file` and `parse_string`. The result is a `FieldGroup` object that represents the root of the copybook tree.

  Examples:

  ```
  import copybook
  text = """
         01  WORK-BOOK.
          10  TAX-RATE        PIC S9(13)V9(2)
                      SIGN LEADING SEPARATE.
  """
  root = copybook.parse_string(text)
  ```



  The `FieldGroup` object provides a `flatten` method that return a flat list of `Field` objects.

  Example:

  ```
  import copybook
  text = """
         01  WORK-BOOK.
          10  TAX-RATE        PIC S9(13)V9(2)
                      SIGN LEADING SEPARATE.
          10  AMOUNT        PIC S9(4)V9(2).
  """

  root = copybook.parse_string(text)


  list_of_fields = root.flatten()


  line = "          -13452987654"


  for field in list_of_fields:

    
    if type(field)==copybook.Field:

      
      
      str_field = line[field.start_pos:field.start_pos+field.get_total_length()]

      
      print(f"{field.name}: {field.parse(str_field)}")
  ```



  PRs are always welcome!



  If you encounter an unsupported copybook feature, please paste the copybook example along with whatever logs or error message you have received and open an issue.



  Copybook uses the awesome PyParsing library for tokenization



  MIT


pkgId: daabcfdc3554bb2645efc3ffa9b009700bd9e3e9483d41fd382e75079a75aad0
name: python-copychat
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Easily copy code for LLM context
url: https://pypi.org/project/copychat/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copychat-0.5.0-1.src.rpm
checksum_type: sha256
description:
  > Simple code to context

  Copychat is a lightweight CLI tool that prepares your code for conversations with LLMs. It intelligently formats your source files into chat-ready context, handling everything from file selection to git diffs.



  - 🎯 **Smart file selection**: Automatically identifies relevant source files while respecting `.gitignore`
  - 🔍 **Git-aware**: Can include diffs and focus on changed files
  - 📦 **GitHub integration**: Pull directly from repositories
  - 🎨 **Clean output**: Formats code with proper language tags and metadata
  - 📋 **Clipboard ready**: Results go straight to your clipboard
  - 🔢 **Token smart**: Estimates token count for context planning



  You can use [uv](https://docs.astral.sh/uv/) to run copychat directly from the command line, without needing to install it first:
  ```bash
  uvx copychat
  ```

  If you want to save a few milliseconds, you can install copychat globally with `uv tool install copychat` or in your environment with `uv pip install copychat`. And of course, `pip install copychat` works too.

  In this readme, we'll show the `copychat` command directly for simplicity, but `uvx copychat` works identically.



  Collect, format, and copy all source code in the current directory (and subdirectories) to the clipboard:
  ```bash
  copychat
  ```

  Copy only Python files to clipboard:
  ```bash
  copychat -i py
  ```

  Copy specific files, including any git diffs:
  ```bash
  copychat src/ tests/test_api.py --diff-mode full-with-diff
  ```

  Use GitHub as a source instead of the local filesystem:
  ```bash
  copychat src/ -s github:prefecthq/controlflow
  ```



  Copychat is designed to be intuitive while offering powerful options for more complex needs. Let's walk through common use cases:



  At its simplest, run `copychat` in any directory to scan and format all recognized source files:

  ```bash
  copychat
  ```

  This will scan the current directory, format all supported files, and copy the result to your clipboard. The output includes metadata like character and token counts to help you stay within LLM context limits.



  You can specify exactly what you want to include:

  ```bash

  copychat src/main.py


  copychat src/api.py tests/test_api.py docs/


  copychat src/*.py tests/**/*.md
  ```



  When you only want specific file types, use the `--include` flag with comma-separated extensions:

  ```bash

  copychat --include py


  copychat --include py,js,jsx
  ```



  Copychat shines when working with git repositories. Use different diff modes to focus on what matters:

  ```bash

  copychat --diff-mode changed-with-diff


  copychat --diff-mode full-with-diff


  copychat --diff-mode diff-only


  copychat --diff-mode diff-only --diff-branch develop
  ```

  The `-diff-mode` and `--diff-branch` options are particularly useful when you want to:
  - Review any changes you've made, either in isolation or in context
  - Compare changes against a specific branch



  You can exclude files that match certain patterns:

  ```bash

  copychat --exclude "**/*.test.js,**/*.spec.py"


  copychat --exclude "build/*,dist/*"
  ```

  Copychat automatically respects your `.gitignore` file and common ignore patterns (like `node_modules`).



  Pull directly from GitHub repositories:

  ```bash

  copychat --source github:username/repo


  copychat --source https://github.com/username/repo
  ```



  By default, Copychat copies to your clipboard, but you have other options:

  ```bash

  copychat --append


  copychat --out context.md


  copychat --out context.md --append


  copychat --print


  copychat --out context.md
  ```



  Use the `--verbose` flag (or `-v`) to include detailed file information in the output, including token counts:

  ```bash
  copychat -v
  ```



  Control how deep copychat scans subdirectories:

  ```bash

  copychat --depth 0


  copychat --depth 1


  copychat --depth 3
  ```



  ```bash
  copychat [OPTIONS] [PATHS]...

  Options:
    -s, --source TEXT     Source to scan (filesystem path, github:owner/repo, or URL)
    -o, --out PATH        Write output to file
    -a, --append          Append output instead of overwriting
    -p, --print          Print output to screen
    -v, --verbose         Show detailed file information in output
    -i, --include TEXT    Extensions to include (comma-separated, e.g. 'py,js,ts')
    -x, --exclude TEXT    Glob patterns to exclude
    -d, --depth INTEGER   Maximum directory depth to scan (0 = current dir only)
    --diff-mode TEXT     How to handle git diffs
    --diff-branch TEXT Compare changes against specified branch
    --debug              Debug mode for development
    --help               Show this message and exit
  ```



  Copychat automatically recognizes and properly formats many common file types, including:

  - Python (`.py`, `.pyi`)
  - JavaScript/TypeScript (`.js`, `.ts`, `.jsx`, `.tsx`)
  - Web (`.html`, `.css`, `.scss`)
  - Systems (`.c`, `.cpp`, `.rs`, `.go`)
  - Config (`.yaml`, `.toml`, `.json`)
  - Documentation (`.md`, `.rst`, `.txt`)
  - And [many more](https://github.com/username/copychat/blob/main/copychat/patterns.py)



  Copychat generates clean, structured output with:
  - File paths and language tags
  - Token count estimates
  - Git diff information (when requested)
  - Proper syntax highlighting markers


pkgId: eddda5acf09bf10c2e4185a538d4f098d07cd6c9c3a3a7cd56c4600a72a18b8b
name: python-copychat
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Easily copy code for LLM context
url: https://pypi.org/project/copychat/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copychat-0.5.2-1.src.rpm
checksum_type: sha256
description:
  > Simple code to context

  Copychat is a lightweight CLI tool that prepares your code for conversations with LLMs. It intelligently formats your source files into chat-ready context, handling everything from file selection to git diffs.



  - 🎯 **Smart file selection**: Automatically identifies relevant source files while respecting `.gitignore`
  - 🔍 **Git-aware**: Can include diffs and focus on changed files
  - 📦 **GitHub integration**: Pull directly from repositories
  - 🎨 **Clean output**: Formats code with proper language tags and metadata
  - 📋 **Clipboard ready**: Results go straight to your clipboard
  - 🔢 **Token smart**: Estimates token count for context planning



  You can use [uv](https://docs.astral.sh/uv/) to run copychat directly from the command line, without needing to install it first:
  ```bash
  uvx copychat
  ```

  If you want to save a few milliseconds, you can install copychat globally with `uv tool install copychat` or in your environment with `uv pip install copychat`. And of course, `pip install copychat` works too.

  In this readme, we'll show the `copychat` command directly for simplicity, but `uvx copychat` works identically.



  Collect, format, and copy all source code in the current directory (and subdirectories) to the clipboard:
  ```bash
  copychat
  ```

  Copy only Python files to clipboard:
  ```bash
  copychat -i py
  ```

  Copy specific files, including any git diffs:
  ```bash
  copychat src/ tests/test_api.py --diff-mode full-with-diff
  ```

  Use GitHub as a source instead of the local filesystem:
  ```bash
  copychat src/ -s github:prefecthq/controlflow
  ```



  Copychat is designed to be intuitive while offering powerful options for more complex needs. Let's walk through common use cases:



  At its simplest, run `copychat` in any directory to scan and format all recognized source files:

  ```bash
  copychat
  ```

  This will scan the current directory, format all supported files, and copy the result to your clipboard. The output includes metadata like character and token counts to help you stay within LLM context limits.



  You can specify exactly what you want to include:

  ```bash

  copychat src/main.py


  copychat src/api.py tests/test_api.py docs/


  copychat src/*.py tests/**/*.md
  ```



  When you only want specific file types, use the `--include` flag with comma-separated extensions:

  ```bash

  copychat --include py


  copychat --include py,js,jsx
  ```



  Copychat shines when working with git repositories. Use different diff modes to focus on what matters:

  ```bash

  copychat --diff-mode changed-with-diff


  copychat --diff-mode full-with-diff


  copychat --diff-mode diff-only


  copychat --diff-mode diff-only --diff-branch develop
  ```

  The `-diff-mode` and `--diff-branch` options are particularly useful when you want to:
  - Review any changes you've made, either in isolation or in context
  - Compare changes against a specific branch



  You can exclude files that match certain patterns:

  ```bash

  copychat --exclude "**/*.test.js,**/*.spec.py"


  copychat --exclude "build/*,dist/*"
  ```

  Copychat automatically respects your `.gitignore` file and common ignore patterns (like `node_modules`).



  Pull directly from GitHub repositories:

  ```bash

  copychat --source github:username/repo


  copychat --source https://github.com/username/repo


  copychat --source github:username/repo src/main.py tests/
  ```

  The `--source` flag specifies where to look (GitHub, filesystem, etc.), and then any additional arguments specify which paths within that source to process. This means you can target specific files or directories within a GitHub repository just like you would with local files.



  By default, Copychat copies to your clipboard, but you have other options:

  ```bash

  copychat --append


  copychat --out context.md


  copychat --out context.md --append


  copychat --print


  copychat --out context.md
  ```



  Use the `--verbose` flag (or `-v`) to include detailed file information in the output, including token counts:

  ```bash
  copychat -v
  ```



  Control how deep copychat scans subdirectories:

  ```bash

  copychat --depth 0


  copychat --depth 1


  copychat --depth 3
  ```



  ```bash
  copychat [OPTIONS] [PATHS]...

  Options:
    -s, --source TEXT     Source to scan (filesystem path, github:owner/repo, or URL)
    -o, --out PATH        Write output to file
    -a, --append          Append output instead of overwriting
    -p, --print          Print output to screen
    -v, --verbose         Show detailed file information in output
    -i, --include TEXT    Extensions to include (comma-separated, e.g. 'py,js,ts')
    -x, --exclude TEXT    Glob patterns to exclude
    -d, --depth INTEGER   Maximum directory depth to scan (0 = current dir only)
    --diff-mode TEXT     How to handle git diffs
    --diff-branch TEXT Compare changes against specified branch
    --debug              Debug mode for development
    --help               Show this message and exit
  ```



  Copychat automatically recognizes and properly formats many common file types, including:

  - Python (`.py`, `.pyi`)
  - JavaScript/TypeScript (`.js`, `.ts`, `.jsx`, `.tsx`)
  - Web (`.html`, `.css`, `.scss`)
  - Systems (`.c`, `.cpp`, `.rs`, `.go`)
  - Config (`.yaml`, `.toml`, `.json`)
  - Documentation (`.md`, `.rst`, `.txt`)
  - And [many more](https://github.com/username/copychat/blob/main/copychat/patterns.py)



  Copychat generates clean, structured output with:
  - File paths and language tags
  - Token count estimates
  - Git diff information (when requested)
  - Proper syntax highlighting markers


pkgId: f443aecc12b1670cb81d86da4d83b5dc641adaebb91b128c7b0630491d80043a
name: python-copydetect
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Code plagiarism detection tool
url: https://github.com/blingenf/copydetect
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copydetect-0.5.0-1.src.rpm
checksum_type: sha256
description:
  ![Screenshot of copydetect code comparison output](https://raw.githubusercontent.com/blingenf/copydetect/master/docs/_static/report_screenshot1.png)


  Copydetect is a code plagiarism detection tool based on the approach proposed in "[Winnowing: Local Algorithms for Document Fingerprinting](http://theory.stanford.edu/~aiken/publications/papers/sigmod03.pdf)" and used for the popular [MOSS](https://theory.stanford.edu/~aiken/moss/) platform. Copydetect takes a list of directories containing code as input, and generates an HTML report displaying copied slices as output. The implementation takes advantage of fast numpy functions for efficient generation of results. Code tokenization is handled by [Pygments](https://pygments.org/), so all 500+ languages which pygments can detect and tokenize are in turn supported by copydetect.

  Note that, like MOSS, copydetect is designed to detect likely instances of plagiarism; it is not guaranteed to catch cheaters dedicated to evading it, and it does not provide a guarantee that plagiarism has occurred.


  Copydetect can be installed using `pip install copydetect`. Note that Python version 3.7 or greater is required. You can then generate a report using the `copydetect` command (`copydetect.exe` on Windows. If your scripts folder is not in your PATH the code can also be run using `py.exe -m copydetect`).


  The simplest usage is `copydetect -t DIRS`, where DIRS is a space-separated list of directories to search for input files. This will recursively search for all files in the provided directories and compare every file with every other file. To look only at specific file extensions, use `-e` followed by another space-separated list (for example, `copydetect -t student_code -e cc cpp h`)

  If the files you want to compare to are different from the files you want to check for plagiarism (for example, if you want to also compare to submissions from previous semesters), use `-r` to provide a list of reference directories. For example, `copydetect -t PA01_F20 -r PA01_F20 PA01_S20 PA01_F19`. To avoid matches with code that was provided to students, use `-b` to specify a list of directories containing boilerplate code.

  There are several options for tuning the sensitivity of the detector. The noise threshold, set with `-n`, is the minimum number of matching characters between two documents that is considered plagiarism. Note that this is AFTER tokenization and filtering, where variable names have been replaced with V, function names with F, etc. If you change `-n` (default value: 25), you will also have to change the guarantee threshold, `-g` (default value: 30). This is the number of matching characters for which the detector is guaranteed to detect the match. If speed isn't an issue, you can set this equal to the noise threshold. Finally, the display threshold, `-d` (default value: 0.33), is used to determine what percentage of code similarity is considered interesting enough to display on the output report. The distribution of similarity scores is plotted on the output report to assist selection of this value.

  There are several other command line options for different use cases. If you only want to check for "lazy" plagiarism (direct copying without changing variable names or reordering code), `-f` can be used to disable code filtering. If you don't want to compare files in the same leaf directory (for example, if code is split into per-student directories and you don't care about self plagiarism), use `-l`. For a complete list of configuration options, see the following section.


  Configuration options can be provided either by using the command line arguments or by using a JSON file. If a JSON file is used, specify it on the command line using `-c` (e.g., `copydetect -c configuration.json`). A sample configuration file is available [here](docs/_static/sample.json). The following list provides the names of each JSON configuration key along with its associated command line arguments.

  - `test_directories` (`-t`, `--test-dirs`): a list of directories to recursively search for files to check for plagiarism.
  - `reference_directories` (`-r`, `--ref-dirs`): a list of directories to search for files to compare the test files to. This should generally be a superset of `test_directories`. If not provided, the test directories are used as reference directories.
  - `boilerplate_directories` (`-b`, `--boilerplate-dirs`): a list of directories containing boilerplate code. Matches between fingerprints present in the boilerplate code will not be considered plagiarism.
  - `extensions` (`-e`, `--extensions`): a list of file extensions containing code the detector should look at.
  - `noise_threshold` (`-n`, `--noise-thresh`): the smallest sequence of matching characters between two files which should be considered plagiarism. Note that tokenization and filtering replaces variable names with `V`, function names with `F`, object names with `O`, and strings with `S` so the threshold should be lower than you would expect from the original code.
  - `guarantee_threshold` (`-g`, `--guarantee-thresh`): the smallest sequence of matching characters between two files for which the system is guaranteed to detect a match. This must be greater than or equal to the noise threshold. If computation time is not an issue, you can set `guarantee_threshold = noise_threshold`.
  - `display_threshold` (`-d`, `--display-thresh`): the similarity percentage cutoff for displaying similar files on the detector report.
  - `force_language` (`-o`, `--force-language`): forces the tokenizer to tokenize input as a specific language, rather than automatically detecting the language using the file extension.
  - `same_name_only` (`-s`, `--same-name`): if `true`, the detector will only compare files that have the same name (for example, `decision_tree.py` will not be compared to `k_nn.py`). Note that this also means that, for example, `bryson_k_nn.py` will not be compared to `sara_k_nn.py`.
  - `ignore_leaf` (`-l`, `--ignore-leaf`):  if `true`, the detector will not compare files located in the same leaf directory.
  - `disable_filtering` (`-f`, `--disable-filter`):  if `true`, the detector will not tokenize and filter code before generating file fingerprints.
  - `disable_autoopen` (`-a`, `--disable-autoopen`):  if `true`, the detector will not automatically open a browser window to display the report.
  - `truncate` (`-T`, `--truncate`):  if `true`, highlighted code will be truncated to remove non-highlighted regions from the displayed output (sections not within 10 lines of highlighted code will be replaced with "...").
  - `out_file` (`-O`, `--out-file`): path to save output report to. A '.html' extension will be added to the path if not provided. If a directory is provided instead of a file, the report will be saved to that directory as report.html.
  - `encoding` (`--encoding`): encoding to use for reading files (the default is UTF-8). If files use varying encodings, --encoding DETECT can be used to detect the encoding of all files *(note: encoding detection requires the chardet package)*.

  Advanced options:

  - `css` (`--css`): Optional list of CSS files that will be linked in the generated HTML report file. These will overwrite the styling of the default report.


  Copydetect can also be run via the python API. An example of basic usage is provided below. API documentation is available [here](https://copydetect.readthedocs.io/en/latest/api.html).
  ```
  >>> from copydetect import CopyDetector
  >>> detector = CopyDetector(test_dirs=["tests"], extensions=["py"],
  ...                         display_t=0.5)
  >>> detector.add_file("copydetect/utils.py")
  >>> detector.run()
    0.00: Generating file fingerprints
     100%|████████████████████████████████████████████████████| 8/8
    0.31: Beginning code comparison
     100%|██████████████████████████████████████████████████| 8/8
    0.31: Code comparison completed
  >>> detector.generate_html_report()
  Output saved to report/report.html
  ```


pkgId: 52197b2016ea79c610a6c1bb36f020d7b5ee35c6b25a4e3782831de5fc873a72
name: python-copydf
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://github.com/conceptualio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copydf-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  A simple utility to copy a pandas dataframe to your local clipboard from a hosted instance of jupyter.


pkgId: 8e71e5702cb865bfcbaf0b564f5648b55a82dfa85b5a44f9be6f395b7bba869a
name: python-copytrav
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Copy traversables as directories.
url: https://github.com/OwenShepherd/copytrav
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-copytrav-0.0.5-1.src.rpm
checksum_type: sha256
description:
  Modern Python packaging has support for data files to be included with the
  package alongside source files. There are many times when you might want to
  have copies of these files on disk, often when being used with external or
  third-party programs, and this is the role copytrav fills. You may, of course,
  use [`importlib.resources.as_file(traversable)`](https://docs.python.org/3/library/importlib.resources.html#importlib.resources.as_file),
  but there are still other times when a context manager isn't good enough.



  `pip install copytrav`



  ```
  from copytrav import copy

  copy("mymodule.data", "path/to_directory", "output_path")
  ```


  ```
  from copytrav import copy

  copy("mymodule.data", "path/to_file", "output_path")
  ```


  ```
  from copytrav import copy

  copy("mymodule.data", dst="output_path")
  ```


  ```
  from copytrav import copy

  tempdir = copy("mymodule.data")
  ```


  clone the repository

  ```
  pip install -e .[dev]

  cd docs && make html
  ```


pkgId: c8ca35e2b2cda67518359e2e642ecb274986d10370266d3e1a69e55b91d53540
name: python-coqpit
arch: src
version: 0.0.17
epoch: 0
release: 1
summary: Simple (maybe too simple), light-weight config management through python data-classes.
url: https://github.com/erogol/coqpit
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coqpit-0.0.17-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/coqui-ai/coqpit/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/coqui-ai/coqpit/actions/workflows/main.yml)

  Simple, light-weight and no dependency config handling through python data classes with to/from JSON serialization/deserialization.

  Currently it is being used by [🐸TTS](https://github.com/coqui-ai/TTS).

  What I need from a ML configuration library...

  1. Fixing a general config schema in Python to guide users about expected values.

      Python is good but not universal. Sometimes you train a ML model and use it on a different platform. So, you
      need your model configuration file importable by other programming languages.

  2. Simple dynamic value and type checking with default values.

      If you are a beginner in a ML project, it is hard to guess the right values for your ML experiment. Therefore it is important
      to have some default values and know what range and type of input are expected for each field.

  4. Ability to decompose large configs.

      As you define more fields for the training dataset, data preprocessing, model parameters, etc., your config file tends
      to get quite large but in most cases, they can be decomposed, enabling flexibility and readability.

  5. Inheritance and nested configurations.

      Simply helps to keep configurations consistent and easier to maintain.

  6. Ability to override values from the command line when necessary.

      For instance, you might need to define a path for your dataset, and this changes for almost every run. Then the user
      should be able to override this value easily over the command line.

      It also allows easy hyper-parameter search without changing your original code. Basically, you can run different models
      with different parameters just using command line arguments.

  7. Defining dynamic or conditional config values.

      Sometimes you need to define certain values depending on the other values. Using python helps to define the underlying
      logic for such config values.

  8. No dependencies

      You don't want to install a ton of libraries for just configuration management. If you install one, then it
      is better to be just native python.


  - `Union` type dataclass fields cannot be parsed from console arguments due to the type ambiguity.
  - `JSON` is the only supported serialization format, although the others can be easily integrated.
  - `List`type with multiple item type annotations are not supported. (e.g. `List[int, str]`).
  - `dict` fields are parsed from console arguments as JSON str without type checking. (e.g `--val_dict '{"a":10, "b":100}'`).
  - `MISSING` fields cannot be avoided when parsing console arguments.




  ```python
  import os
  from dataclasses import asdict, dataclass, field
  from typing import List, Union
  from coqpit import MISSING, Coqpit, check_argument


  @dataclass
  class SimpleConfig(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_d: float = 10.21
      val_c: str = "Coqpit is great!"
      
      
      val_k: int = MISSING
      
      val_dict: dict = field(default_factory=lambda: {"val_aa": 10, "val_ss": "This is in a dict."})
      
      val_listoflist: List[List] = field(default_factory=lambda: [[1, 2], [3, 4]])
      val_listofunion: List[List[Union[str,int]]] = field(default_factory=lambda: [[1, 3], [1, "Hi!"]])

      def check_values(
          self,
      ):  # you can define explicit constraints on the fields using `check_argument()`
          """Check config fields"""
          c = asdict(self)
          check_argument("val_a", c, restricted=True, min_val=10, max_val=2056)
          check_argument("val_b", c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument("val_c", c, restricted=True)


  if __name__ == "__main__":
      file_path = os.path.dirname(os.path.abspath(__file__))
      config = SimpleConfig()

      
      try:
          k = config.val_k
      except AttributeError:
          print(" val_k needs a different value before accessing it.")
      config.val_k = 1000

      
      print(config.serialize())
      print(config.to_json())
      config.save_json(os.path.join(file_path, "example_config.json"))
      config.load_json(os.path.join(file_path, "example_config.json"))
      print(config.pprint())

      
      print(*config)
      print(dict(**config))

      
      config["val_a"] = -999
      print(config["val_a"])
      assert config.val_a == -999
  ```

  ```python
  import os
  from dataclasses import asdict, dataclass, field
  from coqpit import Coqpit, check_argument
  from typing import List, Union


  @dataclass
  class SimpleConfig(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_c: str = "Coqpit is great!"

      def check_values(self,):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_a', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_b', c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument('val_c', c, restricted=True)


  @dataclass
  class NestedConfig(Coqpit):
      val_d: int = 10
      val_e: int = None
      val_f: str = "Coqpit is great!"
      sc_list: List[SimpleConfig] = None
      sc: SimpleConfig = SimpleConfig()
      union_var: Union[List[SimpleConfig], SimpleConfig] = field(default_factory=lambda: [SimpleConfig(),SimpleConfig()])

      def check_values(self,):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_d', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_e', c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument('val_f', c, restricted=True)
          check_argument('sc_list', c, restricted=True, allow_none=True)
          check_argument('sc', c, restricted=True, allow_none=True)


  if __name__ == '__main__':
      file_path = os.path.dirname(os.path.abspath(__file__))
      
      config = NestedConfig()

      
      config.save_json(os.path.join(file_path, 'example_config.json'))
      
      config2 = NestedConfig(val_d=None, val_e=500, val_f=None, sc_list=None, sc=None, union_var=None)
      
      config2.load_json(os.path.join(file_path, 'example_config.json'))
      
      assert config == config2

      
      print(config.pprint())

      
      config_dict = config.to_dict()
      
      config2 = NestedConfig(val_d=None, val_e=500, val_f=None, sc_list=None, sc=None, union_var=None)
      
      config2.from_dict(config_dict)
      
      assert config == config2
  ```



  ```python
  import argparse
  import os
  from dataclasses import asdict, dataclass, field
  from typing import List

  from coqpit import Coqpit, check_argument
  import sys


  @dataclass
  class SimplerConfig(Coqpit):
      val_a: int = field(default=None, metadata={'help': 'this is val_a'})


  @dataclass
  class SimpleConfig(Coqpit):
      val_req: str # required field
      val_a: int = field(default=10,
                         metadata={'help': 'this is val_a of SimpleConfig'})
      val_b: int = field(default=None, metadata={'help': 'this is val_b'})
      nested_config: SimplerConfig = SimplerConfig()
      mylist_with_default: List[SimplerConfig] = field(
          default_factory=lambda:
          [SimplerConfig(val_a=100),
           SimplerConfig(val_a=999)],
          metadata={'help': 'list of SimplerConfig'})

      

      def check_values(self, ):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_a', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_b',
                         c,
                         restricted=True,
                         min_val=128,
                         max_val=4058,
                         allow_none=True)
          check_argument('val_req', c, restricted=True)


  def main():
      
      config_ref = SimpleConfig(val_req='this is different',
                                val_a=222,
                                val_b=999,
                                nested_config=SimplerConfig(val_a=333),
                                mylist_with_default=[
                                    SimplerConfig(val_a=222),
                                    SimplerConfig(val_a=111)
                                ])

      
      parsed = SimpleConfig.init_from_argparse()
      parsed.pprint()

      
      assert parsed == config_ref


  if __name__ == '__main__':
      sys.argv.extend(['--coqpit.val_req', 'this is different'])
      sys.argv.extend(['--coqpit.val_a', '222'])
      sys.argv.extend(['--coqpit.val_b', '999'])
      sys.argv.extend(['--coqpit.nested_config.val_a', '333'])
      sys.argv.extend(['--coqpit.mylist_with_default.0.val_a', '222'])
      sys.argv.extend(['--coqpit.mylist_with_default.1.val_a', '111'])
      main()
  ```


  ```python
  import os
  from dataclasses import dataclass
  from coqpit import Coqpit, check_argument


  @dataclass
  class CoqpitA(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_d: float = 10.21
      val_c: str = "Coqpit is great!"


  @dataclass
  class CoqpitB(Coqpit):
      val_d: int = 25
      val_e: int = 257
      val_f: float = -10.21
      val_g: str = "Coqpit is really great!"


  if __name__ == '__main__':
      file_path = os.path.dirname(os.path.abspath(__file__))
      coqpita = CoqpitA()
      coqpitb = CoqpitB()
      coqpitb.merge(coqpita)
      print(coqpitb.val_a)
      print(coqpitb.pprint())
  ```



  Install the pre-commit hook to automatically check your commits for style and hinting issues:

  ```bash
  $ python .pre-commit-2.12.1.pyz install
  ```

  <img src="https://static.scarf.sh/a.png?x-pxid=cd0232a8-ead2-4f1f-87f5-0dd8ec33ee51" />


pkgId: 3cc3fdb4b3807b0cffbd7400a11fbce85c3794a746ed56ccb93bf474b384b3c2
name: python-coqpit-config
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Simple (maybe too simple), light-weight config management through python data-classes.
url: https://pypi.org/project/coqpit-config/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coqpit-config-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - License](https://img.shields.io/pypi/l/coqpit-config)](https://github.com/idiap/coqui-ai-coqpit/blob/main/LICENSE.txt)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/coqpit-config)
  [![PyPI - Version](https://img.shields.io/pypi/v/coqpit-config)](https://pypi.org/project/coqpit-config)
  [![CI](https://github.com/idiap/coqui-ai-coqpit/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/idiap/coqui-ai-coqpit/actions/workflows/main.yml)

  Simple, light-weight and no dependency config handling through python data
  classes with to/from JSON serialization/deserialization.

  Fork of the [original, unmaintained repository](https://github.com/coqui-ai/coqpit). New PyPI package: [coqpit-config](https://pypi.org/project/coqpit-config)

  Currently it is being used by [coqui-tts](https://github.com/idiap/coqui-ai-TTS).


  What I need from a ML configuration library...

  1. Fixing a general config schema in Python to guide users about expected values.

      Python is good but not universal. Sometimes you train a ML model and use it on a different platform. So, you
      need your model configuration file importable by other programming languages.

  2. Simple dynamic value and type checking with default values.

      If you are a beginner in a ML project, it is hard to guess the right values for your ML experiment. Therefore it is important
      to have some default values and know what range and type of input are expected for each field.

  4. Ability to decompose large configs.

      As you define more fields for the training dataset, data preprocessing, model parameters, etc., your config file tends
      to get quite large but in most cases, they can be decomposed, enabling flexibility and readability.

  5. Inheritance and nested configurations.

      Simply helps to keep configurations consistent and easier to maintain.

  6. Ability to override values from the command line when necessary.

      For instance, you might need to define a path for your dataset, and this changes for almost every run. Then the user
      should be able to override this value easily over the command line.

      It also allows easy hyper-parameter search without changing your original code. Basically, you can run different models
      with different parameters just using command line arguments.

  7. Defining dynamic or conditional config values.

      Sometimes you need to define certain values depending on the other values. Using python helps to define the underlying
      logic for such config values.

  8. No dependencies

      You don't want to install a ton of libraries for just configuration management. If you install one, then it
      is better to be just native python.


  - `Union` type dataclass fields cannot be parsed from console arguments due to the type ambiguity.
  - `JSON` is the only supported serialization format, although the others can be easily integrated.
  - `List`type with multiple item type annotations are not supported. (e.g. `List[int, str]`).
  - `dict` fields are parsed from console arguments as JSON str without type checking. (e.g `--val_dict '{"a":10, "b":100}'`).
  - `MISSING` fields cannot be avoided when parsing console arguments.




  ```python
  import os
  from dataclasses import asdict, dataclass, field
  from typing import List, Union
  from coqpit import MISSING, Coqpit, check_argument


  @dataclass
  class SimpleConfig(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_d: float = 10.21
      val_c: str = "Coqpit is great!"
      
      
      val_k: int = MISSING
      
      val_dict: dict = field(default_factory=lambda: {"val_aa": 10, "val_ss": "This is in a dict."})
      
      val_listoflist: List[List] = field(default_factory=lambda: [[1, 2], [3, 4]])
      val_listofunion: List[List[Union[str,int]]] = field(default_factory=lambda: [[1, 3], [1, "Hi!"]])

      def check_values(
          self,
      ):  # you can define explicit constraints on the fields using `check_argument()`
          """Check config fields"""
          c = asdict(self)
          check_argument("val_a", c, restricted=True, min_val=10, max_val=2056)
          check_argument("val_b", c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument("val_c", c, restricted=True)


  if __name__ == "__main__":
      file_path = os.path.dirname(os.path.abspath(__file__))
      config = SimpleConfig()

      
      try:
          k = config.val_k
      except AttributeError:
          print(" val_k needs a different value before accessing it.")
      config.val_k = 1000

      
      print(config.serialize())
      print(config.to_json())
      config.save_json(os.path.join(file_path, "example_config.json"))
      config.load_json(os.path.join(file_path, "example_config.json"))
      print(config.pprint())

      
      print(*config)
      print(dict(**config))

      
      config["val_a"] = -999
      print(config["val_a"])
      assert config.val_a == -999
  ```

  ```python
  import os
  from dataclasses import asdict, dataclass, field
  from coqpit import Coqpit, check_argument
  from typing import List, Union


  @dataclass
  class SimpleConfig(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_c: str = "Coqpit is great!"

      def check_values(self,):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_a', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_b', c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument('val_c', c, restricted=True)


  @dataclass
  class NestedConfig(Coqpit):
      val_d: int = 10
      val_e: int = None
      val_f: str = "Coqpit is great!"
      sc_list: List[SimpleConfig] = None
      sc: SimpleConfig = SimpleConfig()
      union_var: Union[List[SimpleConfig], SimpleConfig] = field(default_factory=lambda: [SimpleConfig(),SimpleConfig()])

      def check_values(self,):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_d', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_e', c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument('val_f', c, restricted=True)
          check_argument('sc_list', c, restricted=True, allow_none=True)
          check_argument('sc', c, restricted=True, allow_none=True)


  if __name__ == '__main__':
      file_path = os.path.dirname(os.path.abspath(__file__))
      
      config = NestedConfig()

      
      config.save_json(os.path.join(file_path, 'example_config.json'))
      
      config2 = NestedConfig(val_d=None, val_e=500, val_f=None, sc_list=None, sc=None, union_var=None)
      
      config2.load_json(os.path.join(file_path, 'example_config.json'))
      
      assert config == config2

      
      print(config.pprint())

      
      config_dict = config.to_dict()
      
      config2 = NestedConfig(val_d=None, val_e=500, val_f=None, sc_list=None, sc=None, union_var=None)
      
      config2.from_dict(config_dict)
      
      assert config == config2
  ```



  ```python
  import argparse
  import os
  from dataclasses import asdict, dataclass, field
  from typing import List

  from coqpit import Coqpit, check_argument
  import sys


  @dataclass
  class SimplerConfig(Coqpit):
      val_a: int = field(default=None, metadata={'help': 'this is val_a'})


  @dataclass
  class SimpleConfig(Coqpit):
      val_req: str # required field
      val_a: int = field(default=10,
                         metadata={'help': 'this is val_a of SimpleConfig'})
      val_b: int = field(default=None, metadata={'help': 'this is val_b'})
      nested_config: SimplerConfig = SimplerConfig()
      mylist_with_default: List[SimplerConfig] = field(
          default_factory=lambda:
          [SimplerConfig(val_a=100),
           SimplerConfig(val_a=999)],
          metadata={'help': 'list of SimplerConfig'})

      

      def check_values(self, ):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_a', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_b',
                         c,
                         restricted=True,
                         min_val=128,
                         max_val=4058,
                         allow_none=True)
          check_argument('val_req', c, restricted=True)


  def main():
      
      config_ref = SimpleConfig(val_req='this is different',
                                val_a=222,
                                val_b=999,
                                nested_config=SimplerConfig(val_a=333),
                                mylist_with_default=[
                                    SimplerConfig(val_a=222),
                                    SimplerConfig(val_a=111)
                                ])

      
      parsed = SimpleConfig.init_from_argparse()
      parsed.pprint()

      
      assert parsed == config_ref


  if __name__ == '__main__':
      sys.argv.extend(['--coqpit.val_req', 'this is different'])
      sys.argv.extend(['--coqpit.val_a', '222'])
      sys.argv.extend(['--coqpit.val_b', '999'])
      sys.argv.extend(['--coqpit.nested_config.val_a', '333'])
      sys.argv.extend(['--coqpit.mylist_with_default.0.val_a', '222'])
      sys.argv.extend(['--coqpit.mylist_with_default.1.val_a', '111'])
      main()
  ```


  ```python
  import os
  from dataclasses import dataclass
  from coqpit import Coqpit, check_argument


  @dataclass
  class CoqpitA(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_d: float = 10.21
      val_c: str = "Coqpit is great!"


  @dataclass
  class CoqpitB(Coqpit):
      val_d: int = 25
      val_e: int = 257
      val_f: float = -10.21
      val_g: str = "Coqpit is really great!"


  if __name__ == '__main__':
      file_path = os.path.dirname(os.path.abspath(__file__))
      coqpita = CoqpitA()
      coqpitb = CoqpitB()
      coqpitb.merge(coqpita)
      print(coqpitb.val_a)
      print(coqpitb.pprint())
  ```



  Install the pre-commit hook to automatically check your commits for style and hinting issues:

  ```bash
  uv run pre-commit install
  ```


pkgId: ff714b796809b4c494f46b24d77a69fcb25c659358a2fa293083141d70c4e4e7
name: python-coqui-tts
arch: src
version: 0.25.0
epoch: 0
release: 1
summary: Deep learning for Text to Speech.
url: https://github.com/idiap/coqui-ai-TTS
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coqui-tts-0.25.0-1.src.rpm
checksum_type: sha256
description:
  - 📣 Fork of the [original, unmaintained repository](https://github.com/coqui-ai/TTS). New PyPI package: [coqui-tts](https://pypi.org/project/coqui-tts)
  - 📣 [OpenVoice](https://github.com/myshell-ai/OpenVoice) models now available for voice conversion.
  - 📣 Prebuilt wheels are now also published for Mac and Windows (in addition to Linux as before) for easier installation across platforms.
  - 📣 ⓍTTSv2 is here with 17 languages and better performance across the board. ⓍTTS can stream with <200ms latency.
  - 📣 ⓍTTS fine-tuning code is out. Check the [example recipes](https://github.com/idiap/coqui-ai-TTS/tree/dev/recipes/ljspeech).
  - 📣 [🐶Bark](https://github.com/suno-ai/bark) is now available for inference with unconstrained voice cloning. [Docs](https://coqui-tts.readthedocs.io/en/latest/models/bark.html)
  - 📣 You can use [Fairseq models in ~1100 languages](https://github.com/facebookresearch/fairseq/tree/main/examples/mms) with 🐸TTS.




  **🐸TTS is a library for advanced Text-to-Speech generation.**

  🚀 Pretrained models in +1100 languages.

  🛠️ Tools for training new models and fine-tuning existing models in any language.

  📚 Utilities for dataset analysis and curation.
  ______________________________________________________________________

  [![Discord](https://img.shields.io/discord/1037326658807533628?color=%239B59B6&label=chat%20on%20discord)](https://discord.gg/5eXr5seRrv)
  [![License](<https://img.shields.io/badge/License-MPL%202.0-brightgreen.svg>)](https://opensource.org/licenses/MPL-2.0)
  [![PyPI version](https://badge.fury.io/py/coqui-tts.svg)](https://badge.fury.io/py/coqui-tts)
  [![Downloads](https://pepy.tech/badge/coqui-tts)](https://pepy.tech/project/coqui-tts)
  [![DOI](https://zenodo.org/badge/265612440.svg)](https://zenodo.org/badge/latestdoi/265612440)

  ![GithubActions](https://github.com/idiap/coqui-ai-TTS/actions/workflows/tests.yml/badge.svg)
  ![GithubActions](https://github.com/idiap/coqui-ai-TTS/actions/workflows/docker.yaml/badge.svg)
  ![GithubActions](https://github.com/idiap/coqui-ai-TTS/actions/workflows/style_check.yml/badge.svg)
  [![Docs](<https://readthedocs.org/projects/coqui-tts/badge/?version=latest&style=plastic>)](https://coqui-tts.readthedocs.io/en/latest/)

  </div>

  ______________________________________________________________________


  Please use our dedicated channels for questions and discussion. Help is much more valuable if it's shared publicly so that more people can benefit from it.

  | Type                                         | Platforms                           |
  | -------------------------------------------- | ----------------------------------- |
  | 🚨 **Bug Reports, Feature Requests & Ideas** | [GitHub Issue Tracker]              |
  | 👩‍💻 **Usage Questions**                       | [GitHub Discussions]                |
  | 🗯 **General Discussion**                    | [GitHub Discussions] or [Discord]   |

  [github issue tracker]: https://github.com/idiap/coqui-ai-TTS/issues
  [github discussions]: https://github.com/idiap/coqui-ai-TTS/discussions
  [discord]: https://discord.gg/5eXr5seRrv
  [Tutorials and Examples]: https://github.com/coqui-ai/TTS/wiki/TTS-Notebooks-and-Tutorials

  The [issues](https://github.com/coqui-ai/TTS/issues) and
  [discussions](https://github.com/coqui-ai/TTS/discussions) in the original
  repository are also still a useful source of information.



  | Type                            | Links                               |
  | ------------------------------- | --------------------------------------- |
  | 💼 **Documentation**              | [ReadTheDocs](https://coqui-tts.readthedocs.io/en/latest/)
  | 💾 **Installation**               | [TTS/README.md](https://github.com/idiap/coqui-ai-TTS/tree/dev#installation)|
  | 👩‍💻 **Contributing**               | [CONTRIBUTING.md](https://github.com/idiap/coqui-ai-TTS/blob/main/CONTRIBUTING.md)|
  | 🚀 **Released Models**            | [Standard models](https://github.com/idiap/coqui-ai-TTS/blob/dev/TTS/.models.json) and [Fairseq models in ~1100 languages](https://github.com/idiap/coqui-ai-TTS#example-text-to-speech-using-fairseq-models-in-1100-languages-)|


  - High-performance Deep Learning models for Text2Speech tasks. See lists of models below.
  - Fast and efficient model training.
  - Detailed training logs on the terminal and Tensorboard.
  - Support for Multi-speaker TTS.
  - Efficient, flexible, lightweight but feature complete `Trainer API`.
  - Released and ready-to-use models.
  - Tools to curate Text2Speech datasets under```dataset_analysis```.
  - Utilities to use and test your models.
  - Modular (but not too much) code base enabling easy implementation of new ideas.



  - Tacotron: [paper](https://arxiv.org/abs/1703.10135)
  - Tacotron2: [paper](https://arxiv.org/abs/1712.05884)
  - Glow-TTS: [paper](https://arxiv.org/abs/2005.11129)
  - Speedy-Speech: [paper](https://arxiv.org/abs/2008.03802)
  - Align-TTS: [paper](https://arxiv.org/abs/2003.01950)
  - FastPitch: [paper](https://arxiv.org/pdf/2006.06873.pdf)
  - FastSpeech: [paper](https://arxiv.org/abs/1905.09263)
  - FastSpeech2: [paper](https://arxiv.org/abs/2006.04558)
  - SC-GlowTTS: [paper](https://arxiv.org/abs/2104.05557)
  - Capacitron: [paper](https://arxiv.org/abs/1906.03402)
  - OverFlow: [paper](https://arxiv.org/abs/2211.06892)
  - Neural HMM TTS: [paper](https://arxiv.org/abs/2108.13320)
  - Delightful TTS: [paper](https://arxiv.org/abs/2110.12612)


  - ⓍTTS: [blog](https://coqui.ai/blog/tts/open_xtts)
  - VITS: [paper](https://arxiv.org/pdf/2106.06103)
  - 🐸 YourTTS: [paper](https://arxiv.org/abs/2112.02418)
  - 🐢 Tortoise: [orig. repo](https://github.com/neonbjb/tortoise-tts)
  - 🐶 Bark: [orig. repo](https://github.com/suno-ai/bark)


  - Guided Attention: [paper](https://arxiv.org/abs/1710.08969)
  - Forward Backward Decoding: [paper](https://arxiv.org/abs/1907.09006)
  - Graves Attention: [paper](https://arxiv.org/abs/1910.10288)
  - Double Decoder Consistency: [blog](https://erogol.com/solving-attention-problems-of-tts-models-with-double-decoder-consistency/)
  - Dynamic Convolutional Attention: [paper](https://arxiv.org/pdf/1910.10288.pdf)
  - Alignment Network: [paper](https://arxiv.org/abs/2108.10447)


  - GE2E: [paper](https://arxiv.org/abs/1710.10467)
  - Angular Loss: [paper](https://arxiv.org/pdf/2003.11982.pdf)


  - MelGAN: [paper](https://arxiv.org/abs/1910.06711)
  - MultiBandMelGAN: [paper](https://arxiv.org/abs/2005.05106)
  - ParallelWaveGAN: [paper](https://arxiv.org/abs/1910.11480)
  - GAN-TTS discriminators: [paper](https://arxiv.org/abs/1909.11646)
  - WaveRNN: [origin](https://github.com/fatchord/WaveRNN/)
  - WaveGrad: [paper](https://arxiv.org/abs/2009.00713)
  - HiFiGAN: [paper](https://arxiv.org/abs/2010.05646)
  - UnivNet: [paper](https://arxiv.org/abs/2106.07889)


  - FreeVC: [paper](https://arxiv.org/abs/2210.15418)
  - OpenVoice: [technical report](https://arxiv.org/abs/2312.01479)

  You can also help us implement more models.


  🐸TTS is tested on Ubuntu 22.04 with **python >= 3.9, < 3.13.**.

  If you are only interested in [synthesizing speech](https://coqui-tts.readthedocs.io/en/latest/inference.html) with the released 🐸TTS models, installing from PyPI is the easiest option.

  ```bash
  pip install coqui-tts
  ```

  If you plan to code or train models, clone 🐸TTS and install it locally.

  ```bash
  git clone https://github.com/idiap/coqui-ai-TTS
  cd coqui-ai-TTS
  pip install -e .
  ```



  The following extras allow the installation of optional dependencies:

  | Name | Description |
  |------|-------------|
  | `all` | All optional dependencies |
  | `notebooks` | Dependencies only used in notebooks |
  | `server` | Dependencies to run the TTS server |
  | `bn` | Bangla G2P |
  | `ja` | Japanese G2P |
  | `ko` | Korean G2P |
  | `zh` | Chinese G2P |
  | `languages` | All language-specific dependencies |

  You can install extras with one of the following commands:

  ```bash
  pip install coqui-tts[server,ja]
  pip install -e .[server,ja]
  ```



  If you are on Ubuntu (Debian), you can also run following commands for installation.

  ```bash
  make system-deps  # intended to be used on Ubuntu (Debian). Let us know if you have a different OS.
  make install
  ```

  If you are on Windows, 👑@GuyPaddock wrote installation instructions
  [here](https://stackoverflow.com/questions/66726331/how-can-i-run-mozilla-tts-coqui-tts-training-with-cuda-on-a-windows-system)
  (note that these are out of date, e.g. you need to have at least Python 3.9).



  You can also try TTS without install with the docker image.
  Simply run the following command and you will be able to run TTS without installing it.

  ```bash
  docker run --rm -it -p 5002:5002 --entrypoint /bin/bash ghcr.io/coqui-ai/tts-cpu
  python3 TTS/server/server.py --list_models #To get the list of available models
  python3 TTS/server/server.py --model_name tts_models/en/vctk/vits # To start a server
  ```

  You can then enjoy the TTS server [here](http://[::1]:5002/)
  More details about the docker images (like GPU support) can be found
  [here](https://coqui-tts.readthedocs.io/en/latest/docker_images.html)








  ```python
  import torch
  from TTS.api import TTS


  device = "cuda" if torch.cuda.is_available() else "cpu"


  print(TTS().list_models())


  tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)




  wav = tts.tts(text="Hello world!", speaker_wav="my/cloning/audio.wav", language="en")

  tts.tts_to_file(text="Hello world!", speaker_wav="my/cloning/audio.wav", language="en", file_path="output.wav")
  ```



  ```python

  tts = TTS(model_name="tts_models/de/thorsten/tacotron2-DDC", progress_bar=False).to(device)


  tts.tts_to_file(text="Ich bin eine Testnachricht.", file_path=OUTPUT_PATH)


  tts = TTS(model_name="tts_models/multilingual/multi-dataset/your_tts", progress_bar=False).to(device)
  tts.tts_to_file("This is voice cloning.", speaker_wav="my/cloning/audio.wav", language="en", file_path="output.wav")
  tts.tts_to_file("C'est le clonage de la voix.", speaker_wav="my/cloning/audio.wav", language="fr-fr", file_path="output.wav")
  tts.tts_to_file("Isso é clonagem de voz.", speaker_wav="my/cloning/audio.wav", language="pt-br", file_path="output.wav")
  ```



  Converting the voice in `source_wav` to the voice of `target_wav`

  ```python
  tts = TTS(model_name="voice_conversion_models/multilingual/vctk/freevc24", progress_bar=False).to("cuda")
  tts.voice_conversion_to_file(source_wav="my/source.wav", target_wav="my/target.wav", file_path="output.wav")
  ```

  Other available voice conversion models:
  - `voice_conversion_models/multilingual/multi-dataset/openvoice_v1`
  - `voice_conversion_models/multilingual/multi-dataset/openvoice_v2`



  This way, you can clone voices by using any model in 🐸TTS. The FreeVC model is
  used for voice conversion after synthesizing speech.

  ```python

  tts = TTS("tts_models/de/thorsten/tacotron2-DDC")
  tts.tts_with_vc_to_file(
      "Wie sage ich auf Italienisch, dass ich dich liebe?",
      speaker_wav="target/speaker.wav",
      file_path="output.wav"
  )
  ```


  For Fairseq models, use the following name format: `tts_models/<lang-iso_code>/fairseq/vits`.
  You can find the language ISO codes [here](https://dl.fbaipublicfiles.com/mms/tts/all-tts-languages.html)
  and learn about the Fairseq models [here](https://github.com/facebookresearch/fairseq/tree/main/examples/mms).

  ```python

  api = TTS("tts_models/deu/fairseq/vits")
  api.tts_to_file(
      "Wie sage ich auf Italienisch, dass ich dich liebe?",
      file_path="output.wav"
  )
  ```



  <!-- begin-tts-readme -->

  Synthesize speech on command line.

  You can either use your trained model or choose a model from the provided list.

  If you don't specify any models, then it uses LJSpeech based English model.



  - List provided models:

    ```
    $ tts --list_models
    ```

  - Get model info (for both tts_models and vocoder_models):

    - Query by type/name:
      The model_info_by_name uses the name as it from the --list_models.
      ```
      $ tts --model_info_by_name "<model_type>/<language>/<dataset>/<model_name>"
      ```
      For example:
      ```
      $ tts --model_info_by_name tts_models/tr/common-voice/glow-tts
      $ tts --model_info_by_name vocoder_models/en/ljspeech/hifigan_v2
      ```
    - Query by type/idx:
      The model_query_idx uses the corresponding idx from --list_models.

      ```
      $ tts --model_info_by_idx "<model_type>/<model_query_idx>"
      ```

      For example:

      ```
      $ tts --model_info_by_idx tts_models/3
      ```

    - Query info for model info by full name:
      ```
      $ tts --model_info_by_name "<model_type>/<language>/<dataset>/<model_name>"
      ```

  - Run TTS with default models:

    ```
    $ tts --text "Text for TTS" --out_path output/path/speech.wav
    ```

  - Run TTS and pipe out the generated TTS wav file data:

    ```
    $ tts --text "Text for TTS" --pipe_out --out_path output/path/speech.wav | aplay
    ```

  - Run a TTS model with its default vocoder model:

    ```
    $ tts --text "Text for TTS" --model_name "<model_type>/<language>/<dataset>/<model_name>" --out_path output/path/speech.wav
    ```

    For example:

    ```
    $ tts --text "Text for TTS" --model_name "tts_models/en/ljspeech/glow-tts" --out_path output/path/speech.wav
    ```

  - Run with specific TTS and vocoder models from the list:

    ```
    $ tts --text "Text for TTS" --model_name "<model_type>/<language>/<dataset>/<model_name>" --vocoder_name "<model_type>/<language>/<dataset>/<model_name>" --out_path output/path/speech.wav
    ```

    For example:

    ```
    $ tts --text "Text for TTS" --model_name "tts_models/en/ljspeech/glow-tts" --vocoder_name "vocoder_models/en/ljspeech/univnet" --out_path output/path/speech.wav
    ```

  - Run your own TTS model (Using Griffin-Lim Vocoder):

    ```
    $ tts --text "Text for TTS" --model_path path/to/model.pth --config_path path/to/config.json --out_path output/path/speech.wav
    ```

  - Run your own TTS and Vocoder models:

    ```
    $ tts --text "Text for TTS" --model_path path/to/model.pth --config_path path/to/config.json --out_path output/path/speech.wav
        --vocoder_path path/to/vocoder.pth --vocoder_config_path path/to/vocoder_config.json
    ```



  - List the available speakers and choose a <speaker_id> among them:

    ```
    $ tts --model_name "<language>/<dataset>/<model_name>"  --list_speaker_idxs
    ```

  - Run the multi-speaker TTS model with the target speaker ID:

    ```
    $ tts --text "Text for TTS." --out_path output/path/speech.wav --model_name "<language>/<dataset>/<model_name>"  --speaker_idx <speaker_id>
    ```

  - Run your own multi-speaker TTS model:

    ```
    $ tts --text "Text for TTS" --out_path output/path/speech.wav --model_path path/to/model.pth --config_path path/to/config.json --speakers_file_path path/to/speaker.json --speaker_idx <speaker_id>
    ```



  ```
  $ tts --out_path output/path/speech.wav --model_name "<language>/<dataset>/<model_name>" --source_wav <path/to/speaker/wav> --target_wav <path/to/reference/wav>
  ```

  <!-- end-tts-readme -->


  ```
  |- notebooks/       (Jupyter Notebooks for model evaluation, parameter selection and data analysis.)
  |- utils/           (common utilities.)
  |- TTS
      |- bin/             (folder for all the executables.)
        |- train*.py                  (train your target model.)
        |- ...
      |- tts/             (text to speech models)
          |- layers/          (model layer definitions)
          |- models/          (model definitions)
          |- utils/           (model specific utilities.)
      |- speaker_encoder/ (Speaker Encoder models.)
          |- (same)
      |- vocoder/         (Vocoder models.)
          |- (same)
      |- vc/         (Voice conversion models.)
          |- (same)
  ```


pkgId: 1a14eaf8f47bbbe8a3bce1953f816faf5d1f98d957567a000dd38289691e425b
name: python-coqui-tts-trainer
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: General purpose model trainer for PyTorch that is more flexible than it should be, by 🐸Coqui.
url: https://github.com/idiap/coqui-ai-Trainer
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coqui-tts-trainer-0.1.5-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img src="https://user-images.githubusercontent.com/1402048/151947958-0bcadf38-3a82-4b4e-96b4-a38d3721d737.png" align="right" height="255px" /></p>



  [![PyPI - License](https://img.shields.io/pypi/l/coqui-tts-trainer)](https://github.com/idiap/coqui-ai-Trainer/blob/main/LICENSE.txt)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/coqui-tts-trainer)
  [![PyPI - Version](https://img.shields.io/pypi/v/coqui-tts-trainer)](https://pypi.org/project/coqui-tts-trainer)
  ![GithubActions](https://github.com/idiap/coqui-ai-Trainer/actions/workflows/tests.yml/badge.svg)
  ![GithubActions](https://github.com/idiap/coqui-ai-Trainer/actions/workflows/style_check.yml/badge.svg)

  An opinionated general purpose model trainer on PyTorch with a simple code base.
  Fork of the [original, unmaintained repository](https://github.com/coqui-ai/Trainer). New PyPI package: [coqui-tts-trainer](https://pypi.org/project/coqui-tts-trainer)



  From Github:

  ```console
  git clone https://github.com/idiap/coqui-ai-Trainer
  cd coqui-ai-Trainer
  make install
  ```

  From PyPI:

  ```console
  pip install coqui-tts-trainer
  ```


  Subclass and overload the functions in the [```TrainerModel()```](trainer/model.py)



  See the [MNIST example](examples/train_mnist.py).



  With 👟 you can define the whole optimization cycle as you want as the in GAN example below. It enables more
  under-the-hood control and flexibility for more advanced training loops.

  You just have to use the ```scaled_backward()``` function to handle mixed precision training.

  ```python
  ...

  def optimize(self, batch, trainer):
      imgs, _ = batch

      
      z = torch.randn(imgs.shape[0], 100)
      z = z.type_as(imgs)

      
      imgs_gen = self.generator(z)
      logits = self.discriminator(imgs_gen.detach())
      fake = torch.zeros(imgs.size(0), 1)
      fake = fake.type_as(imgs)
      loss_fake = trainer.criterion(logits, fake)

      valid = torch.ones(imgs.size(0), 1)
      valid = valid.type_as(imgs)
      logits = self.discriminator(imgs)
      loss_real = trainer.criterion(logits, valid)
      loss_disc = (loss_real + loss_fake) / 2

      
      _, _ = self.scaled_backward(loss_disc, None, trainer, trainer.optimizer[0])

      if trainer.total_steps_done % trainer.grad_accum_steps == 0:
          trainer.optimizer[0].step()
          trainer.optimizer[0].zero_grad()

      
      imgs_gen = self.generator(z)

      valid = torch.ones(imgs.size(0), 1)
      valid = valid.type_as(imgs)

      logits = self.discriminator(imgs_gen)
      loss_gen = trainer.criterion(logits, valid)

      
      _, _ = self.scaled_backward(loss_gen, None, trainer, trainer.optimizer[1])
      if trainer.total_steps_done % trainer.grad_accum_steps == 0:
          trainer.optimizer[1].step()
          trainer.optimizer[1].zero_grad()
      return {"model_outputs": logits}, {"loss_gen": loss_gen, "loss_disc": loss_disc}

  ...
  ```

  See the [GAN training example](examples/train_simple_gan.py) with Gradient Accumulation



  see the test script [here](tests/test_train_batch_size_finder.py) for training with batch size finder.


  The batch size finder starts at a default BS(defaults to 2048 but can also be user defined) and searches for the largest batch size that can fit on your hardware. you should expect for it to run multiple trainings until it finds it. to use it instead of calling ```trainer.fit()``` youll call ```trainer.fit_with_largest_batch_size(starting_batch_size=2048)``` with ```starting_batch_size``` being the batch the size you want to start the search with. very useful if you are wanting to use as much gpu mem as possible.



  ```console
  $ python -m trainer.distribute --script path/to/your/train.py --gpus "0,1"
  ```

  We don't use ```.spawn()``` to initiate multi-gpu training since it causes certain limitations.

  - Everything must the pickable.
  - ```.spawn()``` trains the model in subprocesses and the model in the main process is not updated.
  - DataLoader with N processes gets really slow when the N is large.



  Setting `use_accelerate` in `TrainingArgs` to `True` will enable training with Accelerate.

  You can also use it for multi-gpu or distributed training.

  ```console
  CUDA_VISIBLE_DEVICES="0,1,2" accelerate launch --multi_gpu --num_processes 3 train_recipe_autoregressive_prompt.py
  ```

  See the [Accelerate docs](https://huggingface.co/docs/accelerate/basic_tutorials/launch).


  👟 Supports callbacks to customize your runs. You can either set callbacks in your model implementations or give them
  explicitly to the Trainer.

  Please check `trainer.utils.callbacks` to see available callbacks.

  Here is how you provide an explicit call back to a 👟Trainer object for weight reinitialization.

  ```python
  def my_callback(trainer):
      print(" > My callback was called.")

  trainer = Trainer(..., callbacks={"on_init_end": my_callback})
  trainer.fit()
  ```



  - Create the torch profiler as you like and pass it to the trainer.
      ```python
      import torch
      profiler = torch.profiler.profile(
          activities=[
              torch.profiler.ProfilerActivity.CPU,
              torch.profiler.ProfilerActivity.CUDA,
          ],
          schedule=torch.profiler.schedule(wait=1, warmup=1, active=3, repeat=2),
          on_trace_ready=torch.profiler.tensorboard_trace_handler("./profiler/"),
          record_shapes=True,
          profile_memory=True,
          with_stack=True,
      )
      prof = trainer.profile_fit(profiler, epochs=1, small_run=64)
      then run Tensorboard
      ```
  - Run the tensorboard.
      ```console
      tensorboard --logdir="./profiler/"
      ```


  - [Tensorboard](https://www.tensorflow.org/tensorboard) - actively maintained
  - [ClearML](https://clear.ml/) - actively maintained
  - [MLFlow](https://mlflow.org/)
  - [Aim](https://aimstack.io/)
  - [WandDB](https://wandb.ai/)

  To add a new logger, you must subclass [BaseDashboardLogger](trainer/logging/base_dash_logger.py) and overload its functions.


pkgId: 7207ce2ad4e81a7ef6bc7d1eadbadfd4a13ea53f571ff18d7a6f0877383e66d4
name: python-coqui-tts-trainer
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: General purpose model trainer for PyTorch that is more flexible than it should be, by 🐸Coqui.
url: https://github.com/idiap/coqui-ai-Trainer
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coqui-tts-trainer-0.1.7-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img src="https://user-images.githubusercontent.com/1402048/151947958-0bcadf38-3a82-4b4e-96b4-a38d3721d737.png" align="right" height="255px" /></p>



  [![PyPI - License](https://img.shields.io/pypi/l/coqui-tts-trainer)](https://github.com/idiap/coqui-ai-Trainer/blob/main/LICENSE.txt)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/coqui-tts-trainer)
  [![PyPI - Version](https://img.shields.io/pypi/v/coqui-tts-trainer)](https://pypi.org/project/coqui-tts-trainer)
  ![GithubActions](https://github.com/idiap/coqui-ai-Trainer/actions/workflows/tests.yml/badge.svg)
  ![GithubActions](https://github.com/idiap/coqui-ai-Trainer/actions/workflows/style_check.yml/badge.svg)

  An opinionated general purpose model trainer on PyTorch with a simple code base.
  Fork of the [original, unmaintained repository](https://github.com/coqui-ai/Trainer). New PyPI package: [coqui-tts-trainer](https://pypi.org/project/coqui-tts-trainer)



  From PyPI:

  ```console
  pip install coqui-tts-trainer
  ```

  From Github:

  ```console
  git clone https://github.com/idiap/coqui-ai-Trainer
  cd coqui-ai-Trainer
  pip install -e .
  ```


  Subclass and overload the functions in the [```TrainerModel()```](trainer/model.py)



  See the [MNIST example](examples/train_mnist.py).



  With 👟 you can define the whole optimization cycle as you want as the in GAN example below. It enables more
  under-the-hood control and flexibility for more advanced training loops.

  You just have to use the ```scaled_backward()``` function to handle mixed precision training.

  ```python
  ...

  def optimize(self, batch, trainer):
      imgs, _ = batch

      
      z = torch.randn(imgs.shape[0], 100)
      z = z.type_as(imgs)

      
      imgs_gen = self.generator(z)
      logits = self.discriminator(imgs_gen.detach())
      fake = torch.zeros(imgs.size(0), 1)
      fake = fake.type_as(imgs)
      loss_fake = trainer.criterion(logits, fake)

      valid = torch.ones(imgs.size(0), 1)
      valid = valid.type_as(imgs)
      logits = self.discriminator(imgs)
      loss_real = trainer.criterion(logits, valid)
      loss_disc = (loss_real + loss_fake) / 2

      
      _, _ = self.scaled_backward(loss_disc, None, trainer, trainer.optimizer[0])

      if trainer.total_steps_done % trainer.grad_accum_steps == 0:
          trainer.optimizer[0].step()
          trainer.optimizer[0].zero_grad()

      
      imgs_gen = self.generator(z)

      valid = torch.ones(imgs.size(0), 1)
      valid = valid.type_as(imgs)

      logits = self.discriminator(imgs_gen)
      loss_gen = trainer.criterion(logits, valid)

      
      _, _ = self.scaled_backward(loss_gen, None, trainer, trainer.optimizer[1])
      if trainer.total_steps_done % trainer.grad_accum_steps == 0:
          trainer.optimizer[1].step()
          trainer.optimizer[1].zero_grad()
      return {"model_outputs": logits}, {"loss_gen": loss_gen, "loss_disc": loss_disc}

  ...
  ```

  See the [GAN training example](examples/train_simple_gan.py) with Gradient Accumulation



  see the test script [here](tests/test_train_batch_size_finder.py) for training with batch size finder.


  The batch size finder starts at a default BS(defaults to 2048 but can also be user defined) and searches for the largest batch size that can fit on your hardware. you should expect for it to run multiple trainings until it finds it. to use it instead of calling ```trainer.fit()``` youll call ```trainer.fit_with_largest_batch_size(starting_batch_size=2048)``` with ```starting_batch_size``` being the batch the size you want to start the search with. very useful if you are wanting to use as much gpu mem as possible.



  ```console
  $ python -m trainer.distribute --script path/to/your/train.py --gpus "0,1"
  ```

  We don't use ```.spawn()``` to initiate multi-gpu training since it causes certain limitations.

  - Everything must the pickable.
  - ```.spawn()``` trains the model in subprocesses and the model in the main process is not updated.
  - DataLoader with N processes gets really slow when the N is large.



  Setting `use_accelerate` in `TrainingArgs` to `True` will enable training with Accelerate.

  You can also use it for multi-gpu or distributed training.

  ```console
  CUDA_VISIBLE_DEVICES="0,1,2" accelerate launch --multi_gpu --num_processes 3 train_recipe_autoregressive_prompt.py
  ```

  See the [Accelerate docs](https://huggingface.co/docs/accelerate/basic_tutorials/launch).


  👟 Supports callbacks to customize your runs. You can either set callbacks in your model implementations or give them
  explicitly to the Trainer.

  Please check `trainer.utils.callbacks` to see available callbacks.

  Here is how you provide an explicit call back to a 👟Trainer object for weight reinitialization.

  ```python
  def my_callback(trainer):
      print(" > My callback was called.")

  trainer = Trainer(..., callbacks={"on_init_end": my_callback})
  trainer.fit()
  ```



  - Create the torch profiler as you like and pass it to the trainer.
      ```python
      import torch
      profiler = torch.profiler.profile(
          activities=[
              torch.profiler.ProfilerActivity.CPU,
              torch.profiler.ProfilerActivity.CUDA,
          ],
          schedule=torch.profiler.schedule(wait=1, warmup=1, active=3, repeat=2),
          on_trace_ready=torch.profiler.tensorboard_trace_handler("./profiler/"),
          record_shapes=True,
          profile_memory=True,
          with_stack=True,
      )
      prof = trainer.profile_fit(profiler, epochs=1, small_run=64)
      then run Tensorboard
      ```
  - Run the tensorboard.
      ```console
      tensorboard --logdir="./profiler/"
      ```


  - [Tensorboard](https://www.tensorflow.org/tensorboard) - actively maintained
  - [ClearML](https://clear.ml/) - actively maintained
  - [MLFlow](https://mlflow.org/)
  - [Aim](https://aimstack.io/)
  - [WandDB](https://wandb.ai/)

  To add a new logger, you must subclass [BaseDashboardLogger](trainer/logging/base_dash_logger.py) and overload its functions.


pkgId: 6ff8105977ba87e717274d4aed9ae2394b68b7cdc605f047d5323050a470e66f
name: python-corallium
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Shared functionality for the calcipy-ecosystem
url: https://github.com/kyleking/corallium
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-corallium-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Shared functionality for the calcipy-ecosystem.



  1. `poetry add corallium`

  1. Take advantage of the logger or other common functionality

      ```sh
      form corallium.log import LOGGER

      LOGGER.info('Hello!')
      ```



  <!-- < TODO: Show an example (screenshots, terminal recording, etc.) >

  - **log**: TBD
  - **pretty_process**: TBD
  - **shell**: TBD
  - **file_helpers**: TBD
  - **tomllib**: This is a lightweight wrapper to backport `tomli` in place of `tomllib` until we can use Python >3.11. Use with `from corallium.tomllib import tomllib`
  - **dot_dict**: has one function `ddict`, which is a light-weight wrapper around whatever is the most [maintained dotted-dictionary package in Python](https://pypi.org/search/?q=dot+accessible+dictionary&o=). Dotted dictionaries can sometimes improve code readability, but they aren't a one-size fits all solution. Sometimes `attr.s` or `dataclass` are more appropriate.
      - The benefit of this wrapper is a stable interface that can be replaced with better internal implementations, such [Bunch](https://pypi.org/project/bunch/), [Chunk](https://pypi.org/project/chunk/), [Munch](https://pypi.org/project/munch/), [flexible-dotdict](https://pypi.org/project/flexible-dotdict/), [classy-json](https://pypi.org/project/classy-json/), and now [Python-Box](https://pypi.org/project/python-box/)
   -->

  For more example code, see the [scripts] directory or the [tests].



  See the `Open Issues` and/or the [CODE_TAG_SUMMARY]. For release history, see the [CHANGELOG].



  We welcome pull requests! For your pull request to be accepted smoothly, we suggest that you first open a GitHub issue to discuss your idea. For resources on getting started with the code base, see the below documentation:

  - [DEVELOPER_GUIDE]
  - [STYLE_GUIDE]



  We follow the [Contributor Covenant Code of Conduct][contributor-covenant].



  We try to reasonably meet most aspects of the "OpenSSF scorecard" from [Open Source Insights](https://deps.dev/pypi/corallium)



  If you have any security issue to report, please contact the project maintainers privately. You can reach us at [dev.act.kyle@gmail.com](mailto:dev.act.kyle@gmail.com).



  [LICENSE]

  [changelog]: https://corallium.kyleking.me/docs/CHANGELOG
  [code_tag_summary]: https://corallium.kyleking.me/docs/CODE_TAG_SUMMARY
  [contributor-covenant]: https://www.contributor-covenant.org
  [developer_guide]: https://corallium.kyleking.me/docs/DEVELOPER_GUIDE
  [license]: https://github.com/kyleking/corallium/blob/main/LICENSE
  [scripts]: https://github.com/kyleking/corallium/blob/main/scripts
  [style_guide]: https://corallium.kyleking.me/docs/STYLE_GUIDE
  [tests]: https://github.com/kyleking/corallium/blob/main/tests


pkgId: 249d80586ff7c5d7987aa91ba3513b8f1e9189896a53dd4ae69afd0c2d518662
name: python-coralogix
arch: src
version: 0.2.6.6
epoch: 0
release: 1
summary: Coralogix Python SDK
url: http://www.coralogix.com/
rpm_license: Apache Software License v2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coralogix-0.2.6.6-1.src.rpm
checksum_type: sha256
description:
  Coralogix is a software analytics SaaS platform that drastically improves the delivery & maintenance process for software providers. Using proprietary machine learning algorithms, Coralogix helps over 100 businesses reduce their issue resolution time, increase system uptime, improve customer satisfaction and decrease maintenance costs.
  Learn more at http://www.coralogix.com.


pkgId: 9a4e8e0c2c40ce2fc77c73daab5b7d0c674404953baa7d1032881bb6458b61df
name: python-coralogix-logger
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: Coralogix Python SDK
url: http://www.coralogix.com/
rpm_license: Apache Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coralogix-logger-2.0.6-1.src.rpm
checksum_type: sha256
description:
  This package provides logging suites integrated with `Coralogix` logs analytics platform.
  For watch how to use it, please, read `Coralogix Python SDK Docs <https://python-coralogix-sdk.readthedocs.io/en/latest/>`_.


pkgId: fe5c08531c154cfc652ba562616b423e22bfa27b631e074edfd592991e96f4c6
name: python-coramin
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Coramin: Pyomo tools for MINLP
url: https://github.com/Coramin/Coramin
rpm_license: Revised BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coramin-0.3.2-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/Coramin/Coramin/branch/main_branch/graph/badge.svg)](https://codecov.io/gh/Coramin/Coramin)
  [![Actions Status](https://github.com/Coramin/Coramin/workflows/main_ci/badge.svg?branch=main_branch)](https://github.com/Coramin/Coramin/actions)

  Coramin is a Pyomo-based Python package that provides tools for
  developing tailored algorithms for mixed-integer nonlinear programming
  problems (MINLP's). This software includes classes for managing and
  refining convex relaxations of nonconvex constraints. These classes
  provide methods for updating the relaxation based on new variable
  bounds, creating and managing piecewise relaxations (for multi-tree
  based algorithms), and adding outer-approximation based cuts for
  convex or concave constraints. These classes inherit from Pyomo
  Blocks, so they can be easily integrated with Pyomo
  models. Additionally, Coramin has functions for automatically
  generating convex relaxations of general Pyomo models. Coramin also
  has tools for domain reduction, including a parallel implementation
  of optimization-based bounds tightening (OBBT) and various OBBT
  filtering techniques.



  - Relaxation classes
  - OBBT
  - OBBT Filtering
  - Factorable programming approach to generating relaxations


  - Parallel OBBT
  - McCormick and piecewise McCormick relaxations for bilinear terms
  - Relaxations for univariate convex/concave fucntions


  - Relaxation classes


  - Alpha-BB relaxation




  Coramin is built upon Pyomo and is designed for integration with Pyomo models.


  Use of Coramin can be improved significantly by also utilizing
  Suspect's convexity detection and feasibility-based bounds tightening
  features. Future development of Coramin will directly use Suspect in
  Coramin's factorable programming approach to generating relaxations.



  Coming soon..


pkgId: 3e4031618d1c5a7e6eb252eb717c99b74df297c26f00fd8d82fdf79039cd9a7f
name: python-corby
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: ⚡ Create your LLMs applications from zero to deploy in minutes ⚡
url: https://pypi.org/project/corby/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-corby-0.1.4-1.src.rpm
checksum_type: sha256
description:
  ⚡ Create your AI applications from zero to deploy in minutes ⚡

  ![pypi](https://github.com/JoseHervas/corby/actions/workflows/publish.yml/badge.svg) ![pylint](https://github.com/JoseHervas/corby/actions/workflows/pylint.yml/badge.svg) [![Python 3.10](https://img.shields.io/badge/python-3.10-blue.svg)](https://www.python.org/downloads/release/python-360/) [![Downloads](https://static.pepy.tech/badge/corby)](https://pepy.tech/project/corby) [![License: GPL-3](https://img.shields.io/badge/License-GPL3-green.svg)](https://opensource.org/licenses/GPL-3) [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/zelzebu.svg?style=social&label=Follow%20%40zelzebu)](https://twitter.com/zelzebu)



  ```bash
  pip install corby


  corby -v
  ```



  AI applications are awesome, but... who has time to go through all the settings, configurations and the hell of folder structuring? 😫

  **Corby** is a tool that bootstraps the skeleton of your AI applications so you don't have spend a ton of time preparing the configurations.

  🚀 Just run the command `corby` on your terminal and get your AI application working in less than 1 minute!



  [📌 User guides can be found here 📌](docs)

  ```bash
  usage: corby new {chatbot | notebook} [options]

  positional arguments:
    {new}               Action to perform
    {chatbot,notebook}  Entity to work with

  options:
    -h, --help          show this help message and exit
    -v, --version       Show version
    -d, --debug         Debug mode
  ```



  This project is open-source and therefore every contribution is more than welcome, whether it be in the form of a new feature, new templates, or better documentation.


pkgId: 93f32ae08216c00617679f6d62c53dc6e547c35be74265ea0a5ad8aad5ce9d77
name: python-cord-19-tools
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: CORD 19 tools and utilities
url: https://github.com/josephsdavid/cord-19-tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cord-19-tools-0.3.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cord-19-tools.svg)](https://badge.fury.io/py/cord-19-tools)


  Tools for making COVID 19 data slightly easier for everyone! If you A) think something would be useful in your research or B) have some helpful code to contribute, make an issue or PR ASAP so we can get your code shared!



  ```
  pip install cord-19-tools
  ```

  BE SURE TO HAVE THE MOST RECENT VERSION! I will be constantly updating to make sure users are getting the right data! Semantic Scholar updates the dataset every friday, so on fridays and saturdays be sure to redownload data!



  [Demonstration Notebook on colab](https://colab.research.google.com/drive/1al-K7vT3m72EOBduMpN2rQF1bLdGikx_)



  To download and extract the data, use the `download` function:

  ```python
  import cotools
  from pprint import pprint

  cotools.download()
  ```

  For now this just downloads the data from the [CORD-19 dataset](https://pages.semanticscholar.org/coronavirus-research), metadata is not included (will be by end of day), extracts all the tarfiles, and places them in a directory



  This is a class for lazily loading papers from the [CORD-19 dataset](https://pages.semanticscholar.org/coronavirus-research).


  ```python

  data = cotools.Paperset("data/comm_use_subset")


  pprint(data[0])



  pprint(data[:2])



  print(len(data))


  alldata = data[:]
  ```

  Lets talk for a bit about how it works, and why it doesnt take a gigantic amount of memory. The files are not actually loaded into python ***until the data is indexed***. Upon indexing, the files at those indexes are read into python, resulting in a list of dictionaries. This means you can still contribute while working on a low resource system.




  For text, there is the `text` function, which returns the text from a single document, the `texts` function, which returns the text from multiple documents, and the `Paperset.texts()` function, which gets the text from all documents:

  ```python
  print(cotools.text(data[0]))
  print(cotools.texts(data[12:18]))

  alltext = data.texts()

  ```

  For abstracts, we have a similar API:

  ```python
  print(cotools.abstract(data[0]))
  print(cotools.abstracts(data[12:18]))

  allabs = data.abstracts()

  ```



  You can also manipulate the documents with the `Paperset.apply` method:

  ```python
  keys = comm_use.apply(lambda x: list(x.keys()))

  print(set(sum(keys, [])))
  ```



  You can search with a list OR a nested list! See the demo notebook for more examples!

  ```python
  txt = [["covid", "novel coronavirus"], ["ventilator", "cpap", "bipap"]]

  x = cotools.search(comm_use, txt)
  print(len(x))
  print(len(cotools.search(comm_use, txt[0])))
  print(len(cotools.search(comm_use, txt[-1])))
  ```



  - [x] Metadata
  - [ ] Other data, for example data from [this aggregate site](https://www.kiragoldner.com/covid19/) and [this google spreadsheet](https://docs.google.com/spreadsheets/u/1/d/e/2PACX-1vRwAqp96T9sYYq2-i7Tj0pvTf6XVHjDSMIKBdZHXiCGGdNC0ypEU9NbngS8mxea55JuCFuua1MUeOj5/pubhtml#)


pkgId: 1f020c499bd97d892061b0e281bbfe3647bf8f56acfc7b9bac1a18e692e4c46c
name: python-cordage
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Small framework for computational research data management
url: https://pypi.org/project/cordage/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cordage-0.0.5-1.src.rpm
checksum_type: sha256
description:
  ![Cordage Icon](https://raw.githubusercontent.com/plonerma/cordage/main/docs/assets/icon.svg)





  [![Build status](https://img.shields.io/github/actions/workflow/status/plonerma/cordage/tests.yml?logo=github&label=Tests)](https://github.com/plonerma/cordage/actions)
  [![PyPI - Version](https://img.shields.io/pypi/v/cordage.svg?logo=pypi&label=Version&logoColor=gold)](https://pypi.org/project/cordage/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cordage.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/cordage/)
  [![PyPI - License](https://img.shields.io/pypi/l/cordage?logo=pypi&logoColor=gold)](https://github.com/plonerma/cordage/blob/main/LICENSE)
  [![Code style: black](https://img.shields.io/badge/Code%20style-black-000000.svg)](https://github.com/psf/black)

  Parameterize experiments using dataclasses and use cordage to easily parse configuration files and command line
  options.

  > [!IMPORTANT]
  > Cordage is in a very early stage. Currently, it lacks a lot of documentation and wider range
  > of features. If you think it could be useful for you, try it out and leave suggestions, complains, and improvemnt ideas
  > as [github issues](https://github.com/plonerma/cordage/issues).




  In many cases, we want to execute and parameterize a main function.
  Since experiments can quickly become more complex and may use an increasing number of parameters,
  it often makes sense to store these parameters in a `dataclass`.

  Cordage makes it easy to load configuration files or configure the experiment via the commandline.




  For more detailed information, check out the [documentation](https://plonerma.github.io/cordage/).



  In an environment of your choice (python>=3.8), run:

  ```bash
  pip install cordage
  ```



  ```python
  from dataclasses import dataclass
  import cordage


  @dataclass
  class Config:
      lr: float = 5e-5
      name: str = "MNIST"


  def train(config: Config):
      """Help text which will be shown."""
      print(config)


  if __name__ == "__main__":
      cordage.run(train)
  ```


  To use cordage, you need a main function (e.g. `func`) which takes a dataclass configuration object as an argument.
  Use `cordage.run(func)` to execute this function with arguments passed via the command line. Cordage parses the
  configuration and creates an output directory (if the function accepts `output_dir`, it will be passed as such).

  See the examples in the examples directory for more details.




  The main purpose of cordage is to manage configurations to make configuring reproducible experiments easy.
  Cordage automatically generates a commandline interface which can be used to parse configuration files and/or
  set specific configuration fields via CLI options (run the experiment with the `--help option` to get an overview
  over the available configuration fields).

  By using the `__series__` key, it is possible ot invoke multiple repetitions of an experiment using the same
  base configuration but varying some of the configuration fields. The resulting trial runs are (by default)
  saved in a common series-level directory.

  Additionally, cordage can provide an output directory (via the `output_dir`) where cordage will store the used configuration
  as well as some experimental metadata.


pkgId: 1746e69aa1bf489eaec3b7c5abe5c8f83a824cfc29cefbf144d09db3ffc16f38
name: python-cordage
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Computational research data management tool
url: https://pypi.org/project/cordage/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cordage-0.0.7-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://img.shields.io/github/actions/workflow/status/plonerma/cordage/tests.yml?logo=github&label=Tests)](https://github.com/plonerma/cordage/actions)
  [![PyPI - Version](https://img.shields.io/pypi/v/cordage.svg?logo=pypi&label=Version&logoColor=gold)](https://pypi.org/project/cordage/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cordage.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/cordage/)
  [![PyPI - License](https://img.shields.io/pypi/l/cordage?logo=pypi&logoColor=gold)](https://github.com/plonerma/cordage/blob/main/LICENSE)
  ![Cordage Icon](https://raw.githubusercontent.com/plonerma/cordage/main/docs/assets/icon.svg)
  [Repository](https://github.com/plonerma/cordage) | [Documentation](https://plonerma.github.io/cordage/) | [Package](https://pypi.org/project/cordage/)


pkgId: beb49f6ebb3753130a59186fe693bd110fd15c5d632fbaca8652eb3ab282650e
name: python-corded
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: A lightweight, extensible client library for Discord bots
url: https://pypi.org/project/corded/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-corded-1.5.2-1.src.rpm
checksum_type: sha256
description:
  A lightweight, extensible client library for Discord bots

  Example usage:
  ```py
  from corded import CordedClient, GatewayEvent, Intents


  bot = CordedClient("my_token", Intents.default())

  @bot.on("message_create")
  async def on_message_create(event: GatewayEvent) -> None:
      data = event.typed_data

      print(data["content"])

  bot.start()
  ```


pkgId: 1db7633bc08f8b995eced20462b5c4f8096309fc9d61659c271d56b7523f768f
name: python-corderius-play
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: The easiest way to make games and media projects in Python.
url: https://github.com/Corderius-College-Amersfoort/play
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-corderius-play-2.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Try on repl.it](https://repl-badge.jajoosam.repl.co/try.png)](https://repl.it/@glench/Python-Play-sample-game)



  Python Play is an open-source code library for the Python programming language that makes it as easy as possible to start making games. Here's the code to make a simple game using Play:

  ```python
  import play

  cat = play.new_text('=^.^=', font_size=70)

  @play.repeat_forever
  async def move_cat():
      cat.x = play.random_number(-200, 200)
      cat.y = play.random_number(-200, 200)
      cat.color = play.random_color()

      cat.show()

      await play.timer(seconds=0.4)

      cat.hide()

      await play.timer(seconds=0.4)

  @cat.when_clicked
  def win_function():
      cat.show()
      cat.words = 'You won!'

  play.start_program()
  ```

  The code above makes a game where you have to click the cat to win:

  ![Clicking a cat game](example.gif)

  Python Play is an excellent choice for beginner programmers to get started with graphics programming. It was designed to have similar commands and simplicity to [MIT's Scratch](https://scratch.mit.edu) and is distinguished from such projects as Pygame, Arcade, or Pygame Zero because of its lack of boiler plate code, its easy-to-understand plain-english commands, and intuitive API. [Read more about its design at the bottom of this document](#why-use-python-play).



  Run the following command in your terminal:

      pip install corderius-play



  All Python Play programs start with `import play` and end with `play.start_program()`, like this:

  ```python
  import play # this is the first line in the program



  play.start_program() # this is the last line in the program
  ```

  All other commands go between those two commands.



  The rest of this document is divided into the following sections:

  - [Basic Commands](#basic-commands) - Getting graphics, shapes, and text on the screen. Also changing the backdrop.
  - [Animation and Control Commands](#animation-and-control-commands) - Animating and controlling graphics, shapes, and text.
  - [Sprite Commands](#sprite-commands) - Controlling sprites.
  - [Mouse Commands](#mouse-commands) - Detecting mouse actions (clicks, movement).
  - [Keyboard Commands](#keyboard-commands) - Detecting keyboard actions.
  - [Physics Commands](#physics-commands) - Making physics objects.
  - [Other Useful Commands](#other-useful-commands) - General commands.
  - [Why use Python Play?](#why-use-python-play) - How this library is different from other graphics libraries.



  To get images or text on the screen, use the following commands. (Copy and paste the code below to try it out.)


  ```python
  box = play.new_box(
          color='black',
          x=0,
          y=0,
          width=100,
          height=200,
          border_color="light blue",
          border_width=10
      )
  ```

  This will put a tall, black box in the middle of the screen.

  If you want to change where the image is on the screen, try changing `x=0` (horizontal position) and `y=0` (vertical position). Just like Scratch, the middle of the screen is x=0, y=0. Increasing x moves the image right and decreasing x moves the image left. Likeswise, increasing y moves the image up and decreasing y moves the image down. You can also change the color by changing `'black'` to another color name, like `'orange'`.



  ```python
  character = play.new_image(
          image='character.png',
          x=0,
          y=0,
          angle=0,
          size=100,
          transparency=100
      )
  ```

  This will place an image in the middle of the screen. Make sure you have a file named `character.png` in your project files for the code above to work. You can find images online at sites like http://icons.iconarchive.com/icons/icojam/animals/64/01-bull-icon.png




  ```python
  greeting = play.new_text(
          words='hi there',
          x=0,
          y=0,
          angle=0,
          font=None,
          font_size=50,
          color='black',
          transparency=100
      )
  ```

  This will put some text on the screen.

  If you want to change the font, you'll need a font file (usually named something like `Arial.ttf`) in your project files. Then you can change `font=None` to `font='Arial.ttf'`. You can find font files at sites like [DaFont](https://www.dafont.com).




  ```python
  ball = play.new_circle(
          color='black',
          x=0,
          y=0,
          radius=100,
          border_color="light blue",
          border_width=10,
          transparency=100
      )
  ```

  This will put a black circle in the middle of the screen.




  ```python
  line = play.new_line(
          color='black',
          x=0,
          y=0,
          length=100,
          angle=0,
          thickness=1,
          x1=None,
          y1=None
      )
  ```

  This will create a thin line on the screen.




  You can change the background color with the `play.set_backdrop()` command:

  ```python
  play.set_backdrop('light blue')
  ```

  There are [lots of named colors to choose from](https://upload.wikimedia.org/wikipedia/commons/2/2b/SVG_Recognized_color_keyword_names.svg). Additionally, if you want to set colors by RGB (Red Green Blue) values, you can do that like this:

  ```python

  play.set_backdrop( (255, 255, 255) )
  ```

  Anywhere you can set a color in Python Play, you can do it using a named color like `'red'` or an RGB value above like `(255, 255, 255)` or even an RGBA value like `(0, 0, 0, 127)` (the fourth number is transparency from 0 to 255). You can get the current background color with `play.backdrop`.







  To make things move around, you can start by using `@play.repeat_forever`, like this:

  ```python
  cat = play.new_text('=^.^=')

  @play.repeat_forever
  def do():

      cat.turn(10)
  ```

  The above code will make the cat turn around forever. Sprites have other commands that you can see in the next section called Sprite Commands.



  To make some code run just at the beginning of your project, use `@play.when_program_starts`, like this:

  ```python
  cat = play.new_text('=^.^=')

  @play.when_program_starts
  def do():

      cat.turn(180)
  ```

  This will make the cat turn upside down instantly when the program starts.




  To run code after a waiting period, you can use the `await play.timer()` command like this:

  ```python
  cat = play.new_text('=^.^=')

  @play.when_program_starts
  async def do():

      cat.turn(180)
      await play.timer(seconds=2)
      cat.turn(180)
  ```

  This will make the cat turn upside down instantly when the program starts, wait 2 seconds, then turn back up again.




  To smoothly animate a character a certain number of times, you can use `play.repeat()` with `await play.animate()`, like this:


  ```python
  cat = play.new_text('=^.^=')

  @play.when_program_starts
  async def do():
      for count in play.repeat(180):
          cat.turn(1)
          await play.animate()
  ```

  This code will animate the cat turning upside down smoothly when the program starts.

  To break down the code:
  - `for count in play.repeat(180):` runs the code 180 times.
  - `cat.turn(1)` turns that cat 1 degree each time.
  - `await play.animate()` makes the cat animate smoothly. Without this command, the cat would just turn upside down instantly.

  Note: to use `await play.animate()` and `await play.timer()`, the word `async` must be included before `def` in your function definition.











  Sprites (images and text) have a few simple commands:

  - **`sprite.move(10)`** — moves the sprite 10 pixels in the direction it's facing (starts facing right). Use negative numbers (-10) to go backward.
  - **`sprite.turn(20)`** — Turns the sprite 20 degrees counter-clockwise. Use negative numbers (-20) to turn the other way.
  - **`sprite.go_to(other_sprite)`** — Makes `sprite` jump to another sprite named `other_sprite`'s position on the screen. Can also be used to make the sprite follow the mouse: `sprite.go_to(play.mouse)`.
  - **`sprite.go_to(x=100, y=50)`** — Makes `sprite` jump to x=100, y=50 (right and up a little).
  - **`sprite.point_towards(other_sprite)`** — Turns `sprite` so it points at another sprite called `other_sprite`.
  - **`sprite.point_towards(x=100, y=50)`** — Turns `sprite` so it points toward x=100, y=50 (right and up a little).
  - **`sprite.hide()`** — Hides `sprite`. It can't be clicked when it's hidden.
  - **`sprite.show()`** — Shows `sprite` if it's hidden.
  - **`sprite.clone()`** — Makes a copy or clone of the sprite and returns it.
  - **`sprite.remove()`** — Removes a sprite from the screen permanently. Calling sprite commands on a removed sprite won't do anything.
  - **`sprite.start_physics()`** — Turn on physics for a sprite. See the [Physics Commands section](#physics-commands) for details.
  - **`sprite.stop_physics()`** — Turn off physics for a sprite. See the [Physics Commands section](#physics-commands) for details.




  Sprites also have properties that can be changed to change how the sprite looks. Here they are:

  - **`sprite.x`** — The sprite's horizontal position on the screen. Positive numbers are right, negative numbers are left. The default is 0.
  - **`sprite.y`** — The sprite's vertical position on the screen. Positive numbers are up, negative numbers are down. The default is 0.
  - **`sprite.size`** — How big the sprite is. The default is 100, but it can be made bigger or smaller.
  - **`sprite.angle`** — How much the sprite is turned. Positive numbers are counter-clockwise. The default is 0 degrees (pointed to the right).
  - **`sprite.transparency`** — How see-through the sprite is from 0 to 100. 0 is completely see-through, 100 is not see-through at all. The default is 100.
  - **`sprite.is_hidden`** — `True` if the sprite has been hidden with the `sprite.hide()` command. Otherwise `False`.
  - **`sprite.is_shown`** — `True` if the sprite has not been hidden with the `sprite.hide()` command. Otherwise `False`.
  - **`sprite.left`** — The x position of the left-most part of the sprite.
  - **`sprite.right`** — The x position of the right-most part of the sprite.
  - **`sprite.top`** — The y position of the top-most part of the sprite.
  - **`sprite.bottom`** — The y position of the bottom-most part of the sprite.
  - **`sprite.physics`** — Contains the physics properties of an object if physics has been turned on. The default is `None`. See the [Physics Commands section](#physics-commands) for details.



  Image-sprite-only properties:

  - **`sprite.image`** — The filename of the image shown. If `None` is provided initially, a blank image will show up.

  Text-sprite-only properties:

  - **`text.words`** — The displayed text content. The default is `'hi :)'`.
  - **`text.font`** — The filename of the font e.g. 'Arial.ttf'. The default is `None`, which will use a built-in font.
  - **`text.font_size`** — The text's size. The default is `50` (pt).
  - **`text.color`** — The text's color. The default is black.

  Box-sprite-only properties:
  - **`box.color`** — The color filling the box. The default is `black`.
  - **`box.width`** — The width of the box. The default is `100` pixels.
  - **`box.height`** — The height of the box. The default is `200` pixels.
  - **`box.border_width`** — The width of the box's border, the line around it. The default is `0`.
  - **`box.border_color`** — The color of the box's border. The default is `'light blue'`.

  If the box has a border, the box's total width, including the border, will be the width defined by the `width` property.

  Circle-sprite-only properties:
  - **`circle.color`** — The color filling the circle. The default is `black`.
  - **`circle.radius`** — How big the circle is, measured from the middle to the outside. The default is `100` pixels, making a 200-pixel-wide circle.
  - **`circle.border_width`** — The width of the circle's border, the line around it. The default is `0`.
  - **`circle.border_color`** — The color of the circle's border. The default is `'light blue'`.

  If the circle has a border, the circle's total width, including the border, will be the width defined by the `radius` property.


  Line-sprite-only properties:
  - **`line.color`** — The line's color. The default is `black`.
  - **`line.length`** — How long the line is. Defaults to `100` (pixels).
  - **`line.angle`** — The angle the line points in. Defaults to `0` (degrees).
  - **`line.x1`** — The `x` coordinate of the end of the line.
  - **`line.y1`** — The `y` coordinate of the end of the line.

  For lines, the `x` and `y` coordinates are where the start of the line is. You can set either the `length` and `angle` or the `x1` and `y1` properties to change where the line points. If you update one, the others will be updated automatically.



  These properties can changed to do the same things as the sprite commands above. For example,

  ```python
  sprite.go_to(other_sprite)



  sprite.x = other_sprite.x
  sprite.y = other_sprite.y
  ```

  You can change the properties to animate the sprites. The code below makes the cat turn around.

  ```python
  cat = play.new_text('=^.^=')

  @play.repeat_forever
  def do():
      cat.angle += 1
      
  ```






  Sprites also have some other useful info:

  - **`sprite.width`** — Gets how wide the sprite is in pixels.
  - **`sprite.height`** — Gets how tall the sprite is in pixels.
  - **`sprite.distance_to(other_sprite)`** — Gets the distance in pixels to `other_sprite`.
  - **`sprite.distance_to(x=100, y=100)`** — Gets the distance to the point x=100, y=100.
  - **`sprite.is_clicked`** — `True` if the sprite has just been clicked, otherwise `False`.
  - **`sprite.is_touching(other_sprite)`** — Returns True if `sprite` is touching the `other_sprite`. Otherwise `False`.
  - **`sprite.is_touching(point)`** — Returns True if the sprite is touching the point (anything with an `x` and `y` coordinate). For example: `sprite.is_touching(play.mouse)`









  Working with the mouse in Python Play is easy. Here's a simple program that points a sprite at the mouse:

  ```python
  arrow = play.new_text('-->', font_size=100)

  @play.repeat_forever
  def do():
      arrow.point_towards(play.mouse)
  ```

  `play.mouse` has the following properties:

  - **`play.mouse.x`** — The horizontal x position of the mouse.
  - **`play.mouse.y`** — The vertical y position of the mouse.
  - **`play.mouse.is_clicked`** — `True` if the mouse is clicked down, or `False` if it's not.
  - **`play.mouse.is_touching(sprite)`** — Returns `True` if the mouse is touching a sprite, or `False` if it's not.





  Probably the easiest way to detect clicks is to use `@sprite.when_clicked`.

  In the program below, when the face is clicked it changes for 1 second then turns back to normal:

  ```python
  face = play.new_text('^.^', font_size=100)

  @face.when_clicked
  async def do():
      face.words = '*o*'
      await play.timer(seconds=1)
      face.words = '^.^'
  ```






  If you wanted to run the same code when multiple sprites are clicked, you can use `@play.when_sprite_clicked()`:

  ```python
  face1 = play.new_text('^.^', x=-100, font_size=100)
  face2 = play.new_text('^_^', x=100, font_size=100)

  @play.when_sprite_clicked(face1, face2) # takes as many sprites as you want
  async def do(sprite):
      starting_words = sprite.words
      sprite.words = '*o*'
      await play.timer(seconds=1)
      sprite.words = starting_words
  ```

  In the above program, clicking `face1` or `face2` will run the code for each sprite separately. Note that the function is defined with a parameter e.g. `def do(sprite):` instead of just `def do():`.




  To run code when the mouse is clicked anywhere, use `@play.mouse.when_clicked` or `@play.when_mouse_clicked` (they do the same exact thing).

  In the code below, when a click is detected, the text will move to the click location and the coordinates will be shown:

  ```python
  text = play.new_text('0, 0')

  @play.mouse.when_clicked
  def do():
      text.words = f'{play.mouse.x}, {play.mouse.y}'
      text.go_to(play.mouse)
  ```



  To run code when the mouse button is released, use `@play.mouse.when_click_released` `@play.when_click_released` (they do the same exact thing).

  In the code below, the cat can be dragged around when it's clicked by the mouse:

  ```python
  cat = play.new_text('=^.^= drag me!')
  cat.is_being_dragged = False

  @cat.when_clicked
  def do():
      cat.is_being_dragged = True

  @play.mouse.when_click_released
  def do():
      cat.is_being_dragged = False

  @play.repeat_forever
  def do():
      if cat.is_being_dragged:
          cat.go_to(play.mouse)
  ```











  You can use `play.key_is_pressed()` to detect keypresses.

  In the code below, pressing the `arrow` keys or `w/a/s/d` will make the cat go in the desired direction.

  ```python
  cat = play.new_text('=^.^=')

  @play.repeat_forever
  def do():
      if play.key_is_pressed('up', 'w'):
          cat.y += 15
      if play.key_is_pressed('down', 's'):
          cat.y -= 15

      if play.key_is_pressed('right', 'd'):
          cat.x += 15
      if play.key_is_pressed('left', 'a'):
          cat.x -= 15
  ```



  You can use `@play.when_key_pressed()` to run code when specific keys are pressed.

  In the code below, pressing the `space` key will change the cat's face, and pressing the `enter` key will change it to a different face.

  ```python
  cat = play.new_text('=^.^=')

  @play.when_key_pressed('space', 'enter') # if either the space key or enter key are pressed...
  def do(key):
      if key == 'enter':
          cat.words = '=-.-='
      if key == 'space':
          cat.words = '=*_*='
  ```






  If you just want to detect when any key is pressed, you can use `@play.when_any_key_pressed`.

  In the code below, any key you press will be displayed on the screen:

  ```python
  text = play.new_text('')

  @play.when_any_key_pressed
  def do(key):
      text.words = f'{key} pressed!'
  ```



  Exactly like `@play.when_key_pressed()` but runs the code when specific keys are released.

  In the code below, text will appear on screen only if the `up` arrow is pressed.

  ```python
  text = play.new_text('')

  @play.when_key_released('up')
  async def do(key):
      text.words = 'up arrow released!'
      await play.timer(seconds=1)
      text.words = ''
  ```



  Exactly like `@play.when_any_key_pressed` but runs the code when any key is released.

  In the code below, the name of the most recently released key will show up on screen.

  ```python
  text = play.new_text('')

  @play.when_any_key_pressed
  def do(key):
      text.words = f'{key} key released!''
  ```





  Python Play uses the [Pymunk](http://www.pymunk.org/en/master/) physics library to turn sprites into physics objects that can collide with each other, fall with gravity, and more.



  To turn a sprite into a physics object, use the `start_physics()` command:

  ```python
  sprite.start_physics(can_move=True, stable=False, x_speed=0, y_speed=0, obeys_gravity=True, bounciness=1, mass=10, friction=0.1)
  ```

  This will cause the sprite to start being affected by gravity, collide with other sprites that have physics, and more.




  Once `sprite.start_physics()` has been called, the sprite will have a `sprite.physics` property. `sprite.physics` has the following properties:

  - **`sprite.physics.can_move`** — Whether the sprite can move around the screen (`True`) or is stuck in place (`False`). Defaults to `True`.
  - **`sprite.physics.stable`** — Whether the sprite is a stable object (one that can't be knocked about). A pong paddle is a stable object (`True`) but a box or ball that can be knocked around is not (`False`). Defaults to `False`.
  - **`sprite.physics.x_speed`** — How fast the sprite is moving horizontally (negative numbers mean the sprite moves to the left and positive numbers mean the sprite moves to the right). Defaults to `0`.
  - **`sprite.physics.y_speed`** — How fast the sprite is moving vertically (negative numbers mean the sprite moves down and positive numbers mean the sprite moves up). Defaults to `0`.
  - **`sprite.physics.obeys_gravity`** — If the sprite is affected by gravity. Defaults to `True`.
  - **`sprite.physics.bounciness`** — How bouncy the sprite is from 0 (doesn't bounce at all) to 1 (bounces a lot). Defaults to `1`.
  - **`sprite.physics.mass`** — How heavy the sprite is. Defaults to `10`. Heavier objects will knock lighter objects around more.
  - **`sprite.physics.friction`** — How much the sprite slides around on other objects. Starts at 0 (slides like on ice) to big numbers (very rough sprite that doesn't slide at all). Defaults to `0.1`.

  Changing any of these properties will immediately change how the sprite acts as a physics object. Try experimenting with all these properties if you don't fully understand them.

  `sprite.physics` also has two commands that could be helpful:

  - **`sprite.physics.pause()`** — Temporarily stop the sprite from being a physics object. The sprite's speed and other physics properties will be saved until the `unpause()` command is used.
  - **`sprite.physics.unpause()`** — Resume physics on a sprite that has been paused. It will continue with the exact speed and physics settings it had before `physics.pause()` was called.

  Calling `sprite.stop_physics()` will immediately stop the sprite from moving and colliding and `sprite.physics` will be set to `None`.




  To get a sprite to stop moving around and colliding, you can call `sprite.stop_physics`:

  ```python
  sprite.stop_physics()
  ```

  This will immediately stop the sprite.




  To set how much gravity there is for sprites that have had `start_physics()` called on them, use the `play.set_gravity()` command:

  ```python
  play.set_gravity(vertical=-100, horizontal=None)
  ```

  You can access the current gravity with `play.gravity.vertical` (default is `-100`) and `play.gravity.horizontal` (default is `0`).









  The way to get information about the screen. `play.screen` has these properties:

  - `play.screen.width` - Defaults to 800 (pixels total). Changing this will change the screen's size.
  - `play.screen.height` - Defaults to 600 (pixels total). Changing this will change the screen's size.
  - `play.screen.left` - The `x` coordinate for the left edge of the screen.
  - `play.screen.right` - The `x` coordinate for the right edge of the screen.
  - `play.screen.top` - The `y` coordinate for the top of the screen.
  - `play.screen.bottom` - The `y` coordinate for the bottom of the screen.




  A list of all the sprites (images, shapes, text) in the program.




  A function that makes random numbers.

  If two whole numbers are given, `play.random_number()` will give a whole number back:

  ```python
  play.random_number(lowest=0, highest=100)


  ```
  (You can also do `play.random_number(0, 100)` without `lowest` and `highest`.)

  If non-whole numbers are given, non-whole numbers are given back:

  ```python
  play.random_number(0, 1.0)

  ```

  `play.random_number()` is also inclusive, which means `play.random_number(0,1)` will return `0` and `1`.




  Returns a random RGB color, including white and black.

  ```python
  play.random_color()

  ```

  Each value varies from 0 to 255.



  Returns a random position on the screen. A position object has an `x` and `y` component.

  ```python
  text = play.Text('WOO')


  @play.repeat_forever
  def do():
      text.go_to(play.random_position())

      
      position = play.random_position()
      text.x = position.x
      text.y = position.y
  ```



  `play.repeat()` is the same as Python's built-in `range` function, except it starts at 1. 'Repeat' is just a friendlier and more descriptive name than 'range'.

  ```python
  list(play.repeat(10))

  ```



  When used in a loop, this command will animate any sprite changes that happen.

  ```python
  cat = play.new_text('=^.^=')

  @play.when_program_starts
  async def do():
      for count in play.repeat(360):
          cat.turn(1)
          await play.animate()
  ```

  `await play.animate()` is the same as `await asyncio.sleep(0)` except it has a friendlier name for beginners.




  Yes, this is Python! Python added `async` and `await` as special keywords in Python 3.7. It's part of the [asyncio module](https://docs.python.org/3/library/asyncio.html).

  Using async functions means we can use the `await play.timer()` and `await play.animate()` functions, which makes some code a lot simpler and appear to run in-parallel, which new programmers find intuitive.

  ```python
  import play

  cat = play.new_text('=^.^=')


  @play.repeat_forever
  async def change_bg():
      play.set_backdrop('pink')
      await play.timer(seconds=1)

      play.set_backdrop('purple')
      await play.timer(seconds=1)

      play.set_backdrop('light blue')
      await play.timer(seconds=1)


  @play.repeat_forever
  def do():
      cat.turn(1)

  play.start_program()
  ```

  In the above program, the backdrop will change and the cat will appear to turn at the same time even though the code is running single-threaded.

  The `async` keyword isn't necessary to write unless you want to use `await` functions. If you try to use an `await` command inside a non-async function, Python will show you an error like this:

  ```
    File "example.py", line 31
      await play.timer(seconds=1)
      ^
  SyntaxError: 'await' outside async function
  ```
  To fix that error, just put `async` before `def`.

  If you don't understand any of this, it's generally safe to just include `async` before `def`.



  Python Play was designed to be an excellent starting point for brand new programmers. The goal of the project is to give someone that has never programmed before a compelling and successful experience in their first few minutes of programming. We aimed to make graphics programming as accessible as possible to as young an audience as possible.

  We found that many existing programming languages and graphics libraries presented unnecessary difficulties for new programmers — difficulties making simple things happen, confusing language, confusing program flow, unexplained concepts, etc. We know that even one initial disagreeable experience can turn people away from programming forever, and we wanted to prevent that outcome as much as possible.

  Python Play was inspired by [MIT's Scratch](https://scratch.mit.edu), which has introduced millions of children and adults to programming and helped them to create and share personally meaningful computational projects. In fact, Python Play's main designer worked on Scratch professionally for a brief period. But we found that for some learners, Scratch — with its graphical blocks and colorful interface — didn't feel like "real programming". For those learners wishing to use a mainstream textual programming language while removing the difficulties of graphics programming in these languages, we made Python Play.


  Python Play was designed with the following principles in mind:

  - No boilerplate - every line of code should do something meaningful and understandable. We want to limit the number of times a learner needs to ask "why do we have to include this line of code?"

  - As much as possible, commands should have immediate visual effects. For example, if a programmer types a `new_image` command the sprite should show up immediately on the screen. They shouldn't need to understand the invisible distinction between initializing a sprite and drawing the sprite.

  - Lines of code should be easily copy and pasted.

  - Command values should have descriptive labels that make it as clear as possible what the value means. Instead of `play.new_image('character.png', 50, 100)`, `play.new_image(image='character.png', x=50, y=100)`.

  - Use plain English as much as possible. For mathematical concepts, try to use language programmers might see in math classes. Try to use short names that are easier for younger people to type and spell. Make errors as clear and constructive as possible. Many of the commands and names were borrowed from Scratch, whose designers have spent decades working with children and observing what language makes sense to them.


  While the learning curve for Python and Python Play are still far from ideal for new programmers, we still think Python Play provides a great way for new programmers to start programming with graphics.


pkgId: b36565365fe6b568ebe254cbe56a13937924e2dcb177ac1cab8a270f54add1ee
name: python-core-ciphers
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: This project/library contains common elements related to ciphers...
url: https://gitlab.com/bytecode-solutions/core/core-ciphers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-core-ciphers-1.0.2-1.src.rpm
checksum_type: sha256
description:
  _______________________________________________________________________________

  This project/library contains common elements related to ciphers...




  ```commandline
  pip install --upgrade pip
  pip install virtualenv
  ```


  ```commandline
  virtualenv --python=python3.11 .venv
  ```


  ```commandline
  source .venv/bin/activate
  ```


  ```commandline
  pip install .
  ```


  ```commandline
  python manager.py run-test
  python manager.py run-coverage
  ```


