# packages

pkgId: 86db47ea66db67bdd3cabb7ef28b458a13a91c83e3e52e2caf3197ad37fa81dd
name: python-codebased
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: AI-powered code search for the terminal and beyond.
url: https://github.com/codebased-sh/codebased
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codebased-0.6.2-1.src.rpm
checksum_type: sha256
description:
  Codebased is the most powerful code search tool that runs on your computer.

  Here's why it's great:

  - Search, simplified: Combines semantic and full-text search to find what you're looking for, not just what you typed.
  - Search code, not just text: Searches for complete code structures, not just lines of text, in 11 languages.
  - Ignores uninteresting files: Respects your `.gitignore` file(s) and ignores hidden directories.
  - Instant editing: Selecting a search result opens your favorite editor at the correct file and line number.
  - Fast: Indexes your code in seconds, searches in milliseconds, and updates in real-time as you edit your code.
  - Open-source, runs locally: No code is stored on remote servers.



  The fastest way to install Codebased is with [pipx](https://github.com/pypa/pipx?tab=readme-ov-file#install-pipx):

  ```shell
  pipx install codebased
  ```

  Verify the installation by running:

  ```shell
  codebased --version
  ```

  If this fails, please double-check your pipx installation.

  Next, run the following command in a Git repository to start searching:

  ```shell
  codebased search
  ```

  The first time you run Codebased, it will create a configuration file at `~/.codebased/config.toml`.
  It will prompt you for an OpenAI key, you can access a testing key on the [Discord](https://discord.gg/cQrQCAKZ).

  Once this is finished, `codebased` will create an index of your codebase, stored in `.codebased` at the root of your
  repository.
  This takes seconds for most projects, but can take a few minutes for large projects.
  Most of the time is spent creating embeddings using the OpenAI API.

  Once the index is created, a terminal UI will open with a search bar.
  At this point, you can start typing a search query and results will appear as you type.

  - You can use the arrow keys and the mouse to navigate the results.
  - A preview of the selected result is displayed.
  - Pressing enter on the highlighted result opens the file in your editor at the correct line number.
  - Pressing escape returns to the search bar.
  - As you edit your code, the index will be updated in real-time, and future searches will reflect your changes.

  Codebased will run `stat` on all non-ignored files in your repository, which can take a few seconds, but after that
  will listen for filesystem events, so it's recommended to use the TUI.



  If you'd like to contribute, bug fixes are welcome, as well as anything in the list
  of [issues](https://github.com/codebased-sh/codebased/issues).

  Especially welcome is support for your favorite language, as long as:

  1. There's a tree-sitter grammar for it.
  2. There are Python bindings for it maintained by the excellent [amaanq](https://pypi.org/user/amaanq/).

  Also, if there's anything ripgrep does that Codebased doesn't, feel free to file an issue / PR.

  Clone the repository:

  ```shell
  git clone https://github.com/codebased-sh/codebased.git
  ```

  Install the project's dependencies (requires [poetry](https://python-poetry.org), using a virtual environment is
  recommended):

  ```shell
  poetry install
  ```

  Run the tests (some tests require an `OPENAI_API_KEY` environment variable, usage is de minimis):

  ```shell
  poetry run pytest
  ```





  - [X] C
  - [X] C#
  - [X] C++
  - [X] Go
  - [X] Java
  - [X] JavaScript
  - [X] PHP
  - [X] Python
  - [X] Ruby
  - [X] Rust
  - [X] TypeScript
  - [ ] HTML / CSS
  - [ ] SQL
  - [ ] Shell
  - [ ] Swift
  - [ ] Lua
  - [ ] Kotlin
  - [ ] Dart
  - [ ] R
  - [ ] Assembly language
  - [ ] OCaml
  - [ ] Zig
  - [ ] Haskell
  - [ ] Elixir
  - [ ] Erlang
  - [ ] TOML?
  - [ ] YAML?


pkgId: a003b74338fcb14458b1f1e72d470e843caec002e940453f1e2ba85dfd8c35a8
name: python-codebleu
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Unofficial CodeBLEU implementation that supports Linux, MacOS and Windows available on PyPI.
url: https://pypi.org/project/codebleu/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codebleu-0.7.0-1.src.rpm
checksum_type: sha256
description:
  The code is based on the original [CodeXGLUE/CodeBLEU](https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/code-to-code-trans/evaluator/CodeBLEU) and updated version by [XLCoST/CodeBLEU](https://github.com/reddy-lab-code-research/XLCoST/tree/main/code/translation/evaluator/CodeBLEU).  It has been refactored, tested, built for macOS and Windows, and multiple improvements have been made to enhance usability.

  > An ideal evaluation metric should consider the grammatical correctness and the logic correctness.
  > We propose weighted n-gram match and syntactic AST match to measure grammatical correctness, and introduce semantic data-flow match to calculate logic correctness.
  > ![CodeBLEU](CodeBLEU.jpg)
  [from [CodeXGLUE](https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/code-to-code-trans/evaluator/CodeBLEU) repo]
  In a nutshell, `CodeBLEU` is a weighted combination of `n-gram match (BLEU)`, `weighted n-gram match (BLEU-weighted)`, `AST match` and `data-flow match` scores.
  The metric has shown higher correlation with human evaluation than `BLEU` and `accuracy` metrics.

  This library requires `so` file compilation with tree-sitter, so it is platform dependent.
  Currently available for `Linux` (manylinux), `MacOS` and `Windows` with Python 3.8+.
  The metrics is available as [pip package](https://pypi.org/project/codebleu/) and can be installed as indicated above:
  ```bash
  pip install codebleu
  ```
  or directly from git repo (require internet connection to download tree-sitter):
  ```bash
  pip install git+https://github.com/k4black/codebleu.git
  ```
  Also you have to install tree-sitter language you need (e.g. python, rust, etc):
  ```bash
  pip install tree-sitter-python
  ```
  Or you can install all languages:
  ```bash
  pip install codebleu[all]
  ```
  Note: At the moment (May 2024) precompiled languages are NOT available for arm64 (M1) MacOS, so you have to install and build tree-sitter languages manually, for example:
  ```bash
  pip install pip install git+https://github.com/tree-sitter/tree-sitter-python.git
  ```

  ```python
  from codebleu import calc_codebleu
  prediction = "def add ( a , b ) :\n return a + b"
  reference = "def sum ( first , second ) :\n return second + first"
  result = calc_codebleu([reference], [prediction], lang="python", weights=(0.25, 0.25, 0.25, 0.25), tokenizer=None)
  print(result)







  ```
  where `calc_codebleu` takes the following arguments:
  - `refarences` (`list[str]` or `list[list[str]]`): reference code
  - `predictions` (`list[str]`) predicted code
  - `lang` (`str`): code language, see `codebleu.AVAILABLE_LANGS` for available languages (python, c_sharp c, cpp, javascript, java, php, go and ruby at the moment)
  - `weights` (`tuple[float,float,float,float]`): weights of the `ngram_match`, `weighted_ngram_match`, `syntax_match`, and `dataflow_match` respectively, defaults to `(0.25, 0.25, 0.25, 0.25)`
  - `tokenizer` (`callable`): to split code string to tokens, defaults to `s.split()`
  and outputs the `dict[str, float]` with following fields:
  - `codebleu`: the final `CodeBLEU` score
  - `ngram_match_score`: `ngram_match` score (BLEU)
  - `weighted_ngram_match_score`: `weighted_ngram_match` score (BLEU-weighted)
  - `syntax_match_score`: `syntax_match` score (AST match)
  - `dataflow_match_score`: `dataflow_match` score
  Alternatively, you can use `k4black/codebleu` from HuggingFace Spaces (`codebleu` package required):
  ```python
  import evaluate
  metric = evaluate.load("dvitel/codebleu")
  prediction = "def add ( a , b ) :\n return a + b"
  reference = "def sum ( first , second ) :\n return second + first"
  result = metric.compute([reference], [prediction], lang="python", weights=(0.25, 0.25, 0.25, 0.25))
  ```
  Feel free to check the HF Space with online example: [k4black/codebleu](https://huggingface.co/spaces/k4black/codebleu)

  Contributions are welcome!
  If you have any questions, suggestions, or bug reports, please open an issue on GitHub.
  Make your own fork and clone it:
  ```bash
  git clone https://github.com/k4black/codebleu
  ```
  For development, you need to install library with `all` precompiled languages and `test` extra:
  (require internet connection to download tree-sitter)
  ```bash
  python -m pip install -e .[all,test]
  python -m pip install -e .\[all,test\]  # for macos
  ```
  For testing just run pytest:
  ```bash
  python -m pytest
  ```
  To perform a style check, run:
  ```bash
  python -m isort codebleu --check
  python -m black codebleu --check
  python -m ruff codebleu
  python -m mypy codebleu
  ```

  This project is licensed under the terms of the MIT license.

  Official [CodeBLEU paper](https://arxiv.org/abs/2009.10297) can be cited as follows:
  ```bibtex
  @misc{ren2020codebleu,
        title={CodeBLEU: a Method for Automatic Evaluation of Code Synthesis},
        author={Shuo Ren and Daya Guo and Shuai Lu and Long Zhou and Shujie Liu and Duyu Tang and Neel Sundaresan and Ming Zhou and Ambrosio Blanco and Shuai Ma},
        year={2020},
        eprint={2009.10297},
        archivePrefix={arXiv},
        primaryClass={cs.SE}
  }
  ```


pkgId: 59bf82196e8f75e47da733340cd548f4e5e8bddf96964feaa3d38753799fa1ac
name: python-codeblocks
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Extract and process code blocks from Markdown files.
url: https://pypi.org/project/codeblocks/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeblocks-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Extract and process code blocks from Markdown files. Now you can keep code examples automatically:

  * formatted (e.g. using [black][] for Python)
  * type checked
  * unit tested
  * linted
  * up-to-date with `--help`
  * etc



  (if [uv](https://docs.astral.sh/uv/) is available)

  Try `codeblocks` without installing:

  ```
  uvx codeblocks --help
  ```

  Install to `PATH`:

  ```
  uv tool install codeblocks
  codeblocks --help
  ```



  With `pip`:
  ```
  pip install codeblocks
  ```

  With `uv`:
  ```
  uv add codeblocks
  ```

  With `poetry`:
  ```
  poetry add codeblocks
  ```



  ```usage
  Usage: codeblocks [OPTIONS] LANGUAGE FILE [COMMAND]...

    Extract or process LANGUAGE code blocks in Markdown FILE.

    Extract Python code blocks:
        codeblocks python README.md

    Reformat Python code blocks with `black`, in place:
        codeblocks python README.md -- black -

  Options:
    --wrap     Wrap each code block in a function.
    --check    Do not modify the file, just return the status. Return code 0
               means block matches COMMAND output. Return code 1 means block
               would be modified.
    --version  Show the version and exit.
    --help     Show this message and exit.
  ```



  Extract Python code blocks:
  ```
  codeblocks python README.md
  ```

  Check formatting of Python code blocks with black:
  ```
  codeblocks --check python README.md -- black -
  ```

  Reformat Python code blocks with black, **in place**:
  ```
  codeblocks python README.md -- black -
  ```

  Type check Python code blocks with mypy (`--wrap` puts each code block into its own function):
  ```
  mypy somemodule anothermodule <(codeblocks python --wrap README.md)
  ```

  Insert the output of `codeblock --help` into `usage` block in this README.md:
  ```
  codeblocks usage README.md -- codeblocks --help
  ```

  Check that `usage` block in this README.md is up-to-date with `--help` output:
  ```
  codeblocks --check usage README.md -- codeblocks --help
  ```



  ```python
  def plus(x: int, y: int) -> int:
      return x + y

  plus(1, '2')
  ```

  ```
  $ mypy --pretty <(codeblocks python README.md)
  /dev/fd/63:5: error: Argument 2 to "plus" has incompatible type "str"; expected "int"  [arg-type]
          plus(1, '2')
                  ^~~
  Found 1 error in 1 file (checked 1 source file)
  ```



  There are alternative tools, but none of them supported all of the cases above.

  * [prettier][] [can reformat Markdown code blocks][prettier-md] ([PR][prettier-pr]), but it works only for supported languages like JavaScript. It does not support Python. No lint or unit test support.
  * [blacken-docs][] can reformat Python code blocks, but it does not support all [black][] options. For example, [`black --check`][blacken-check] is not supported. No lint or unit test support. In addition, `codeblocks` implementation is much simpler and is not coupled with black.
  * [excode][] is very similar, but does not support in place modifications.
  * [gfm-code-blocks][] does not have command line interface.
  * [codedown][] does not support processing and [separate code block extraction](https://github.com/earldouglas/codedown/issues/9)
  * [cog][] is fully generic, but requires writing [scripts embedded in Markdown][cog-help]

  [black]: https://github.com/psf/black
  [prettier]: https://prettier.io
  [prettier-md]: https://prettier.io/blog/2017/11/07/1.8.0.html#markdown-support
  [prettier-pr]: https://github.com/prettier/prettier/pull/2943
  [blacken-docs]: https://github.com/asottile/blacken-docs
  [blacken-check]: https://github.com/asottile/blacken-docs/issues/42
  [excode]: https://github.com/nschloe/excode
  [gfm-code-blocks]: https://github.com/jonschlinkert/gfm-code-blocks
  [cog-help]: https://til.simonwillison.net/python/cog-to-update-help-in-readme
  [codedown]: https://github.com/earldouglas/codedown
  [cog]: https://nedbatchelder.com/code/cog


pkgId: 7841a025ce30809d448f89eb339c1be531366a26f6bb3c3624c82f269b221e25
name: python-codeboxapi
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: CodeBox gives you an easy scalable and isolated python interpreter for your LLM Agents.
url: https://pypi.org/project/codeboxapi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeboxapi-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://badge.fury.io/py/codeboxapi.svg)](https://badge.fury.io/py/codeboxapi)
  [![code-check](https://github.com/shroominic/codebox-api/actions/workflows/code-check.yml/badge.svg)](https://github.com/shroominic/codebox-api/actions/workflows/code-check.yml)
  ![Downloads](https://img.shields.io/pypi/dm/codeboxapi)
  ![License](https://img.shields.io/pypi/l/codeboxapi)

  CodeBox is the simplest cloud infrastructure for your LLM Apps and Services.
  It allows you to run python code in an isolated/sandboxed environment.



  You can install CodeBox with pip:

  ```bash
  pip install codeboxapi
  ```



  ```bash
  export CODEBOX_API_KEY=local # for local development
  export CODEBOX_API_KEY=docker # for small projects
  export CODEBOX_API_KEY=sk-*************** # for production
  ```

  ```python
  from codeboxapi import CodeBox


  codebox = CodeBox()


  codebox.exec("a = 'Hello'")
  codebox.exec("b = 'World!'")
  codebox.exec("x = a + ', ' + b")
  result = codebox.exec("print(x)")

  print(result)

  ```



  Checkout the [pricing page](https://codeboxapi.com/pricing) of CodeBoxAPI. By subscribing to a plan,
  you will receive an account with an api-key.
  Bear in mind, we don't have many automations set up right now,
  so you'll need to write an [email](mailto:team@codeboxapi.com) for things like refunds,
  sub cancellations, or upgrades.



  Checkout the [documentation](https://shroominic.github.io/codebox-api/) for more details!



  Feel free to contribute to this project.
  You can open an issue or submit a pull request.



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



  You can contact me at [team@codeboxapi.com](mailto:team@codeboxapi.com)


pkgId: 94bf990847e4400333fc1f121092d761f97cc71bc70fa861374b61a018237837
name: python-codebuilder
arch: src
version: 0.0.1a3
epoch: 0
release: 1
summary: CLI helper for AWS CodeBuild and CodePipeline
url: http://github.com/wnkz/codebuilder
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codebuilder-0.0.1a3-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Docs| |Version| |License|
  CodeBuilder is a CLI tool which allows developpers to use simple commands
  and helpers inside AWS CI/CD tools like CodePipeline and CodeBuild.


pkgId: 30758840e938e61c1bb65c04baceb35302c53349844b642a1df89e2165ac3168
name: python-codecarbon
arch: src
version: 2.7.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://codecarbon.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codecarbon-2.7.1-1.src.rpm
checksum_type: sha256
description:
  ![banner](docs/edit/images/banner.png)

  Estimate and track carbon emissions from your computer, quantify and analyze their impact.

  [**Documentation**](https://mlco2.github.io/codecarbon)

  <br/>

  [![](https://anaconda.org/conda-forge/codecarbon/badges/version.svg)](https://anaconda.org/conda-forge/codecarbon)
  [![](https://img.shields.io/pypi/v/codecarbon?color=024758)](https://pypi.org/project/codecarbon/)
  [![DOI](https://zenodo.org/badge/263364731.svg)](https://zenodo.org/badge/latestdoi/263364731)
  [![Downloads](https://static.pepy.tech/badge/codecarbon/month)](https://pepy.tech/project/codecarbon)


  - [About CodeCarbon 💡](#about-codecarbon-)
  - [Quickstart 🚀](#quickstart-)
      - [Installation 🔧](#installation-)
      - [Start to estimate your impact 📏](#start-to-estimate-your-impact-)
        - [Monitoring your whole machine](#monitoring-your-machine-)
        - [In your python code](#in-your-python-code-)
        - [Visualize](#visualize-)
  - [Contributing 🤝](#contributing-)
  - [How To Cite 📝](#how-to-cite-)
  - [Contact 📝](#contact-)



  **CodeCarbon** started with a quite simple question:

  **What is the carbon emission impact of my computer program? :shrug:**

  We found some global data like "computing currently represents roughly 0.5% of the world’s energy consumption" but nothing on our individual/organisation level impact.

  At **CodeCarbon**, we believe, along with Niels Bohr, that "Nothing exists until it is measured". So we found a way to estimate how much CO<sub>2</sub> we produce while running our code.

  *How?*

  We created a Python package that estimates your hardware electricity power consumption (GPU + CPU + RAM) and we apply to it the carbon intensity of the region where the computing is done.

  ![calculation Summary](docs/edit/images/calculation.png)

  We explain more about this calculation in the [**Methodology**](https://mlco2.github.io/codecarbon/methodology.html#) section of the documentation.

  Our hope is that this package will be used widely for estimating the carbon footprint of computing, and for establishing best practices with regards to the disclosure and reduction of this footprint.

  **So ready to "change the world one run at a time"? Let's start with a very quick set up.**





  **From PyPI repository**
  ```python
  pip install codecarbon
  ```

  **From Conda repository**
  ```python
  conda install -c conda-forge codecarbon
  ```
  To see more installation options please refer to the documentation: [**Installation**](https://mlco2.github.io/codecarbon/installation.html#)



  To get an experiment_id enter:
  ```python
  ! codecarbon init
  ```
  You can now store it in a **.codecarbon.config** at the root of your project
  ```python
  [codecarbon]
  log_level = DEBUG
  save_to_api = True
  experiment_id = 2bcbcbb8-850d-4692-af0d-76f6f36d79b2 #the experiment_id you get with init
  ```
  Now you have 2 main options:



  In your command prompt use:
  ```codecarbon monitor```
  The package will track your emissions independently from your code.


  ```python
  from codecarbon import track_emissions
  @track_emissions()
  def your_function_to_track():
    
    ```
  The package will track the emissions generated by the execution of your function.

  There is other ways to use **codecarbon** package, please refer to the documentation to learn more about it:  [**Usage**](https://mlco2.github.io/codecarbon/usage.html#)



  You can now visualize your experiment emissions on the [dashboard](https://dashboard.codecarbon.io/).
  ![dashboard](docs/edit/images/dashboard.png)

  *Note that for now, all emissions data send to codecarbon API are public.*

  > Hope you enjoy your first steps monitoring your carbon computing impact!
  > Thanks to the incredible codecarbon community 💪🏼 a lot more options are available using *codecarbon* including:
  > - offline mode
  > - cloud mode
  > - comet integration...
  >
  > Please explore the [**Documentation**](https://mlco2.github.io/codecarbon) to learn about it
  > If ever what your are looking for is not yet implemented, let us know through the *issues* and even better become one of our 🦸🏼‍♀️🦸🏼‍♂️ contributors! more info 👇🏼




  We are hoping that the open-source community will help us edit the code and make it better!

  You are welcome to open issues, even suggest solutions and better still contribute the fix/improvement! We can guide you if you're not sure where to start but want to help us out 🥇

  In order to contribute a change to our code base, please submit a pull request (PR) via GitHub and someone from our team will go over it and accept it.

  Check out our [contribution guidelines :arrow_upper_right:](https://github.com/mlco2/codecarbon/blob/master/CONTRIBUTING.md)

  Contact [@vict0rsch](https://github.com/vict0rsch) to be added to our slack workspace if you want to contribute regularly!



  If you find CodeCarbon useful for your research, you can find a citation under a variety of formats on [Zenodo](https://zenodo.org/records/11171501).

  Here is a sample for BibTeX:
  ```tex
  @software{benoit_courty_2024_11171501,
    author       = {Benoit Courty and
                    Victor Schmidt and
                    Sasha Luccioni and
                    Goyal-Kamal and
                    MarionCoutarel and
                    Boris Feld and
                    Jérémy Lecourt and
                    LiamConnell and
                    Amine Saboni and
                    Inimaz and
                    supatomic and
                    Mathilde Léval and
                    Luis Blanche and
                    Alexis Cruveiller and
                    ouminasara and
                    Franklin Zhao and
                    Aditya Joshi and
                    Alexis Bogroff and
                    Hugues de Lavoreille and
                    Niko Laskaris and
                    Edoardo Abati and
                    Douglas Blank and
                    Ziyao Wang and
                    Armin Catovic and
                    Marc Alencon and
                    Michał Stęchły and
                    Christian Bauer and
                    Lucas Otávio N. de Araújo and
                    JPW and
                    MinervaBooks},
    title        = {mlco2/codecarbon: v2.4.1},
    month        = may,
    year         = 2024,
    publisher    = {Zenodo},
    version      = {v2.4.1},
    doi          = {10.5281/zenodo.11171501},
    url          = {https://doi.org/10.5281/zenodo.11171501}
  }
  ```



  Maintainers are [@vict0rsch](https://github.com/vict0rsch) [@benoit-cty](https://github.com/benoit-cty) and [@SaboniAmine](https://github.com/saboniamine). Codecarbon is developed by volunteers from [**Mila**](http://mila.quebec) and the [**DataForGoodFR**](https://twitter.com/dataforgood_fr) community alongside donated professional time of engineers at [**Comet.ml**](https://comet.ml) and [**BCG GAMMA**](https://www.bcg.com/en-nl/beyond-consulting/bcg-gamma/default).


pkgId: 0c812874490ce5757a058038f74346a9cc749013d5252d590b5a941f8c0b1963
name: python-codecarbon
arch: src
version: 2.7.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://codecarbon.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codecarbon-2.7.4-1.src.rpm
checksum_type: sha256
description:
  ![banner](docs/edit/images/banner.png)

  Estimate and track carbon emissions from your computer, quantify and analyze their impact.

  [**Documentation**](https://mlco2.github.io/codecarbon)

  <br/>

  [![](https://anaconda.org/conda-forge/codecarbon/badges/version.svg)](https://anaconda.org/conda-forge/codecarbon)
  [![](https://anaconda.org/codecarbon/codecarbon/badges/version.svg)](https://anaconda.org/codecarbon/codecarbon)
  [![](https://img.shields.io/pypi/v/codecarbon?color=024758)](https://pypi.org/project/codecarbon/)
  [![DOI](https://zenodo.org/badge/263364731.svg)](https://zenodo.org/badge/latestdoi/263364731)
  [![Downloads](https://static.pepy.tech/badge/codecarbon/month)](https://pepy.tech/project/codecarbon)


  - [About CodeCarbon 💡](#about-codecarbon-)
  - [Quickstart 🚀](#quickstart-)
      - [Installation 🔧](#installation-)
      - [Start to estimate your impact 📏](#start-to-estimate-your-impact-)
        - [Monitoring your whole machine](#monitoring-your-machine-)
        - [In your python code](#in-your-python-code-)
        - [Visualize](#visualize-)
  - [Contributing 🤝](#contributing-)
  - [How To Cite 📝](#how-to-cite-)
  - [Contact 📝](#contact-)



  **CodeCarbon** started with a quite simple question:

  **What is the carbon emission impact of my computer program? :shrug:**

  We found some global data like "computing currently represents roughly 0.5% of the world’s energy consumption" but nothing on our individual/organisation level impact.

  At **CodeCarbon**, we believe, along with Niels Bohr, that "Nothing exists until it is measured". So we found a way to estimate how much CO<sub>2</sub> we produce while running our code.

  *How?*

  We created a Python package that estimates your hardware electricity power consumption (GPU + CPU + RAM) and we apply to it the carbon intensity of the region where the computing is done.

  ![calculation Summary](docs/edit/images/calculation.png)

  We explain more about this calculation in the [**Methodology**](https://mlco2.github.io/codecarbon/methodology.html#) section of the documentation.

  Our hope is that this package will be used widely for estimating the carbon footprint of computing, and for establishing best practices with regards to the disclosure and reduction of this footprint.

  **So ready to "change the world one run at a time"? Let's start with a very quick set up.**





  **From PyPI repository**
  ```python
  pip install codecarbon
  ```

  **From Conda repository**
  ```python
  conda install -c codecarbon codecarbon
  ```
  To see more installation options please refer to the documentation: [**Installation**](https://mlco2.github.io/codecarbon/installation.html#)



  To get an experiment_id enter:
  ```python
  ! codecarbon init
  ```
  You can now store it in a **.codecarbon.config** at the root of your project
  ```python
  [codecarbon]
  log_level = DEBUG
  save_to_api = True
  experiment_id = 2bcbcbb8-850d-4692-af0d-76f6f36d79b2 #the experiment_id you get with init
  ```
  Now you have 2 main options:



  In your command prompt use:
  ```codecarbon monitor```
  The package will track your emissions independently from your code.


  ```python
  from codecarbon import track_emissions
  @track_emissions()
  def your_function_to_track():
    
    ```
  The package will track the emissions generated by the execution of your function.

  There is other ways to use **codecarbon** package, please refer to the documentation to learn more about it:  [**Usage**](https://mlco2.github.io/codecarbon/usage.html#)



  You can now visualize your experiment emissions on the [dashboard](https://dashboard.codecarbon.io/).
  ![dashboard](docs/edit/images/dashboard.png)

  *Note that for now, all emissions data send to codecarbon API are public.*

  > Hope you enjoy your first steps monitoring your carbon computing impact!
  > Thanks to the incredible codecarbon community 💪🏼 a lot more options are available using *codecarbon* including:
  > - offline mode
  > - cloud mode
  > - comet integration...
  >
  > Please explore the [**Documentation**](https://mlco2.github.io/codecarbon) to learn about it
  > If ever what your are looking for is not yet implemented, let us know through the *issues* and even better become one of our 🦸🏼‍♀️🦸🏼‍♂️ contributors! more info 👇🏼




  We are hoping that the open-source community will help us edit the code and make it better!

  You are welcome to open issues, even suggest solutions and better still contribute the fix/improvement! We can guide you if you're not sure where to start but want to help us out 🥇

  In order to contribute a change to our code base, please submit a pull request (PR) via GitHub and someone from our team will go over it and accept it.

  Check out our [contribution guidelines :arrow_upper_right:](https://github.com/mlco2/codecarbon/blob/master/CONTRIBUTING.md)

  Contact [@vict0rsch](https://github.com/vict0rsch) to be added to our slack workspace if you want to contribute regularly!



  If you find CodeCarbon useful for your research, you can find a citation under a variety of formats on [Zenodo](https://zenodo.org/records/11171501).

  Here is a sample for BibTeX:
  ```tex
  @software{benoit_courty_2024_11171501,
    author       = {Benoit Courty and
                    Victor Schmidt and
                    Sasha Luccioni and
                    Goyal-Kamal and
                    MarionCoutarel and
                    Boris Feld and
                    Jérémy Lecourt and
                    LiamConnell and
                    Amine Saboni and
                    Inimaz and
                    supatomic and
                    Mathilde Léval and
                    Luis Blanche and
                    Alexis Cruveiller and
                    ouminasara and
                    Franklin Zhao and
                    Aditya Joshi and
                    Alexis Bogroff and
                    Hugues de Lavoreille and
                    Niko Laskaris and
                    Edoardo Abati and
                    Douglas Blank and
                    Ziyao Wang and
                    Armin Catovic and
                    Marc Alencon and
                    Michał Stęchły and
                    Christian Bauer and
                    Lucas Otávio N. de Araújo and
                    JPW and
                    MinervaBooks},
    title        = {mlco2/codecarbon: v2.4.1},
    month        = may,
    year         = 2024,
    publisher    = {Zenodo},
    version      = {v2.4.1},
    doi          = {10.5281/zenodo.11171501},
    url          = {https://doi.org/10.5281/zenodo.11171501}
  }
  ```



  Maintainers are [@vict0rsch](https://github.com/vict0rsch) [@benoit-cty](https://github.com/benoit-cty) and [@SaboniAmine](https://github.com/saboniamine). Codecarbon is developed by volunteers from [**Mila**](http://mila.quebec) and the [**DataForGoodFR**](https://twitter.com/dataforgood_fr) community alongside donated professional time of engineers at [**Comet.ml**](https://comet.ml) and [**BCG GAMMA**](https://www.bcg.com/en-nl/beyond-consulting/bcg-gamma/default).


pkgId: 8ae48093e194f1ce4f1144fccd70c99447f46339216e0c10b6ad50b5510302f7
name: python-codecon
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: A machine learning library for economists
url: https://github.com/mickwzh/codecon
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codecon-0.9.1-1.src.rpm
checksum_type: sha256
description:
  - [愿景](#愿景)
  - [安装](#安装)
  - [使用](#使用)
    - ⚠️环境配置
    - ⚠️数据准备
    - tp_nlp:基于无监督文本聚类的标签启发
    - cl_nlp_findtrain:基于文本相似度的训练样本扩展
    - cl_nlp_train,cl_nlp_pred:基于BERT的模型训练与预测
    - gai_nlp:批量调取生成式AI接口
  - [python应急基础](#python应急基础)
  - [联系](#联系)







  经济学研究中大多数与文本分析相关任务都属于归类(Classification)问题。例如,情感分析(正向情感VS负向情感)、前瞻性分析(前瞻VS非前瞻)、是否与数字化转型相关(与数字化转型有关VS与数字化转型无关)。
  Prof. Melissa Dell(2024) 提供了一个非常实用的经济学研究的文本分类任务实践流程,本次更新对该流程进行了完整实现与补充。
  ![blob/dell_2024_flowchart.png](https://github.com/mickwzh/codecon/blob/main/blob/dell_2024_flowchart.png)
  (Dell, 2024)
  简要来说,这张图重点讲了两个事情:
  **第一,文本分类的机器学习实现主要有两个途径**
  - _有监督学习_:标注少量数据后训练基于深度学习的文本分类器
  - _生成式AI标注_:使用生成式AI,调整提示词,直接对文本进行标注
  **第二,在使用有监督学习方法之前,可以借助词向量(Embeddings,[点击此处了解词向量](https://github.com/mickwzh/codecon/blob/main/note/embedding_note%20copy.ipynb))辅助启发、扩充标签**
  - _标签启发_:使用词向量对文本进行聚类,启发标签
  - _训练集扩充_:通过计算词向量之间的相似度(语意相似度)辅助拓展训练集
  本次更新提供实现这两种功能的魔法命令
  - 四行命令实现BERT文本分类器训练全流程(标签启发,训练集扩充、模型训练、模型预测)
  - 批量调取生成式AI API接口进行文本分类
  个人非常喜欢 Prof. Melissa Dell 的工作,严谨、实用、有深度, 另分享Prof. Melissa Dell 最新关于此篇深度学习如何应用在经济学研究中的的[文章笔记](https://github.com/mickwzh/codecon/blob/main/note/MelissaDell_2024_note.pdf)
  Dell, M. (2024). Deep learning for economists (No. w32768). National Bureau of Economic Research.


  ```python
  pip install codecon --upgrade -i https://pypi.org/simple
  ```

  ```
  pip install codecon --upgrade -i https://pypi.tuna.tsinghua.edu.cn/simple
  ```

  ```python
  git clone https://github.com/mickwzh/codecon.git
  ```

  **百度网盘**: `https://pan.baidu.com/s/1dIrQQnOl6spZv6Jet48eQA?pwd=dvqm 提取码: dvqm`
  **Dropbox**: `https://www.dropbox.com/scl/fo/9ut3qtfradrde9tp6kslc/ANPvqvIgi2Lkf5t6TDuqiCc?rlkey=iw3seyzgpz9utmnj6xtdgej22&st=cywzuwmc&dl=0`


  所谓环境，是指**一套**符合当前所需功能的工具包。
  python的方便之处在于有大量封装好的工具包；但这些工具包往往依赖于其他的工具包。
  - 假设`A`和B两个python库分别使用的是`C1`和`C2`,
  - `C1`和`C2`是`C`的两个不同版本，一个环境里通常只能安装一个`C`
  - 使用`A`必须使用`C1`，使用B必须使用`C2`
  - 所以如果先安装了`A`，就会导致安装B出错 (`C`的版本不兼容); 反之亦然。
  如果你通过`pip`的方式安装`codecon`，其会自动配置好实现codecon的环境，但前提是你的旧环境中没有与codecon所依赖的工具包相冲突的工具包。
  **因此，建议在安装`codecon`前配置一个新环境。**
  这里提供了适合初学者上手的两种（无代码）创建新环境的方案：[ANACONDA&Spyder(本地运行)](https://github.com/mickwzh/codecon/blob/main/note/anaconda_intro.pdf) 和 [Featurize&JupyterNote(在线运行)](https://github.com/mickwzh/codecon/blob/main/note/featurize_intro.pdf) 。点击可获取相应pdf版指南。


pkgId: 95bbefe9d8637f6d57f700c1b4cbdc1c9d77ece7331e46e79a29237d664bd9f7
name: python-codeconcat
arch: src
version: 0.1.19
epoch: 0
release: 1
summary: A tool to concatenate a folders into a single text file
url: https://github.com/lguibr/CodeConcat
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeconcat-0.1.19-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/lguibr/codeconcat/workflows/CI/badge.svg)](https://github.com/lguibr/codeconcat/actions)
  [![PyPI](https://img.shields.io/pypi/v/codeconcat.svg)](https://pypi.org/project/codeconcat/)
  [![Python Version](https://img.shields.io/pypi/pyversions/codeconcat.svg)](https://pypi.org/project/codeconcat/)
  [![License](https://img.shields.io/pypi/l/codeconcat.svg)](https://github.com/lguibr/codeconcat/blob/main/LICENSE)

  **CodeConcat** is a powerful command-line tool designed to simplify the process of concatenating the entire contents of local directories or code repositories into a single text file. This tool is particularly useful for developers who need to prepare large datasets for analysis or training in machine learning models, especially those that benefit from understanding the broader context provided by having complete codebases in a single file.



  - **Efficiency**: Quickly concatenate entire directories or repositories.
  - **Flexibility**: Use include and exclude patterns to control exactly what gets included in the output.
  - **Clarity**: Each file's path is included in the output, maintaining the context necessary for large language models.
  - **Simplicity**: A straightforward command-line interface that integrates easily into any developer's workflow.



  You can install CodeConcat directly from PyPI:

  ```bash
  pip install codeconcat
  ```





  ```bash
  codeconcat <source_path> <destination_file> [--exclude <pattern>] [--whitelist <pattern>]
  ```



  - `<source_path>`: Path to the directory or repository to process.
  - `<destination_file>`: Path where the concatenated output will be saved.
  - `--exclude <pattern>`: (Optional) Exclude files matching this pattern.
  - `--whitelist <pattern>`: (Optional) Only include files matching this pattern.



  **Basic Concatenation:**

  ```bash
  codeconcat ./my-repo output.txt
  ```

  **Using Exclude Patterns:**

  ```bash
  codeconcat ./my-repo output.txt --exclude "*.log"
  ```

  **Using Whitelist Patterns:**

  ```bash
  codeconcat ./my-repo output.txt --whitelist "*.py"
  ```



  Contributions to CodeConcat are welcome! Please check out the [issues on GitHub](https://github.com/lguibr/codeconcat/issues) or submit a pull request if you have an improvement or bug fix.



  CodeConcat is distributed under the MIT license. See the [LICENSE](LICENSE) file for more details.


pkgId: 6eca21cf3936e75480008ae6d57093879a1eca79d6a92e952f13c6f3a2292994
name: python-codeconsolidator
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Consolidates and analyzes codebases for insights.
url: https://github.com/kamilstanuch/codeconsolidator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeconsolidator-0.1.8-1.src.rpm
checksum_type: sha256
description:
  CodeConsolidator is a command-line tool written in Python that helps you analyze and understand your codebase. It provides a structured overview of your project's directory structure, file sizes, token counts, and even consolidates the content of all text-based files into a single output for easy analysis with Large Language Models (LLMs).



  * **Directory Tree Visualization:** Generates a hierarchical tree view of your project's directory structure, optionally including file sizes and ignoring specified files/directories.
  * **Codebase Statistics:** Calculates total files, directories, code size, and token counts for your project.
  * **File Content Consolidation:** Consolidates the content of all text-based files into a single output file (useful for LLM analysis).
  * **.gitignore Support:** Respects your .gitignore file to exclude unwanted files and directories from the analysis.
  * **Customizable Output:** Choose between text or JSON output formats and customize the level of detail included.
  * **Colored Console Output:** Provides a visually appealing and informative summary in the console.



  ```bash
  pip install tiktoken colorama
  ```

  ```bash
  python codeconsolidator.py [path_to_directory] [options]
  ```


  ```bash
  path_to_directory: Path to the directory you want to analyze.
  -d, --max-depth: Maximum depth for directory traversal.
  -o, --output: Output format (text or json). Default: text.
  -f, --file: Output file name (default: codebase_analysis.txt or codebase_analysis.json).
  --show-tree: Show directory tree in console output (always included in text file output).
  --show-size: Show file sizes in directory tree.
  --show-ignored: Show ignored files and directories in tree.
  --ignore-ext: Additional file extensions to ignore (e.g., .pyc .log).
  --no-content: Exclude file contents from the output.
  --include-git: Include .git directory in the analysis.
  --max-size: Maximum allowed text content size in KB (default: 10240 KB).
  ```

  ```bash
  python codeconsolidator.py my_project -d 3 -o json --show-size --ignore-ext .pyc .log
  ```







  ```bash
  **Objective:** Identify potential errors and inconsistencies within the provided codebase.

  **Instructions:**

  1. **Analyze the attached code** for the following:
      * Syntax errors and logical flaws.
      * Inconsistencies in variable and function naming conventions.
      * Code duplication.
      * Performance bottlenecks.
      * Violations of established coding best practices.
  2. **Structure your analysis clearly**, pinpointing specific code snippets and providing detailed descriptions of the identified issues.
  3. **Prioritize clarity and conciseness** in your explanations.

  **Expected Output:** A comprehensive report detailing errors and inconsistencies, organized by code section or error type, with actionable insights for improvement.
  ```



  ```bash
  **Objective:** Identify code segments within the provided codebase that could potentially lead to future issues.

  **Instructions:**

  1. **Analyze the attached code** with a focus on:
      * Code that is difficult to understand and maintain (code smells).
      * Fragments that might cause errors under specific conditions (edge cases).
      * Code that deviates from established coding standards.
  2. **Provide detailed justifications for your concerns**, explaining the potential risks associated with each identified segment.
  3. **Suggest potential solutions or mitigation strategies** to address the identified risks.

  **Expected Output:** A report highlighting potential risk areas within the codebase, with clear explanations of the risks and actionable recommendations for improvement.
  ```



  ```bash
  **Objective:** Generate comprehensive and user-friendly documentation for the provided codebase.

  **Instructions:**

  1. **Analyze the attached code** and identify key components, functionalities, and APIs.
  2. **Generate documentation that includes:**
      * API specifications with detailed descriptions of endpoints, parameters, and responses.
      * Function descriptions with clear explanations of their purpose, inputs, and outputs.
      * Usage examples demonstrating how to interact with the codebase effectively.
  3. **Structure the documentation logically** and use a consistent format for clarity.
  4. **Prioritize clarity, conciseness, and accuracy** in your documentation.

  **Expected Output:**  Well-structured and informative documentation that facilitates understanding and utilization of the codebase by developers and other stakeholders.
  ```





  ```bash
  **Objective:** Reconstruct the user stories that likely served as the basis for the development of the provided codebase.

  **Instructions:**

  1. **Analyze the attached code** to identify the core functionalities of the application.
  2. **Infer the user needs** that each functionality aims to address.
  3. **Formulate user stories** using the following template: "As a [user role], I want [functionality], so that [benefit]."
  4. **Identify potential missing user stories**. Suggest functionalities that could be added to the application to better meet user needs.

  **Expected Output:** A list of reconstructed user stories based on the code's functionalities, along with insights into potential missing user stories and suggestions for application enhancements.
  ```



  ```bash
  **Objective:** Create a series of mini-lessons that explain the key concepts implemented within the provided codebase.

  **Instructions:**

  1. **Divide the code into logical sections** and create a separate lesson for each.
  2. **Start with the simplest concepts** and gradually progress to more complex ones.
  3. **Use code examples from the application** to illustrate the discussed concepts.
  4. **Include exercises and quizzes** to help learners test their understanding.
  5. **Focus on clarity and pedagogical effectiveness** in your lesson design.

  **Expected Output:** A set of well-structured mini-lessons covering the key concepts of the application, with code examples, exercises, and quizzes to facilitate learning.
  ```





  ```bash
  **Objective:** Analyze the provided codebase and identify examples of both good and bad programming practices.

  **Instructions:**

  1. **Carefully review the attached code** and pinpoint instances of exemplary and problematic coding practices.
  2. **For each example, provide a detailed analysis** that includes:
      * **What is good/bad about the specific solution?**
      * **What concepts or principles underpin the solution?**
      * **What are the potential positive/negative consequences of using this solution?**

  **Expected Output:** A comprehensive report highlighting both positive and negative coding practices within the codebase, with in-depth explanations and analysis of their impact.
  ```



  ```bash
  **Objective:**  Translate the provided codebase from [Source Language] to [Target Language] while preserving its functionality and structure.

  **Instructions:**

  1. **Analyze the attached code** written in [Source Language] and understand its logic and functionalities.
  2. **Translate the code** into [Target Language], ensuring that the translated code performs the same tasks as the original code.
  3. **Maintain the original code's structure and organization** as much as possible in the translated version.
  4. **Adhere to the coding conventions and best practices** of the target language.
  5. **Comment the translated code** to explain any significant changes or adaptations made during the translation process.

  **Expected Output:** A functional codebase in [Target Language] that accurately reflects the functionality and structure of the original [Source Language] codebase.
  ```



  ```bash
  **Objective:** Refactor the provided codebase to enhance its readability, maintainability, and performance.

  **Instructions:**

  1. **Analyze the attached code** and identify areas that can be improved in terms of code clarity, structure, and efficiency.
  2. **Suggest specific code transformations and optimizations** to address the identified areas for improvement.
  3. **Prioritize refactoring techniques** that improve code readability without introducing unnecessary complexity.
  4. **Consider performance implications** of your suggested refactoring and aim for solutions that enhance efficiency without sacrificing clarity.
  5. **Provide clear explanations** for each refactoring suggestion, justifying its benefits and potential impact.

  **Expected Output:**  A set of actionable refactoring suggestions with detailed explanations of their benefits and potential impact on code quality and performance.
  ```





  ```bash
  **Objective:** Generate unit tests for the provided codebase to ensure code correctness and prevent regressions.

  **Instructions:**

  1. **Analyze the attached code** and identify its core functions and methods.
  2. **Generate unit tests** that cover a wide range of input values and expected outputs for each function/method.
  3. **Follow best practices for unit testing**, including:
      * **Test one function/method per test case.**
      * **Use descriptive test names.**
      * **Assert expected outcomes clearly.**
      * **Keep tests independent and isolated.**
  4. **Prioritize test coverage for critical functionalities** and edge cases.

  **Expected Output:** A comprehensive suite of unit tests that can be used to verify the correctness of the codebase and prevent regressions during future development.
  ```



  ```bash
  **Objective:** Identify potential security vulnerabilities within the provided codebase.

  **Instructions:**

  1. **Analyze the attached code** with a focus on identifying common security weaknesses such as:
      * SQL injection.
      * Cross-site scripting (XSS).
      * Cross-site request forgery (CSRF).
      * Authentication and authorization bypasses.
      * Data exposure.
  2. **For each identified vulnerability, provide a detailed explanation** of:
      * The nature of the vulnerability.
      * The potential impact of exploitation.
      * Recommendations for mitigation using secure coding practices.
  3. **Prioritize vulnerabilities based on their severity and potential impact.**

  **Expected Output:** A comprehensive security report highlighting potential vulnerabilities within the codebase, along with clear explanations of their risks and actionable recommendations for remediation.
  ```


pkgId: 675a2a9429048c760249cb08c8d92b96e3ea74cd9c7140b122ccf7e61d991372
name: python-codecontextor
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A tool for extracting codebase context for LLM conversations
url: https://github.com/ergut/codecontextor
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codecontextor-1.0.0-1.src.rpm
checksum_type: sha256
description:
  CodeContextor is a lightweight Python tool designed for quick and simple context extraction from your codebase for Large Language Model (LLM) conversations. Instead of copying files manually or explaining your project structure repeatedly, CodeContextor generates a single file containing:
  1. A complete directory tree of your project
  2. Contents of key files you specify

  This approach allows you to:
  - Start conversations with LLMs by providing clear project structure
  - Include only the most relevant files initially
  - Let the LLM request additional files from the tree as needed during the conversation
  - Automatically include all files in a directory (with size warning and confirmation)

  The tool is intentionally kept simple and focused on this single task to make it easy to use and modify.



  - Generate a complete tree structure of your project
  - Include full contents of specified key files
  - Support for .gitignore patterns
  - Exclude specific files or directories
  - Conversation-friendly output format
  - Auto-include all files with confirmation (if no specific files are provided)
  - Size warnings and large file protection



  ```bash

  git clone https://github.com/ergut/codecontextor


  pip install -r requirements.txt
  ```



  Basic usage:

  ```bash


  python codecontextor.py --directory ./my_project


  python codecontextor.py --files main.py config.yaml --directory ./my_project


  python codecontextor.py --files-list important_files.txt --directory ./my_project
  ```



  - `--directory`: Project directory to analyze (default: current directory)
  - `--files`: List of files to include in full
  - `--files-list`: Text file containing list of files to include
  - `--output`: Output file name (default: project_context.txt)
  - `--no-gitignore`: Disable .gitignore-based exclusions
  - `--exclude-file`: File containing additional exclude patterns (uses .gitignore syntax)



  ```text
  src/main.py
  config/settings.yaml
  README.md
  ```


  ```text

  *.pyc
  __pycache__/
  .env
  temp/
  *.log

  ```



  The generated file includes:
  1. A header with project information
  2. Complete directory tree
  3. Full contents of specified files (or all files if none specified)

  Example output structure:
  ```

  Generated on: 2024-11-28 10:30:00
  Project Path: /path/to/project


  1. The tree structure below shows ALL available files in the project
  2. Some key files are included in full after the tree
  3. During conversation, you can request the contents of any file shown in the tree


  my_project/
  ├── src/
  │   ├── main.py
  │   └── utils.py
  ├── config/
  │   └── settings.yaml
  └── README.md


  [Contents of specified files...]
  ```



  When no specific files are provided, CodeContextor will:
  1. Calculate the total size of all files in the directory
  2. Show a warning with the total size
  3. Ask for user confirmation before proceeding
  4. Skip any individual files larger than 10MB to prevent massive context files
  5. Respect .gitignore patterns by default



  1. Generate the context file for your project:
     - Use specific files: `python codecontextor.py --files main.py config.py`
     - Include all files: `python codecontextor.py` (will ask for confirmation)
  2. Start a conversation with an LLM
  3. Share the generated file at the beginning of the conversation
  4. The LLM can now:
     - See the complete project structure
     - Access contents of included files
     - Request additional files from the tree as needed



  Contributions are welcome! Please feel free to submit a Pull Request.



  CodeContextor includes a comprehensive test suite covering all major functionality. For detailed information about running tests, test coverage, and contributing new tests, please see [README.test.md](README.test.md).

  Basic test execution:
  ```bash
  python -m unittest tests/test_main.py -v
  ```



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



  - Thanks to the pathspec library for .gitignore pattern matching
  - Inspired by the need for better context in LLM conversations about code



  Salih Ergüt



  - 1.0.1 (2024-11-28)
    - Added automatic all-files inclusion feature
    - Added size warnings and confirmation
    - Added large file protection (>10MB files are skipped)

  - 1.0.0 (2024-11-28)
    - Initial release
    - Basic file tree generation
    - File content merging
    - .gitignore support


pkgId: c9d80cfeafaa824aac6377906842e261d242ee7137a304cb58902ee6f17401b2
name: python-codecontextor
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Create context files from your codebase for AI conversations
url: https://pypi.org/project/codecontextor/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codecontextor-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Ever needed to explain your codebase to ChatGPT or Claude? CodeContextor creates a perfect snapshot of your project in seconds:

  ```bash

  codecontextor --directory ./my_project
  ```



  ```text
  my_project/
  ├── src/
  │   └── main.py     # LLMs can request this file if needed!
  └── config/
      └── settings.yaml


  ```

  Just paste this into your AI chat and start coding! The AI can see your project structure and request any file it needs.



  ```bash

  pip install codecontextor


  codecontextor --directory ./my_project


  codecontextor --files main.py config.yaml
  ```



  - **Simple**: One command to create perfect context for AI conversations
  - **Smart**: Respects .gitignore, handles large files, includes safety checks
  - **Flexible**: Include specific files or let the AI see everything
  - **Safe**: Warns you about size and skips files >10MB



  - 📁 Complete project tree generation
  - 📄 Automatic or selective file inclusion
  - 🔒 .gitignore pattern support
  - ⚡ Large file protection
  - 🎮 Custom file exclusions
  - 📊 Size warnings and confirmations



  Need more control? We've got you covered:

  ```bash

  codecontextor --files-list important_files.txt


  codecontextor --exclude-file exclude_patterns.txt


  codecontextor --no-gitignore


  codecontextor --prefix-file project_overview.txt --appendix-file api_docs.txt


  codecontextor --prefix-file schemas.txt --appendix-file deployment.txt
  ```



  | Option | Description |
  |--------|-------------|
  | `--directory` | Project directory (default: current) |
  | `--files` | Specific files to include |
  | `--files-list` | File containing list of files |
  | `--smart-select` | Automatically select important files like entry points, configs, and docs |
  | `--prefix-file` | Essential context to add at start (schemas, overview) |
  | `--appendix-file` | Supplementary info to add at end (docs, guides) |
  | `--output` | Output filename (default: project_context.txt) |
  | `--estimate-tokens` | Calculate and show estimated token count in the output file |
  | `--no-gitignore` | Disable .gitignore patterns |
  | `--exclude-file` | Additional exclude patterns file |




  ```text
  src/main.py
  config/settings.yaml
  README.md
  ```


  ```text
  *.pyc
  __pycache__/
  .env
  *.log
  ```



  CodeContextor looks out for you:
  - Calculates total file size
  - Shows warning for large directories
  - Asks for confirmation
  - Skips files >10MB
  - Respects .gitignore by default



  ```bash

  pip install codecontextor


  git clone https://github.com/ergut/codecontextor
  pip install -r requirements.txt
  ```



  We love contributions! Check out [README.test.md](README.test.md) for:
  - Running tests
  - Test coverage details
  - Adding new features
  - Contributing guidelines



  MIT License - See [LICENSE](LICENSE) file



  - 🐛 [Report issues](https://github.com/ergut/codecontextor/issues)
  - 💡 [Feature requests](https://github.com/ergut/codecontextor/issues)
  - 📖 [Documentation](https://github.com/ergut/codecontextor)



  Salih Ergüt



  Current version: 1.0.3

  See [CHANGELOG.md](CHANGELOG.md) for version history and updates.


pkgId: 81c528e9d2ef7015d22eb21d91a16e96c428295ae77f249d8585ae39ab9a92db
name: python-codecov-cli
arch: src
version: 0.7.6
epoch: 0
release: 1
summary: Codecov Command Line Interface
url: https://pypi.org/project/codecov-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codecov-cli-0.7.6-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/codecov/codecov-cli/branch/master/graph/badge.svg?token=jN0CICuA6Z)](https://codecov.io/gh/codecov/codecov-cli)
  [![Build-Test-Upload](https://github.com/codecov/codecov-cli/actions/workflows/push_flow.yml/badge.svg)](https://github.com/codecov/codecov-cli/actions/workflows/push_flow.yml)

  CodecovCLI is a new way for users to interact with Codecov directly from the user’s terminal or CI platform. Many Codecov features that require the user’s interference can be done via the codecovCLI. It saves commits, creates reports, uploads coverage and has many more features.

  - [CodecovCLI](#codecovcli)
  - [Installing](#installing)
    - [Using PIP](#using-pip)
    - [As a Binary](#as-a-binary)
      - [Integrity Checking the Binary](#integrity-checking-the-binary)
  - [How to Upload to Codecov](#how-to-upload-to-codecov)
    - [How to Get an Upload Token](#how-to-get-an-upload-token)
  - [Usage](#usage)
  - [Codecov-cli Commands](#codecov-cli-commands)
    - [create-commit](#create-commit)
    - [create-report](#create-report)
    - [do-upload](#do-upload)
    - [create-report-results](#create-report-results)
    - [get-report-results](#get-report-results)
    - [pr-base-picking](#pr-base-picking)
    - [send-notifications](#send-notifications)
    - [empty-upload](#empty-upload)
  - [How to Use Local Upload](#how-to-use-local-upload)
  - [Work in Progress Features](#work-in-progress-features)
    - [Plugin System](#plugin-system)
    - [Static Analysis](#static-analysis)
  - [Contributions](#contributions)
    - [Requirements](#requirements)
    - [Guidelines](#guidelines)
    - [Dependencies](#dependencies)
  - [Releases](#releases)




  To use codecov-cli in your local machine, or your CI workflows, you need to install it:

  `pip install codecov-cli`

  The above command will download the latest version of Codecov-cli. If you wish to use a specific version, releases can be viewed [here](https://pypi.org/project/codecov-cli/#history).

  Note: If you're installing in a `pyenv` environment, you may need to call `pyenv rehash` before the CLI will work.


  If you would like to use the CLI in an environment that does not have access to Python / PIP, you can install the CLI as a compiled binary. Linux and macOS releases can be found [here](https://cli.codecov.io/), along with SHASUMs and signatures for each released version. Binary releases are also available via [Github releases](https://github.com/codecov/codecov-cli/releases) on this repository.

  You can retrieve the Binary for Linux directly from your command line as follows:

  ```
  curl -Os https://cli.codecov.io/latest/linux/codecov
  sudo chmod +x codecov
  ./codecov --help
  ```



  The binary can be integrity checked using a SHASUM256 and SHASUM256.sig file. The process for macos and Linux is identical. Linux is as follows:

  ```
  curl https://keybase.io/codecovsecurity/pgp_keys.asc | gpg --no-default-keyring --keyring trustedkeys.gpg --import # One-time step
  curl -Os https://cli.codecov.io/latest/linux/codecov
  curl -Os https://cli.codecov.io/latest/linux/codecov.SHA256SUM
  curl -Os https://cli.codecov.io/latest/linux/codecov.SHA256SUM.sig

  gpgv codecov.SHA256SUM.sig codecov.SHA256SUM

  shasum -a 256 -c codecov.SHA256SUM
  ```

  For macos you will want to use the macos distributions of the binary (e.g., https://cli.codecov.io/latest/macos/codecov)



  If desired, the CLI can be used as a replacement for our [NodeJS Binary Uploader](https://github.com/codecov/uploader). To use the CLI to upload from your CI workflow, you need to add these commands:

  ```
  pip install codecov-cli
  codecovcli create-commit
  codecovcli create-report
  codecovcli do-upload
  ```
  OR
  ```
  pip install codecov-cli
  codecovcli upload-process
  ```
  codecovcli upload-process is a wrapper for create-commit, create-report and do-upload.

  You can customize the commands with the options aligned with each command.

  Note that these commands will automatically search your environment for a `$CODECOV_TOKEN` environment variable and use it if found. If you do not have a repository upload token, or global upload token, stored as an environment variable, you will need to pass it into **each command manually**, like so: `-t {$CODECOV_TOKEN}`.


  The following tokens are suitable for uploading:

  * The [Repository Upload Token](https://docs.codecov.com/docs/codecov-uploader#upload-token): Found on the settings page of your repository, also viewable on the `/new` page when setting up a repository on Codecov for the first time.
  * The [Global Upload Token](https://docs.codecov.com/docs/codecov-uploader#organization-upload-token): Found on your organization settings page (e.g., `https://app.codecov.io/account/<scm>/<org>/org-upload-token`).



  If the installation is successful, running `codecovcli --help` will output the available commands along with the different general options that can be used with them.
  ```
  Usage: codecovcli [OPTIONS] COMMAND [ARGS]...
  ```
  Codecov-cli supports user input. These inputs, along with their descriptions and usage contexts, are listed in the table below:

  | Input  | Description | Usage |
  | :---:     |     :---:   |    :---:   |
  | `--auto-load-params-from`  | The CI/CD platform   | Optional |
  | `--codecov-yml-path` | The path for your codecov.yml  | Optional
  | `--enterprise-url` | Change the upload host (Enterprise use) | Optional
  | `--version` | Codecov-cli's version | Optional
  | `--verbose` or `-v` | Run the cli with verbose logging | Optional


  | Command  | Description |
  | :---:     |     :---:   |
  | `create-commit` | Saves the commit's metadata in codecov, it's only necessary to run this once per commit
  | `create-report` | Creates an empty report in codecov with initial data e.g. report name, report's commit
  | `do-upload` | Searches for and uploads coverage data to codecov
  | `create-report-results` | Used for local upload. It tells codecov that you finished local uploading and want it to calculate the results for you to get them locally.
  | `get-report-results` | Used for local upload. It asks codecov to provide you the report results you calculated with the previous command.
  | `pr-base-picking` | Tells codecov that you want to explicitly define a base for your PR
  | `upload-process` | A wrapper for 3 commands. Create-commit, create-report and do-upload. You can use this command to upload to codecov instead of using the previosly mentioned commands.
  | `send-notifications` | A command that tells Codecov that you finished uploading and you want to be sent notifications. To disable automatically sent notifications please consider adding manual_trigger to your codecov.yml, so it will look like codecov: notify: manual_trigger: true.
  >**Note**: Every command has its own different options that will be mentioned later in this doc. Codecov will try to load these options from your CI environment variables, if not, it will try to load them from git, if not found, you may need to add them manually.




  `codecovcli create-commit [Options]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  | -C, --sha, --commit-sha | Commit SHA (with 40 chars) | Required
  |--parent-sha | SHA (with 40 chars) of what should be the parent of this commit | Optional
  |-P, --pr, --pull-request-number| Specify the pull request number manually. Used to override pre-existing CI environment variables | Optional
  |-B, --branch | Branch to which this commit belongs to | Optional
  |-r, --slug | owner/repo slug used instead of the private repo token in Self-hosted | Required
  |-t, --token | Codecov upload token | Required
  |--git-service | Git Provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Required
  |-h, --help | Shows usage, and command options



  `codecovcli create-report [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  | -C, --sha, --commit-sha | Commit SHA (with 40 chars) | Required
  |-r, --slug | owner/repo slug used instead of the private repo token in Self-hosted | Required
  |-t, --token | Codecov upload token | Required
  |--git-service | Git Provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Required
  |--code| The code of the report. This is used in local uploading to isolate local reports from regular or cloud reports uploaded to codecov so they don't get merged. It's basically a name you give to your report e.g. local-report. | Optional
  |-h, --help | Shows usage, and command options


  `codecovcli do-upload [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  |-C, --sha, --commit-sha|    Commit SHA (with 40 chars) | Required
  |--report-code | The code of the report defined when creating the report. If unsure, leave default | Optional
  |--network-root-folder |      Root folder from which to consider paths on the network section  default: (Current working directory) | Optional
  |-s, --dir, --coverage-files-search-root-folder | Folder where to search for coverage files default: (Current Working Directory) | Optional
  |--exclude, --coverage-files-search-exclude-folder | Folders to exclude from search | Optional
  |-f, --file, --coverage-files-search-direct-file | Explicit files to upload | Optional
  |--disable-search | Disable search for coverage files. This is helpful when specifying what files you want to upload with the --file option.| Optional
  |-b, --build, --build-code | Specify the build number manually | Optional
  |--build-url | The URL of the build where this is running | Optional
  |--job-code | The job code for the CI run | Optional
  |-t, --token | Codecov upload token | Required
  |-n, --name | Custom defined name of the upload. Visible in Codecov UI | Optional
  |-B, --branch | Branch to which this commit belongs to | Optional
  |-r, --slug | owner/repo slug | Required
  |-P, --pr, --pull-request-number | Specify the pull request number manually. Used to override pre-existing CI environment variables | Optional
  |-e, --env, --env-var | Specify environment variables to be included with this build. | Optional
  |-F, --flag | Flag the upload to group coverage metrics. Multiple flags allowed. | Optional
  |--plugin | plugins to run. Options: xcode, gcov, pycoverage. The default behavior runs them all. | Optional
  |-Z, --fail-on-error | Exit with non-zero code in case of error uploading.|Optional
  |-d, --dry-run | Don't upload files to Codecov | Optional
  |--legacy, --use-legacy-uploader | Use the legacy upload endpoint | Optional
  |--git-service | Git Provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Required
  |-h, --help | Shows usage, and command options


  `codecovcli create-report-results [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  |--commit-sha | Commit SHA (with 40 chars) | Required
  |--code | The code of the report. If unsure, leave default | Required
  |--slug | owner/repo slug | Required
  |--git-service | Git provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  |-t, --token | Codecov upload token | Required
  |-h, --help | Shows usage, and command options


  `codecovcli get-report-results [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  |--commit-sha | Commit SHA (with 40 chars) | Required
  |--code | The code of the report. If unsure, leave default | Required
  |--slug | owner/repo slug | Required
  |--git-service | Git provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  |-t, --token | Codecov upload token | Required
  |-h, --help | Shows usage, and command options


  `codecovcli pr-base-picking [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  |--base-sha | Base commit SHA (with 40 chars) | Required
  |--pr  | Pull Request id to associate commit with | Required
  |--slug | owner/repo slug | Required
  |-t, --token| Codecov upload token | Required
  |--service | Git provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  |-h, --help | Shows usage, and command options


  `codecovcli send-notifications [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  | -C, --sha, --commit-sha TEXT    |Commit SHA (with 40 chars) | Required
  | -r, --slug TEXT                 |owner/repo slug used instead of the private repo token in Self-hosted | Required
  | -t, --token TEXT                |Codecov upload token | Required
  | --git-service | Git provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  | -h,--help                      |Show this message and exit.



  Used if the changes made don't need testing, but PRs require a passing codecov status to be merged.
  This command will scan the files in the commit and send passing status checks configured if all the changed files
  are ignored by codecov (including README and configuration files)

  `Usage: codecovcli empty-upload [OPTIONS]`

  | Options | Description | usage
  | :---:  |  :---:  |  :---:  |
   | -C, --sha, --commit-sha TEXT    |Commit SHA (with 40 chars)  | Required
   |  -t, --token TEXT                |Codecov upload token |Required
  |  -r, --slug TEXT               |  owner/repo slug used instead of the private repo token in Self-hosted | Optional
  |  -Z, --fail-on-error            | Exit with non-zero code in case of error|Optional
  |  --git-service| Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  | -h, --help                   |   Show this message and exit.|Optional



  The CLI also supports "dry run" local uploading. This is useful if you prefer to see Codecov status checks and coverage reporting locally, in your terminal, as opposed to opening a PR and waiting for your full CI to run. Local uploads do not interfere with regular uploads made from your CI for any given commit / Pull Request.

  Local Upload is accomplished as follows:

  ```
  pip install codecov-cli
  codecovcli create-commit
  codecovcli create-report --code <CODE>
  codecovcli do-upload --report-code <CODE>
  codecovcli create-report-results --code <CODE>
  codecovcli get-report-results --code <CODE>
  ```

  Codecov will calculate the coverage results, and return them in your terminal, telling you whether your PR will fail or pass the coverage check.

  Note: In order for Local Upload to work, it must be used against a commit on the origin repository. Local Upload does not work for arbitrary diffs or uncommitted changes on your local machine.



  The following features are somewhat implemented in code, but are not yet meant for use. These features will be documented once they are fully implemented in the CLI.



  To provide extensibility to some of its commands, the CLI makes use of a plugin system. For most cases, the default commands are sufficient. But in some cases, having some custom logic specific to your use case can be beneficial. Note that full documentation of the plugin system is pending, as the feature is still heavily a work in progress.



  The CLI can perform basic static analysis on Python code today. This static analysis is meant to power more future looking Codecov features and, as such, is not required or in active use today. As more functionality dependent on static analysis becomes available for use, we will document static analysis in detail here.



  This repository, like all of Codecov's repositories, strives to follow our general [Contributing guidlines](https://github.com/codecov/contributing). If you're considering making a contribution to this repository, we encourage review of our Contributing guidelines first.



  Most of this package is a very conventional Python package. The main difference is the static the CLI's analysis module uses both git submodules and C code

  Before installing, one should pull the submodules with:

  ```
  git submodule update --init
  ```
  Then, install dependencies with
  ```
  pip install -r requirements.txt
  python setup.py develop
  ```

  The C code shouldn't require any additional setup to get running, but depending on your environment, you may be prompted to install compilers and supporting tools. If errors are generated during installation, it is likely due to missing dependencies / tools required of the C code. In many cases, resulting error messages should be clear enough to determine what is missing and how to install it, but common errors will be collected here as they are encountered.



  There are a few guidelines when developing in this system. Some notable folders:

  1. `commands` - It's the folder that interacts with the caller. This is where the commands themselves should reside. These commands are not meant to do heavy lifting. They only do wiring, which is mostly parsing the input parameters.
  2. `services` - It's where the heavy logic resides. It's mostly organized by which command needs them. Commands should generally be thin wrappers around these services.
  3. `helpers` - This is meant for logic that is useful across different commands. For example, logging helpers, or the logic that searches folders.



  If external dependencies need to be added, it's important to check whether those dependencies have wheels available on PyPI with the `any` or `universal2` platform tags. If those dependencies don't have those wheels available, then they will need to built during the CI, so they will have to be added to the list of
  dependencies in the `--no-binary` flag when building the requirements for the macos release in `build_assets.yml`.



  The standard way to making a new release is the following:
  1)  Open a PR that increases the version number in setup.py. As a rule of thumb, just add one to the micro/patch version (e.g., v0.1.6 -> v0.1.7).

  2) Get the up-to-date master branch locally and run the `tag.release` command from the Makefile.

  `$ make tag.release version=v<VERSION_NUM>`

  The version tag must match the regex defined on the Makefile (`tag_regex := ^v([0-9]{1,}\.){2}[0-9]{1,}([-_]\w+)?$`).

  >**Note**: \
  >Releases with `test` word in them are created as `draft`. \
  >Releases with `beta` word in them are created as `pre-release`.


pkgId: 87a84ca36eb7a8695c85cf1008333e69a1eaf053efd7267d423292356ef7a251
name: python-codecov-cli
arch: src
version: 9.0.4
epoch: 0
release: 1
summary: Codecov Command Line Interface
url: https://pypi.org/project/codecov-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codecov-cli-9.0.4-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/codecov/codecov-cli/branch/master/graph/badge.svg?token=jN0CICuA6Z)](https://codecov.io/gh/codecov/codecov-cli)
  [![Build-Test-Upload](https://github.com/codecov/codecov-cli/actions/workflows/push_flow.yml/badge.svg)](https://github.com/codecov/codecov-cli/actions/workflows/push_flow.yml)

  CodecovCLI is a new way for users to interact with Codecov directly from the user’s terminal or CI platform. Many Codecov features that require the user’s interference can be done via the codecovCLI. It saves commits, creates reports, uploads coverage and has many more features.

  - [CodecovCLI](#codecovcli)
  - [Installing](#installing)
    - [Using PIP](#using-pip)
    - [As a Binary](#as-a-binary)
      - [Integrity Checking the Binary](#integrity-checking-the-binary)
  - [How to Upload to Codecov](#how-to-upload-to-codecov)
    - [How to Get an Upload Token](#how-to-get-an-upload-token)
  - [Usage](#usage)
  - [Codecov-cli Commands](#codecov-cli-commands)
    - [create-commit](#create-commit)
    - [create-report](#create-report)
    - [do-upload](#do-upload)
    - [create-report-results](#create-report-results)
    - [get-report-results](#get-report-results)
    - [pr-base-picking](#pr-base-picking)
    - [send-notifications](#send-notifications)
    - [empty-upload](#empty-upload)
  - [How to Use Local Upload](#how-to-use-local-upload)
  - [Work in Progress Features](#work-in-progress-features)
    - [Plugin System](#plugin-system)
    - [Static Analysis](#static-analysis)
  - [Contributions](#contributions)
    - [Requirements](#requirements)
    - [Guidelines](#guidelines)
    - [Dependencies](#dependencies)
  - [Releases](#releases)




  To use codecov-cli in your local machine, or your CI workflows, you need to install it:

  `pip install codecov-cli`

  The above command will download the latest version of Codecov-cli. If you wish to use a specific version, releases can be viewed [here](https://pypi.org/project/codecov-cli/#history).

  Note: If you're installing in a `pyenv` environment, you may need to call `pyenv rehash` before the CLI will work.


  If you would like to use the CLI in an environment that does not have access to Python / PIP, you can install the CLI as a compiled binary. Linux and macOS releases can be found [here](https://cli.codecov.io/), along with SHASUMs and signatures for each released version. Binary releases are also available via [Github releases](https://github.com/codecov/codecov-cli/releases) on this repository.

  You can retrieve the Binary for Linux directly from your command line as follows:

  ```
  curl -Os https://cli.codecov.io/latest/linux/codecov
  sudo chmod +x codecov
  ./codecov --help
  ```



  The binary can be integrity checked using a SHASUM256 and SHASUM256.sig file. The process for macos and Linux is identical. Linux is as follows:

  ```
  curl https://keybase.io/codecovsecurity/pgp_keys.asc | gpg --no-default-keyring --keyring trustedkeys.gpg --import # One-time step
  curl -Os https://cli.codecov.io/latest/linux/codecov
  curl -Os https://cli.codecov.io/latest/linux/codecov.SHA256SUM
  curl -Os https://cli.codecov.io/latest/linux/codecov.SHA256SUM.sig

  gpgv codecov.SHA256SUM.sig codecov.SHA256SUM

  shasum -a 256 -c codecov.SHA256SUM
  ```

  For macos you will want to use the macos distributions of the binary (e.g., https://cli.codecov.io/latest/macos/codecov)



  If desired, the CLI can be used as a replacement for our [NodeJS Binary Uploader](https://github.com/codecov/uploader). To use the CLI to upload from your CI workflow, you need to add these commands:

  ```
  pip install codecov-cli
  codecovcli create-commit
  codecovcli create-report
  codecovcli do-upload
  ```
  OR
  ```
  pip install codecov-cli
  codecovcli upload-process
  ```
  codecovcli upload-process is a wrapper for create-commit, create-report and do-upload.

  You can customize the commands with the options aligned with each command.

  Note that these commands will automatically search your environment for a `$CODECOV_TOKEN` environment variable and use it if found. If you do not have a repository upload token, or global upload token, stored as an environment variable, you will need to pass it into **each command manually**, like so: `-t {$CODECOV_TOKEN}`.


  The following tokens are suitable for uploading:

  * The [Repository Upload Token](https://docs.codecov.com/docs/codecov-uploader#upload-token): Found on the settings page of your repository, also viewable on the `/new` page when setting up a repository on Codecov for the first time.
  * The [Global Upload Token](https://docs.codecov.com/docs/codecov-uploader#organization-upload-token): Found on your organization settings page (e.g., `https://app.codecov.io/account/<scm>/<org>/org-upload-token`).



  If the installation is successful, running `codecovcli --help` will output the available commands along with the different general options that can be used with them.
  ```
  Usage: codecovcli [OPTIONS] COMMAND [ARGS]...
  ```
  Codecov-cli supports user input. These inputs, along with their descriptions and usage contexts, are listed in the table below:

  | Input  | Description | Usage |
  | :---:     |     :---:   |    :---:   |
  | `--auto-load-params-from`  | The CI/CD platform   | Optional |
  | `--codecov-yml-path` | The path for your codecov.yml  | Optional
  | `--enterprise-url` | Change the upload host (Enterprise use) | Optional
  | `--version` | Codecov-cli's version | Optional
  | `--verbose` or `-v` | Run the cli with verbose logging | Optional


  | Command  | Description |
  | :---:     |     :---:   |
  | `create-commit` | Saves the commit's metadata in codecov, it's only necessary to run this once per commit
  | `create-report` | Creates an empty report in codecov with initial data e.g. report name, report's commit
  | `do-upload` | Searches for and uploads coverage data to codecov
  | `create-report-results` | Used for local upload. It tells codecov that you finished local uploading and want it to calculate the results for you to get them locally.
  | `get-report-results` | Used for local upload. It asks codecov to provide you the report results you calculated with the previous command.
  | `pr-base-picking` | Tells codecov that you want to explicitly define a base for your PR
  | `upload-process` | A wrapper for 3 commands. Create-commit, create-report and do-upload. You can use this command to upload to codecov instead of using the previosly mentioned commands.
  | `send-notifications` | A command that tells Codecov that you finished uploading and you want to be sent notifications. To disable automatically sent notifications please consider adding manual_trigger to your codecov.yml, so it will look like codecov: notify: manual_trigger: true.
  >**Note**: Every command has its own different options that will be mentioned later in this doc. Codecov will try to load these options from your CI environment variables, if not, it will try to load them from git, if not found, you may need to add them manually.




  `codecovcli create-commit [Options]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  | -C, --sha, --commit-sha | Commit SHA (with 40 chars) | Required
  |--parent-sha | SHA (with 40 chars) of what should be the parent of this commit | Optional
  |-P, --pr, --pull-request-number| Specify the pull request number manually. Used to override pre-existing CI environment variables | Optional
  |-B, --branch | Branch to which this commit belongs to | Optional
  |-r, --slug | owner/repo slug used instead of the private repo token in Self-hosted | Required
  |-t, --token | Codecov upload token | Required
  |--git-service | Git Provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Required
  |-h, --help | Shows usage, and command options



  `codecovcli create-report [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  | -C, --sha, --commit-sha | Commit SHA (with 40 chars) | Required
  |-r, --slug | owner/repo slug used instead of the private repo token in Self-hosted | Required
  |-t, --token | Codecov upload token | Required
  |--git-service | Git Provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Required
  |--code| The code of the report. This is used in local uploading to isolate local reports from regular or cloud reports uploaded to codecov so they don't get merged. It's basically a name you give to your report e.g. local-report. | Optional
  |-h, --help | Shows usage, and command options


  `codecovcli do-upload [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  |-C, --sha, --commit-sha|    Commit SHA (with 40 chars) | Required
  |--report-code | The code of the report defined when creating the report. If unsure, leave default | Optional
  |--network-root-folder |      Root folder from which to consider paths on the network section  default: (Current working directory) | Optional
  |-s, --dir, --coverage-files-search-root-folder | Folder where to search for coverage files default: (Current Working Directory) | Optional
  |--exclude, --coverage-files-search-exclude-folder | Folders to exclude from search | Optional
  |-f, --file, --coverage-files-search-direct-file | Explicit files to upload | Optional
  |--disable-search | Disable search for coverage files. This is helpful when specifying what files you want to upload with the --file option.| Optional
  |-b, --build, --build-code | Specify the build number manually | Optional
  |--build-url | The URL of the build where this is running | Optional
  |--job-code | The job code for the CI run | Optional
  |-t, --token | Codecov upload token | Required
  |-n, --name | Custom defined name of the upload. Visible in Codecov UI | Optional
  |-B, --branch | Branch to which this commit belongs to | Optional
  |-r, --slug | owner/repo slug | Required
  |-P, --pr, --pull-request-number | Specify the pull request number manually. Used to override pre-existing CI environment variables | Optional
  |-e, --env, --env-var | Specify environment variables to be included with this build. | Optional
  |-F, --flag | Flag the upload to group coverage metrics. Multiple flags allowed. | Optional
  |--plugin | plugins to run. Options: xcode, gcov, pycoverage. The default behavior runs them all. | Optional
  |-Z, --fail-on-error | Exit with non-zero code in case of error uploading.|Optional
  |-d, --dry-run | Don't upload files to Codecov | Optional
  |--legacy, --use-legacy-uploader | Use the legacy upload endpoint | Optional
  |--git-service | Git Provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Required
  |-h, --help | Shows usage, and command options


  `codecovcli create-report-results [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  |--commit-sha | Commit SHA (with 40 chars) | Required
  |--code | The code of the report. If unsure, leave default | Required
  |--slug | owner/repo slug | Required
  |--git-service | Git provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  |-t, --token | Codecov upload token | Required
  |-h, --help | Shows usage, and command options


  `codecovcli get-report-results [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  |--commit-sha | Commit SHA (with 40 chars) | Required
  |--code | The code of the report. If unsure, leave default | Required
  |--slug | owner/repo slug | Required
  |--git-service | Git provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  |-t, --token | Codecov upload token | Required
  |-h, --help | Shows usage, and command options


  `codecovcli pr-base-picking [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  |--base-sha | Base commit SHA (with 40 chars) | Required
  |--pr  | Pull Request id to associate commit with | Required
  |--slug | owner/repo slug | Required
  |-t, --token| Codecov upload token | Required
  |--service | Git provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  |-h, --help | Shows usage, and command options


  `codecovcli send-notifications [OPTIONS]`

  | Option  | Description | Usage
  | :---:     |     :---:   |    :---:   |
  | -C, --sha, --commit-sha TEXT    |Commit SHA (with 40 chars) | Required
  | -r, --slug TEXT                 |owner/repo slug used instead of the private repo token in Self-hosted | Required
  | -t, --token TEXT                |Codecov upload token | Required
  | --git-service | Git provider. Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional
  | -h,--help                      |Show this message and exit.



  Used if the changes made don't need testing, but PRs require a passing codecov status to be merged.
  This command will scan the files in the commit and send passing status checks configured if all the changed files
  are ignored by codecov (including README and configuration files)

  `Usage: codecovcli empty-upload [OPTIONS]`

  |           Options            |                                        Description                                         |  usage   |
  | :--------------------------: | :----------------------------------------------------------------------------------------: | :------: |
  | -C, --sha, --commit-sha TEXT |                                 Commit SHA (with 40 chars)                                 | Required |
  |       -t, --token TEXT       |                                    Codecov upload token                                    | Required |
  |       -r, --slug TEXT        |           owner/repo slug used instead of the private repo token in Self-hosted            | Optional |
  |           --force            |                   Always emit passing checks regardless of changed files                   | Optional |
  |     -Z, --fail-on-error      |                          Exit with non-zero code in case of error                          | Optional |
  |        --git-service         | Options: github, gitlab, bitbucket, github_enterprise, gitlab_enterprise, bitbucket_server | Optional |
  |          -h, --help          |                                Show this message and exit.                                 | Optional |



  The CLI also supports "dry run" local uploading. This is useful if you prefer to see Codecov status checks and coverage reporting locally, in your terminal, as opposed to opening a PR and waiting for your full CI to run. Local uploads do not interfere with regular uploads made from your CI for any given commit / Pull Request.

  Local Upload is accomplished as follows:

  ```
  pip install codecov-cli
  codecovcli create-commit
  codecovcli create-report --code <CODE>
  codecovcli do-upload --report-code <CODE>
  codecovcli create-report-results --code <CODE>
  codecovcli get-report-results --code <CODE>
  ```

  Codecov will calculate the coverage results, and return them in your terminal, telling you whether your PR will fail or pass the coverage check.

  Note: In order for Local Upload to work, it must be used against a commit on the origin repository. Local Upload does not work for arbitrary diffs or uncommitted changes on your local machine.



  The following features are somewhat implemented in code, but are not yet meant for use. These features will be documented once they are fully implemented in the CLI.



  To provide extensibility to some of its commands, the CLI makes use of a plugin system. For most cases, the default commands are sufficient. But in some cases, having some custom logic specific to your use case can be beneficial. Note that full documentation of the plugin system is pending, as the feature is still heavily a work in progress.



  The CLI can perform basic static analysis on Python code today. This static analysis is meant to power more future looking Codecov features and, as such, is not required or in active use today. As more functionality dependent on static analysis becomes available for use, we will document static analysis in detail here.



  This repository, like all of Codecov's repositories, strives to follow our general [Contributing guidlines](https://github.com/codecov/contributing). If you're considering making a contribution to this repository, we encourage review of our Contributing guidelines first.



  Most of this package is a very conventional Python package. The main difference is the static the CLI's analysis module uses both git submodules and C code

  Before installing, one should pull the submodules with:

  ```
  git submodule update --init
  ```
  Then, install dependencies with
  ```
  pip install -r requirements.txt
  python setup.py develop
  ```

  The C code shouldn't require any additional setup to get running, but depending on your environment, you may be prompted to install compilers and supporting tools. If errors are generated during installation, it is likely due to missing dependencies / tools required of the C code. In many cases, resulting error messages should be clear enough to determine what is missing and how to install it, but common errors will be collected here as they are encountered.



  There are a few guidelines when developing in this system. Some notable folders:

  1. `commands` - It's the folder that interacts with the caller. This is where the commands themselves should reside. These commands are not meant to do heavy lifting. They only do wiring, which is mostly parsing the input parameters.
  2. `services` - It's where the heavy logic resides. It's mostly organized by which command needs them. Commands should generally be thin wrappers around these services.
  3. `helpers` - This is meant for logic that is useful across different commands. For example, logging helpers, or the logic that searches folders.



  If external dependencies need to be added, it's important to check whether those dependencies have wheels available on PyPI with the `any` or `universal2` platform tags. If those dependencies don't have those wheels available, then they will need to built during the CI, so they will have to be added to the list of
  dependencies in the `--no-binary` flag when building the requirements for the macos release in `build_assets.yml`.



  The standard way to making a new release is the following:
  1)  Open a PR that increases the version number in setup.py. As a rule of thumb, just add one to the micro/patch version (e.g., v0.1.6 -> v0.1.7).

  2) Get the up-to-date master branch locally and run the `tag.release` command from the Makefile.

  `$ make tag.release version=v<VERSION_NUM>`

  The version tag must match the regex defined on the Makefile (`tag_regex := ^v([0-9]{1,}\.){2}[0-9]{1,}([-_]\w+)?$`).

  >**Note**: \
  >Releases with `test` word in them are created as `draft`. \
  >Releases with `beta` word in them are created as `pre-release`.


pkgId: dcf81c309b95ff212fb5c48f8d0ddeb63541466547d156e702b95b6bfffadf94
name: python-coded
arch: src
version: 1.132
epoch: 0
release: 1
url: https://pypi.org/project/coded/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coded-1.132-1.src.rpm
checksum_type: sha256
summary:
  Coded is a programming language and Python extension designed to make programming just a little bit easier

description:
  With Coded, you can easily build projects - no matter how complex.
  Our libraries allow you to create whatever you can imagine, with just a few lines of code.



  <!--

  ``` python
  write(*text, seperator="", end="", flush=True)
  ```

  ``` python
  writeline(*text, seperator="", flush=True)
  ```

  ``` python
  prompt()
  ```

  ``` python
  clear()
  ```

  ``` python
  rand()
  ```

  ``` python
  readf(path)
  ```

  ``` python
  writef(path, content)
  ```

  ``` python
  appendf(path, content)
  ```

  ``` python
  rm(path)
  ```

  ``` python
  rmdir(path)
  ```

  ``` python
  syscmd(cmd)
  ```

  ``` python
  delay()
  ```

  ``` python
  request_get()
  ```

  ``` python
  request_get_cookies()
  ```

  ``` python
  request_post()
  ```

  ``` python
  request_post_content()
  ```

  ``` python
  request_post_cookies()
  ```

  ``` python
  getenv()
  ```

  ``` python
  setenv()
  ```

  ``` python
  get_working_dir()
  ```

  ``` python
  hash_sha512()
  ```

  ``` python
  hash_sha256()
  ```

  ``` python
  hash_sha384()
  ```

  ``` python
  hash_sha224()
  ```

  ``` python
  hash_sha1()
  ```

  ``` python
  hash_md5()
  ```

  ``` python
  USERNAME
  ```

  ``` python
  PID
  ```

  ``` python
  UID
  ```

  ``` python
  OS_TYPE
  ```

  ``` python
  true
  ```

  ``` python
  false
  ```

  ``` python
  envs
  ```

  ``` python
  pypath
  ```

  ``` python
  Colour
  ```

  ``` python
  Colour() *(constructor)*
  ```

  ``` python
  Colour.RED
  ```

  ``` python
  Colour.GREEN
  ```

  ``` python
  Colour.BLUE
  ```

  ``` python
  Colour.YELLOW
  ```

  ``` python
  Colour.CYAN
  ```

  ``` python
  Colour.MAGENTA
  ```

  ``` python
  Colour.hex_to_rgb()
  ```

  ``` python
  Colour.rgb_to_hex
  ```

  ``` python
  *Colour.__str__()*
  ```

  ``` python
  *Colour.__eq__()*
  ```

  ``` python
  Ansi
  ```

  ``` python
  Ansi.RESET
  ```

  ``` python
  Ansi.FBLACK
  ```

  ``` python
  Ansi.BBLACK
  ```

  ``` python
  Ansi.RESET
  ```

  ``` python
  Ansi.FBLACK
  ```

  ``` python
  Ansi.BBLACK
  ```

  ``` python
  Ansi.FRED
  ```

  ``` python
  Ansi.BRED
  ```

  ``` python
  Ansi.FGREEN
  ```

  ``` python
  Ansi.BGREEN
  ```

  ``` python
  Ansi.FBLUE
  ```

  ``` python
  Ansi.BBLUE
  ```

  ``` python
  Ansi.FYELLOW
  ```

  ``` python
  Ansi.BYELLOW
  ```

  ``` python
  Ansi.FCYAN
  ```

  ``` python
  Ansi.BCYAN
  ```

  ``` python
  Ansi.FMAGENTA
  ```

  ``` python
  Ansi.BMAGENTA
  ```

  ``` python
  Ansi.FWHITE
  ```

  ``` python
  Ansi.BWHITE
  ```

  ``` python
  Ansi.FLBLACK
  ```

  ``` python
  Ansi.BLBLACK
  ```

  ``` python
  Ansi.FLRED
  ```

  ``` python
  Ansi.BLRED
  ```

  ``` python
  Ansi.FLGREEN
  ```

  ``` python
  Ansi.BLGREEN
  ```

  ``` python
  Ansi.FLBLUE
  ```

  ``` python
  Ansi.BLBLUE
  ```

  ``` python
  Ansi.FLYELLOW
  ```

  ``` python
  Ansi.BLYELLOW
  ```

  ``` python
  Ansi.FLCYAN
  ```

  ``` python
  Ansi.BLCYAN
  ```

  ``` python
  Ansi.FLMAGENTA
  ```

  ``` python
  Ansi.BLMAGENTA
  ```

  ``` python
  Ansi.FLWHITE
  ```

  ``` python
  Ansi.BLWHITE
  ```

  ``` python
  Window
  ```

  ``` python
  Window *(constructor)*
  ```

  ``` python
  Window.run()
  ```

  ``` python
  Window.quit_window()
  ```

  ``` python
  Window.event()
  ```

  ``` python
  Window.keydown()
  ```

  ``` python
  Window.keyup()
  ```

  ``` python
  Window.mousedown()
  ```

  ``` python
  Window.mouseup()
  ```

  ``` python
  Window.mousex()
  ```

  ``` python
  Window.mousey()
  ```

  ``` python
  Window.mousepos()
  ```

  ``` python
  Window.keys_pressed()
  ```

  ``` python
  Window.key_is_down()
  ```

  ``` python
  Time
  ```

  ``` python
  Time() *(constructor)*
  ```

  ``` python
  Time.convert_time()
  ```

  ``` python
  Time.get_real_time()
  ```

  -->

  [View the full documentation](https://github.com/dylanopen/coded.py)



  * write()
  * writeline()
  * prompt()
  * clear()
  * rand()
  * readf()
  * writef()
  * rm()
  * rmdir()
  * syscmd()
  * delay()
  * request_get()
  * request_get_cookies()
  * request_post()
  * request_post_content()
  * request_post_cookies()
  * getenv()
  * setenv()
  * get_working_dir()
  * hash_sha512()
  * hash_sha256()
  * hash_sha384()
  * hash_sha224()
  * hash_sha1()
  * hash_md5()
  * USERNAME *(property)*
  * PID *(property)*
  * UID *(property)*
  * OS_TYPE *(property)*
  * true *(property)*
  * false *(property)*
  * envs *(property)*
  * pypath *(property)*
  * Colour *(class)*
  * Colour() *(constructor)*
  * Colour.RED *(property)*
  * Colour.GREEN *(property)*
  * Colour.BLUE *(property)*
  * Colour.YELLOW *(property)*
  * Colour.CYAN *(property)*
  * Colour.MAGENTA *(property)*
  * Colour.hex_to_rgb()
  * Colour.rgb_to_hex
  * *Colour.__str__()*
  * *Colour.__eq__()*
  * Ansi *(class)*
  * Ansi.RESET *(property)*
  * Ansi.FBLACK *(property)*
  * Ansi.BBLACK *(property)*
  * Ansi.RESET *(property)*
  * Ansi.FBLACK *(property)*
  * Ansi.BBLACK *(property)*
  * Ansi.FRED *(property)*
  * Ansi.BRED *(property)*
  * Ansi.FGREEN *(property)*
  * Ansi.BGREEN *(property)*
  * Ansi.FBLUE *(property)*
  * Ansi.BBLUE *(property)*
  * Ansi.FYELLOW *(property)*
  * Ansi.BYELLOW *(property)*
  * Ansi.FCYAN *(property)*
  * Ansi.BCYAN *(property)*
  * Ansi.FMAGENTA *(property)*
  * Ansi.BMAGENTA *(property)*
  * Ansi.FWHITE *(property)*
  * Ansi.BWHITE *(property)*
  * Ansi.FLBLACK *(property)*
  * Ansi.BLBLACK *(property)*
  * Ansi.FLRED *(property)*
  * Ansi.BLRED *(property)*
  * Ansi.FLGREEN *(property)*
  * Ansi.BLGREEN *(property)*
  * Ansi.FLBLUE *(property)*
  * Ansi.BLBLUE *(property)*
  * Ansi.FLYELLOW *(property)*
  * Ansi.BLYELLOW *(property)*
  * Ansi.FLCYAN *(property)*
  * Ansi.BLCYAN *(property)*
  * Ansi.FLMAGENTA *(property)*
  * Ansi.BLMAGENTA *(property)*
  * Ansi.FLWHITE *(property)*
  * Ansi.BLWHITE *(property)*
  * Window *(class)*
  * Window *(constructor)*
  * Window.run()
  * Window.quit_window()
  * Window.event()
  * Window.keydown()
  * Window.keyup()
  * Window.mousedown()
  * Window.mouseup()
  * Window.mousex()
  * Window.mousey()
  * Window.mousepos()
  * Window.keys_pressed()
  * Window.key_is_down()
  * Time *(class)*
  * Time() *(constructor)*
  * Time.convert_time()
  * Time.get_real_time()

  And MANY more!



  1.1:

  * Created basic project structure
  * Created Coded
  * Added `write`

  1.2:

  * Added `writeline`

  1.3:

  * Added `prompt`
  * Reconfigured program structure
  * Removed submodules (e.g. `console.write` is now just `write`)
  * Added changelog
  * Added project description
  * Added documentation link
  * Fixed `writeline` tuple bug

  1.4:

  * Use `os` module
  * Added `clear`
  * Added [current features](#current-features) view.

  1.5:

  * Added function documentation inline
  * Handles exceptions in `prompt`

  All newer minor versions:

  * Bug fixes
  * New features

  [View full changelog](https://github.com/dylanopen/coded.py)


pkgId: 841af84aa0514489b0bda66aabf2a19a543f958abadf58ab4cbaac6f72a18f71
name: python-codefind
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Find code objects and their referents
url: https://github.com/breuleux/codefind
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codefind-0.1.7-1.src.rpm
checksum_type: sha256
description:
  * Find code objects from filename and qualname
  * Find all functions that have a certain code
  * Change the code of functions
  * Used by [jurigged](https://github.com/breuleux/jurigged)




  ```python
  from codefind import find_code

  def f(x):
      return x + x

  def adder(x):
      def f(y):
          return x + y

      return f

  add1 = adder(1)

  assert find_code("f" filename=__file__) is f.__code__


  assert find_code("adder", "f", filename=__file__) is add1.__code__


  assert find_code("adder", "f", module=__module__) is add1.__code__
  ```




  ```python
  from codefind import get_functions

  def f(x):
      return x + x

  def adder(x):
      def f(y):
          return x + y

      return f

  add1 = adder(1)
  add2 = adder(2)
  add3 = adder(3)

  assert get_functions(f.__code__) == [f]


  assert set(get_functions(add1.__code__)) == {add1, add2, add3}
  ```





  ```python
  from codefind import conform

  def f(x):
      return x + x

  def g(x):
      return x * x

  print(f(5))  # 10
  conform(f, g)
  print(f(5))  # 25
  ```




  ```python
  def adder(x):
      def f(y):
          return x + y

      return f

  def muller(x):
      def f(y):
          return x * y

      return f

  add1 = adder(1)
  add2 = adder(2)
  add3 = adder(3)

  print(add1(5))  # 6
  print(add2(5))  # 7
  print(add3(5))  # 8

  conform(add1.__code__, muller(0).__code__)

  print(add1(5))  # 5
  print(add2(5))  # 10
  print(add3(5))  # 15
  ```


pkgId: 046b7e2fda87ff3839e4525b7e33eb9af413a86010ec2d6f0b05a9aa9f864966
name: python-codeflare-sdk
arch: src
version: 0.21.1
epoch: 0
release: 1
summary: Python SDK for codeflare client
url: https://github.com/project-codeflare/codeflare-sdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeflare-sdk-0.21.1-1.src.rpm
checksum_type: sha256
description:
  [![Python application](https://github.com/project-codeflare/codeflare-sdk/actions/workflows/unit-tests.yml/badge.svg?branch=main)](https://github.com/project-codeflare/codeflare-sdk/actions/workflows/unit-tests.yml)
  ![coverage badge](./coverage.svg)

  An intuitive, easy-to-use python interface for batch resource requesting, access, job submission, and observation. Simplifying the developer's life while enabling access to high-performance compute resources, either in the cloud or on-prem.

  For guided demos and basics walkthroughs, check out the following links:

  - Guided demo notebooks available [here](https://github.com/project-codeflare/codeflare-sdk/tree/main/demo-notebooks/guided-demos), and copies of the notebooks with [expected output](https://github.com/project-codeflare/codeflare-sdk/tree/main/demo-notebooks/guided-demos/notebook-ex-outputs) also available
  - these demos can be copied into your current working directory when using the `codeflare-sdk` by using the `codeflare_sdk.copy_demo_nbs()` function
  - Additionally, we have a [video walkthrough](https://www.youtube.com/watch?v=U76iIfd9EmE) of these basic demos from June, 2023

  Full documentation can be found [here](https://project-codeflare.github.io/codeflare-sdk/detailed-documentation)



  Can be installed via `pip`: `pip install codeflare-sdk`



  Please see our [CONTRIBUTING.md](./CONTRIBUTING.md) for detailed instructions.





  It is possible to use the Release Github workflow to do the release. This is generally the process we follow for releases



  The following instructions apply when doing release manually. This may be required in instances where the automation is failing.

  - Check and update the version in "pyproject.toml" file.
  - Generate new documentation.
  `pdoc --html -o docs src/codeflare_sdk && pushd docs && rm -rf cluster job utils && mv codeflare_sdk/* . && rm -rf codeflare_sdk && popd && find docs -type f -name "*.html" -exec bash -c "echo '' >> {}" \;` (it is possible to install **pdoc** using the following command `poetry install --with docs`)
  - Commit all the changes to the repository.
  - Create Github release (<https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository#creating-a-release>).
  - Build the Python package. `poetry build`
  - If not present already, add the API token to Poetry.
  `poetry config pypi-token.pypi API_TOKEN`
  - Publish the Python package. `poetry publish`
  - Change directory to custom-nb-image. `cd custom-nb-image`
  - Set tag `export tag=TAG`
  - Build the container image. `podman build --build-arg SDK_VERSION=<version> -t quay.io/project-codeflare/notebook:${tag} .`
  - Login to quay.io. `podman login quay.io`
  - Push the image. `podman push quay.io/project-codeflare/notebook:${tag}`
  - Push the stable image tag `podman push quay.io/project-codeflare/notebook:${tag} quay.io/project-codeflare/notebook:stable`


pkgId: 08ed7a43d432f286e3c6d903b7748cccb4a949d20b0e7f3b2d6138f7bc4c3103
name: python-codeflare-sdk
arch: src
version: 0.22.0
epoch: 0
release: 1
summary: Python SDK for codeflare client
url: https://github.com/project-codeflare/codeflare-sdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeflare-sdk-0.22.0-1.src.rpm
checksum_type: sha256
description:
  [![Python application](https://github.com/project-codeflare/codeflare-sdk/actions/workflows/unit-tests.yml/badge.svg?branch=main)](https://github.com/project-codeflare/codeflare-sdk/actions/workflows/unit-tests.yml)
  ![coverage badge](./coverage.svg)

  An intuitive, easy-to-use python interface for batch resource requesting, access, job submission, and observation. Simplifying the developer's life while enabling access to high-performance compute resources, either in the cloud or on-prem.

  For guided demos and basics walkthroughs, check out the following links:

  - Guided demo notebooks available [here](https://github.com/project-codeflare/codeflare-sdk/tree/main/demo-notebooks/guided-demos), and copies of the notebooks with [expected output](https://github.com/project-codeflare/codeflare-sdk/tree/main/demo-notebooks/guided-demos/notebook-ex-outputs) also available
  - these demos can be copied into your current working directory when using the `codeflare-sdk` by using the `codeflare_sdk.copy_demo_nbs()` function
  - Additionally, we have a [video walkthrough](https://www.youtube.com/watch?v=U76iIfd9EmE) of these basic demos from June, 2023

  Full documentation can be found [here](https://project-codeflare.github.io/codeflare-sdk/index.html)



  Can be installed via `pip`: `pip install codeflare-sdk`



  Please see our [CONTRIBUTING.md](./CONTRIBUTING.md) for detailed instructions.





  It is possible to use the Release Github workflow to do the release. This is generally the process we follow for releases



  The following instructions apply when doing release manually. This may be required in instances where the automation is failing.

  - Check and update the version in "pyproject.toml" file.
  - Commit all the changes to the repository.
  - Create Github release (<https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository#creating-a-release>).
  - Build the Python package. `poetry build`
  - If not present already, add the API token to Poetry.
  `poetry config pypi-token.pypi API_TOKEN`
  - Publish the Python package. `poetry publish`
  - Trigger the [Publish Documentation](https://github.com/project-codeflare/codeflare-sdk/actions/workflows/publish-documentation.yaml) workflow


pkgId: 7e9dceb4997f7592af3d672827b923c3083a09831edfde4d056f4e400f5d245b
name: python-codeforlife-portal
arch: src
version: 7.4.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/codeforlife-portal/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeforlife-portal-7.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Workflow Status](https://github.com/ocadotechnology/codeforlife-portal/actions/workflows/ci.yml/badge.svg)](https://github.com/ocadotechnology/codeforlife-portal/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/ocadotechnology/codeforlife-portal/branch/master/graph/badge.svg)](https://codecov.io/gh/ocadotechnology/codeforlife-portal)


  In accordance with the [Terms of Use](https://www.codeforlife.education/terms#terms)
  of the Code for Life website, all copyright, trademarks, and other
  intellectual property rights in and relating to Code for Life (including all
  content of the Code for Life website, the Rapid Router application, the
  Kurono application, related software (including any drawn and/or animated
  avatars, whether or not such avatars have any modifications) and any other
  games, applications or any other content that we make available from time to
  time) are owned by Ocado Innovation Limited.

  The source code of the Code for Life portal, the Rapid Router application
  and the Kurono/aimmo application are [licensed under the GNU Affero General
  Public License](https://github.com/ocadotechnology/codeforlife-workspace/blob/main/LICENSE.md).
  All other assets including images, logos, sounds etc., are not covered by
  this licence and no-one may copy, modify, distribute, show in public or
  create any derivative work from these assets.



  [Code for Life](https://www.codeforlife.education/) has been developed by Ocado Technology as a **free, open-source** project to inspire the next generation of computer scientists and to help teachers deliver the computing curriculum.

  This repository hosts the source code of the [main website](https://www.codeforlife.education/), which includes the registration, log in, teacher and student dashboards, the teaching materials, etc.

  We are open to contributors from anywhere around the world. Please read ahead if you'd like to get involved.



  - [Developer Guide](https://docs.codeforlife.education/developer-guide)

  - [Good First Issues](https://github.com/ocadotechnology/codeforlife-portal/contribute)

  - [How to set up your work environment](https://docs.codeforlife.education/git/common-setup)

  - [Testing](https://docs.codeforlife.education/git/testing)


pkgId: d6e528fec12fc093577a3eedc2e78b02c63ca9ca6c2b0a322af43f1b2e49dfee
name: python-codegpt
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A CLI tool for developers using GPT-3.
url: https://github.com/morganpartee/codegpt
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codegpt-0.3.1-1.src.rpm
checksum_type: sha256
description:
  A tool for using GPT just a little quicker. A nearly truly automated footgun. Learn how to revert with git before trying please.

  Posting about progress here:

  [![Twitter Follow](https://img.shields.io/twitter/follow/_JohnPartee?style=social)](https://twitter.com/_JohnPartee)



  `pip install codegpt --upgrade`

  And set your openapi API key as an environment variable like they recommend:
  [In their docs here](https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety)

  Windows users can also use `setx` like:

  `$ setx OPENAI_SECRET_KEY=<YOUR_API_KEY>`

  from an admin console.



  One cool thing is generating documentation. GPT-3 has a token limit of 4000 for completions, so larger files will be chunked up.

  ```bash
  codegpt docs <paths>
  ```

  And it'll generate docs, one per file. This is great when you're coming into a codebase you've never seen before.



  Everything else can modify files. Have someone hold your beer and try some of these (after you check it into git):

  Usage
  To try Codegpt, you can run the following command:

  ```bash
  codegpt do <instructions (quoted)> -f readme.md
  ```

  It can do basically anything. Try handing in some files for context and telling it to generate something new - SQL queries, new features, documentation, whatever.

  Or use the quick command to do some neat stuff, like:

  Generate docs

  ```bash
  codegpt quick docs <filenames>
  ```

  Change variable names to be more readable

  ```bash
  codegpt quick varnames <filenames>
  ```

  Add comments to your code automatically

  ```bash
  codegpt quick comment <filenames>
  ```

  Check for bugs (iffy, but worth a shot)

  ```bash
  codegpt quick bugs <filenames>
  ```

  Check for vulnerabilities (even more iffy, but worth a shot)

  ```bash
  codegpt quick vulns <filenames>
  ```

  Try to make code less miserable

  ```bash
  codegpt quick ugh <filenames>
  ```

  Keep in mind that using GPT-3 for code generation is paid, with a cost of 2 cents per 1,000 tokens.

  Just like with a Jr Dev, it's best to break up your tasks into smaller pieces to improve the results.


pkgId: b3e769e4a013e7924fae42f3b77a265cbf72234fc2f669e99ac3d26fc4b2b3f0
name: python-codegrade
arch: src
version: 16.1.70
epoch: 0
release: 1
summary: A client library for accessing CodeGrade
url: https://pypi.org/project/codegrade/
rpm_license: AGPL-3.0-only OR BSD-3-Clause-Clear
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codegrade-16.1.70-1.src.rpm
checksum_type: sha256
description:
  This library makes it easier to use the CodeGrade API. Its API allows you to
  automate your usage of CodeGrade. We are currently still busy documenting the
  entire API, but everything that is possible in the UI of CodeGrade is also
  possible through the API.

  You can install the library through [pypi](https://pypi.org/), simply run
  `python3 -m pip install codegrade`. If you want to get a dev version with support
  for the latest features, simply email [support@codegrade.com](mailto:support@codegrade.com)
  and we'll provide you with a dev version.

  First, create a client:

  ```python
  import codegrade


  with codegrade.login(
      username='my-username',
      password=os.getenv('CG_PASSWORD'),
      tenant='My University',
  ) as client:
      pass


  with codegrade.login_from_cli() as client:
      pass
  ```

  Now call your endpoint and use your models:

  ```python
  from codegrade.models import PatchCourseData

  courses = client.course.get_all()
  for course in courses:
      client.course.patch(
          PatchCourseData(name=course.name + ' (NEW)'),
          course_id=course.id,
      )


  for course in courses:
      client.course.patch(
          {"name": course.name + ' (NEW)'},
          course_id=course.id,
      )
  ```

  For the complete documentation go to
  https://python.api.codegrade.com.

  CodeGrade is constantly upgrading its API, but we try to minimize backwards
  incompatible changes. We'll announce every backwards incompatible change in the
  [changelog](http://codegrade.com/changelog). A new version of the API
  client is released with every release of CodeGrade, which is approximately every
  month. To upgrade simply run `pip install --upgrade codegrade`.

  We support python 3.6 and above, `pypy` is currently not tested but should work
  just fine.

  The library is licensed under AGPL-3.0-only or BSD-3-Clause-Clear.


pkgId: 5623aa553c54516a1eefbd4f737777c574c2d977b2268be621f319f5125acfc9
name: python-codegreen-core
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: This package helps you become aware of the carbon footprint of your computation
url: https://pypi.org/project/codegreen-core/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codegreen-core-0.0.2-1.src.rpm
checksum_type: sha256
description:
  [![Run Tests](https://github.com/codegreen-framework/codegreen-core/actions/workflows/test.yml/badge.svg)](https://github.com/codegreen-framework/codegreen-core/actions/workflows/test.yml)

  This repository contains the main functionality of the codegreen project. The complete documentation including installation and usage are available on the [documentation website](https://codegreen-framework.github.io/codegreen-core/).


  - the `release` branch contains the latest stable version of the released python package
  - the `main` branch contains stable, tested code ready to be released.
  - the `dev` branch is the main working branch. All feature branches are merged to `dev`


  - Ensure new changes are merged to `dev` and the version number is bumped according to [sematic versioning](https://semver.org/).
  -  Merge `dev`to `main`. This should trigger tests.
  -  Create a git tag for the new version :
  ```
  git checkout main
  git pull
  git tag vX.Y.Z  # Replace X.Y.Z with the new version number
  git push origin vX.Y.Z
  ```
  - Create a PR from `main` to `release` and get one approval
  - Once the PR is merged, it will trigger the release of the new package version and publish the documentation.


pkgId: e8af050004bd1b6407210dc46ef23c297870e915c38e2a350601b92624a4af3e
name: python-codeguru-profiler-agent
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: The Python agent to be used for Amazon CodeGuru Profiler
url: https://github.com/aws/amazon-codeguru-profiler-python-agent
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeguru-profiler-agent-1.2.5-1.src.rpm
checksum_type: sha256
description:
  For more details, check the documentation: https://docs.aws.amazon.com/codeguru/latest/profiler-ug/what-is-codeguru-profiler.html



  This package is being released to PyPI as [codeguru-profiler-agent](https://pypi.org/project/codeguru-profiler-agent), so use it as any Python package from PyPI.

  For a demo application that uses this agent, check our [demo application](https://github.com/aws-samples/aws-codeguru-profiler-python-demo-application).



  Check the GitHub repository at [aws/amazon-codeguru-profiler-python-agent](https://github.com/aws/amazon-codeguru-profiler-python-agent).

  See [CONTRIBUTING](CONTRIBUTING.md) for details.



  See [DEVELOPMENT](DEVELOPMENT.md) for more information.



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



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


pkgId: c1cf77613e1fea55dc55857b53a0c4402ef4fd66807c02c908cf0f69d83ed700
name: python-codejail-includes
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: codejail-includes
url: https://github.com/edx/codejail-includes
rpm_license: AGPL 3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codejail-includes-1.0.0-1.src.rpm
checksum_type: sha256
description:
  |pypi-badge| |license-badge|
  CodeJail manages execution of untrusted code in secure sandboxes. It is designed primarily for Python execution,
  but can be used for other languages as well.


pkgId: e9ce47509c8fa86a8f6169dc8a2befcec72b9f514acd949ca8c7ae0d15029f55
name: python-codelimit
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/codelimit/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codelimit-0.10.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  ![Logo](docs/assets/logo.png)

  </div>

  <div align="center">

    *Your Refactoring Alarm 🔔*

  </div>

  <div align="center">

  [![main](https://github.com/getcodelimit/codelimit/actions/workflows/main.yml/badge.svg)](https://github.com/getcodelimit/codelimit/actions/workflows/main.yml)
  [![codecov](https://codecov.io/gh/getcodelimit/codelimit/branch/main/graph/badge.svg?token=ZQBEAJVC2Y)](https://codecov.io/gh/getcodelimit/codelimit)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Linting: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Checked with Code Limit](https://codelimit.vercel.app/api/badge/getcodelimit/codelimit)](https://github.com/getcodelimit/codelimit)

  </div>



  Code Limit is a tool for developers with one goal: _it tells the developer when
  it’s time to refactor_.

  Check out the [documentation](https://codelimit-docs.vercel.app) and start
  using Code Limit today to keep your code maintainable.



  Depending on your development workflow, Code Limit can run in many different
  ways (e.g.: pre-commit hook, GitHub Action, standalone, etc.). See the
  [Quickstart documentation](https://codelimit-docs.vercel.app/quickstart/) for
  examples.



  Code Limit can run as a standalone program to check and inspect a codebase, see
  the [Standalone Usage documentation](https://codelimit-docs.vercel.app/usage/)
  to get started.



  Code Limit aims to be zero-configuration. However, sometimes the exception
  proves the rule. Check out the [Configuration
  documentation](https://codelimit-docs.vercel.app/configuration/) for all
  configuration options.



  See the [Development
  documentation](https://codelimit-docs.vercel.app/development) if you want to
  extend or contribute to Code Limit.



  If you have suggestions for how Code Limit could be improved, or want to report
  a bug, [open an issue](https://github.com/getcodelimit/codelimit/issues)! All
  and any contributions are appreciated.

  To show your project uses Code Limit place this badge in the README markdown:

  [![Checked with Code Limit](https://img.shields.io/badge/Code%20Limit-checked-green.svg)](https://github.com/getcodelimit/codelimit)

  ```
  ![Checked with Code Limit](https://img.shields.io/badge/Code%20Limit-checked-green.svg)](https://github.com/getcodelimit/codelimit)
  ```



  [GPL-3.0-or-later](LICENSE) © 2022 Rob van der Leek <robvanderleek@gmail.com>
  (https://twitter.com/robvanderleek)


pkgId: 97fcc75d065c7a63fd9f72cc311ba6ffaaeab9c19e0f3c75e5376acb58f116e2
name: python-codelink
arch: src
version: 0.0.26
epoch: 0
release: 1
summary: Node-based visual programming environment
url: https://github.com/j8sr0230/codelink
rpm_license: GNU Lesser General Public License v2 or later (LGPLv2+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codelink-0.0.26-1.src.rpm
checksum_type: sha256
description:
  Codelink is a node-based visual programming environment that can be easily and flexibly integrated into
  [PySide2](https://pypi.org/project/PySide2/) applications as a widget. With Codelink, functions (so-called nodes) can
  be logically linked to each other via wires, as in flowcharts, to create directed node graphs that can be used to
  perform complex calculations or control other programs. A main application area is node-based modeling of 3D geometries
  with the parametric CAD software [FreeCAD](https://www.freecad.org/).

  ![Startup image](https://github.com/j8sr0230/codelink/raw/main/img/start_up_image.png)


  It provides:
  * customizable nodes, sockets and data types
  * framing and commenting nodes
  * sub-graphs and group nodes
  * socket options
  * validation node connections (links)
  * full undo/redo implementation
  * framework for node developer
  * easy integration in [PySide2](https://pypi.org/project/PySide2/) applications
  * made for [FreeCAD](https://www.freecad.org/)


  Binary wheels for [codelink](https://pypi.org/project/codelink/) are available on
  [PyPI](https://pypi.org/).
  ```
  pip install codelink
  ```


  After installing Codelink via [PyPI](https://pypi.org/) start your Python interpreter and run the following commands:
  ```
  >>> import codelink.path_loader
  >>> from codelink.app import main
  >>> main()
  ```

  If you want to run Codelink from within [FreeCAD](https://www.freecad.org/), execute the following commands in the
  integrated Python interpreter:
  ```
  >>> import codelink.path_loader
  >>> from codelink.app_fc import main
  >>> main()
  ```


pkgId: c285afa1312f72cb4fc110465c0d963b0e6e7bf36d8d37c12c10b4262c53043a
name: python-codelinker
arch: src
version: 0.3.27
epoch: 0
release: 1
summary: A tool to link the code with large language models.
url: https://pypi.org/project/codelinker/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codelinker-0.3.27-1.src.rpm
checksum_type: sha256
description:
  CodeLinker aims to provide functions to link your code with language models.
  It builds on top of the Pydatic library and Tool Calling abilities introduced by [OpenAI](https://platform.openai.com/docs/guides/function-calling), which enabling models to generate content according to [Json Schema](https://json-schema.org/).



  The core concept of this package is to treat language models as a function handler.
  By defining a schema for return value of the function, we can call the function and let the model generate the return value.

  To start with, we need to first define the configuration that will be used during exection:

  ```python
  config = CodeLinkerConfig(api_keys={
      "gpt-3.5-turbo-16k":[{
          "api_key": "your api key here",
          "model": "model name alias here"
      }]
  })
  cl = CodeLinker(config)
  ```

  Learn more about the configuration in the [Configuration](docs/configuration.md) page.



  Currently, the package support two types of structured generation with language models: `Function Definition` and `Return Declearation`.



  You can define the schema of the return value with pydantic package:

  ```python
  class HelloWorldSchema(BaseModel):
      message: str = Field(description="the message to be returned")
  ```

  Then we can use the `cl` object to wrap the function you want to call:

  ```python
  @cl.smartFunc()
  def hello_world() -> HelloWorldSchema:
      """Say hello to the world"""
  ```

  The function's docstring will be passed to models as instruction about what this function should do.
  Now we can call the function and let the model generate the return value:

  ```python
  result = hello_world()
  print(result.message)


  ```



  Other wise, if you do not want to define the function, you can use the `exec` method to call the function:

  ```python
  result = await cl.exec(return_type=HelloWorldSchema)
  ```

  To be noticed, the `exec` method is an async method, so you need to use `await` to call it.

  More details about structured generation can be found in the [Structured Generation](docs/structuredgen.md) page.


pkgId: e607c417f86bc7cf8887d00bce1944d1f141a7d9f4d5cae3055edb73a8b07db1
name: python-codem
arch: src
version: 0.25.6
epoch: 0
release: 1
summary: A package for co-registering geospatial data
url: https://pypi.org/project/codem/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codem-0.25.6-1.src.rpm
checksum_type: sha256
description:
  ![Registered Mesh](./docs/img/reg_mesh.png)



  `CODEM` is a testbed application for registering a 3D model of an area of interest (AOI) to a larger 3D Foundation data source. Point cloud, mesh, and raster digital surface model (DSM) data types are supported. Format support is limited to the following:

  * Point Cloud: LAS, LAZ, BPF
  * Mesh: PLY, OBJ
  * DSM: GeoTIFF

  `CODEM` follows the following basic steps to perform co-registration:

  1. Generation of normalized DSMs from the AOI and Foundation data sources.
  2. Coarse registration via matching of features extracted from the DSMs.
  3. Fine registration via an iterative closest point (ICP) algorithm.
  4. Application of the solved registration transformation to the AOI data in its original type and format.



  1. Clone the repo:

      ```console
      git clone https://github.com/NCALM-UH/CODEM
      ```

  2. Create and activate a Conda environment containing the required dependencies. From inside the `CODEM` directory:

      ```console
      conda env create --file environment.yml
      ```

      ```console
      conda activate codem
      ```

  3. Install `CODEM`. From the project directory.

      ```console
      pip install .
      ```





  The `CODEM` application has two required positional arguments and numerous options. The required positional arguments are the file path to the Foundation data file and the file path to the AOI data file. Executing codem on the command line has the following form:

  ```bash
  codem <foundation_file_path> <aoi_file_path> [-opt option_value]
  ```

  For example, running `CODEM` on some of the sample data files in the [demo](demo) directory looks like:

  ```bash
  codem demo/Foundation-PointCloud.laz demo/AOI-Mesh.ply
  ```

  Optional arguments can be placed before or after the positional arguments. For example, we can set the minimum registration pipeline resolution to a new value (default value = 1.0):

  ```bash
  codem demo/Foundation-PointCloud.laz demo/AOI-Mesh.ply --min_resolution 2.0
  ```

  A summary of all options and their default values is given in the [docs/configuration.md](docs/configuration.md) document. The default option values should be sufficient for most landscapes.




  All output is saved to a new directory that is created at the location of the AOI file. The directory name is tagged with the date and time of execution: `registration_YYYY-MM-DD_HH-MM-SS`. The directory contents include the following:

  1. Registered AOI Data File: The registered AOI file will be of the same data type and file format as the original AOI file and will have the same name with term "`_registered`" appended to end of the name.
  2. `config.yml`: A record of the parameters used in the registration.
  3. `log.txt`: A log file.
  4. `registration.txt`: Contains the solved coarse and fine registration transformation parameters and a few statistics.
  5. `dsm_feature_matches.png`: An image of the matched features used in the coarse registration step.






  In addition to the coregistration functionality, codem provides vertical change detection functionality as well based on LiDAR scans.

  ```bash
  vcd <before_file_path> <after_file_path> [-opt option_value]
  ```



  Raster, Mesh and Point cloud outputs are generated (inclyding ESRI 3D Shapefiles) to highlight ground/not-ground features, and vertical changes.




  Information on available configuration options, a more in-depth review of how `CODEM` works, and a simple example utilizing data files contained in the `demo` directory of this repository are found in the `docs` directory:

  * [docs/configuration.md](docs/configuration.md)
  * [docs/details.md](docs/details.md)
  * [docs/example.md](docs/example.md)



  * Ognyan Moore - Hobu Inc. - [Email](ogi@hobu.co)
  * Preston Hartzell - University of Houston - [Email](pjhartzell@uh.edu)
  * Jesse Shanahan - formerly of Booz Allen Hamilton (listed for software development credit attribution) - [LinkedIn](https://www.linkedin.com/in/jesseshanahan/)


pkgId: 7f694dd42d65af20039a9cb32637fad673bc065729a0cd6863fd5013f1d795fa
name: python-codemapper
arch: src
version: 3.8.0
epoch: 0
release: 1
summary: A tool to generate comprehensive Markdown artifacts of directory structures and file contents
description: If you find CodeMapper useful, don't forget to star this repository!
url: https://github.com/shaneholloman/codemapper
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemapper-3.8.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Shane Holloman  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: 36ee993d18baca1431bc6893058ea704fe95c1400a6363c0a2a977693f944698
name: python-codeme
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: CodeMe - Automatic Python Coder
url: https://pypi.org/project/codeme/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeme-0.1.9-1.src.rpm
checksum_type: sha256
description:
  ![Logo](https://raw.githubusercontent.com/neetishsingh/customItems/main/LogoMakr-3vOhNL.png)



  [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)


  CodeME is a python tool through which you can autocomplete your code just by asking it. It takes help from chatGPT to acomplish it and do changes in your existing code.



  - [@neetishsingh](https://github.com/neetishsingh/sharevia)




  Best part of CodeME is you just need two lines of code to initiate it.

  1.To install CodeME python package.
  ```bash
    pip install codeme
  ```

  2.Now start the app
  ```bash
    python -m codeme <filename with extension>
  ```
  Note: The only requirement to take benifit of this sharing framework in that you need to have python installed.







  In the working file add `#` in a new line and write your command as `#command` and save it.

  Example:  `#write a python program for adls databricks connection`

  ![alt text](https://raw.githubusercontent.com/neetishsingh/customItems/main/Capture1.PNG)

  Now in terminal in the same working directory write a command `python -m codeme <filename with its extension>`

  ![alt text](https://raw.githubusercontent.com/neetishsingh/customItems/main/Capture2.PNG)

  Aladdin will come out and will write code for you. Woah!

  ![alt text](https://raw.githubusercontent.com/neetishsingh/customItems/main/Capture3.PNG)

  There is a lot more optimization and things coming whose screenshot will be added soon

  Note: This will code for any coding language even it can write anything for you as it involved chat gpt features.





  Contributions are always welcome!

  Lets connect and discuss your ideas and scope of improvement

  Please adhere to this project's `code of conduct`.




  For support, email neetishsingh97@gmail.com or call me at +91-9643046366.


pkgId: 0a8323eda3b96c96333ea5e4d54a82bedef46fba5f70fd8937b022e0a41713a1
name: python-codemetrics-cli
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A tool for exploring code metrics of a software project (e.g. dotnet)
url: https://github.com/grigoryk/codemetrics-cli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemetrics-cli-0.1.2-1.src.rpm
checksum_type: sha256
description:
  A cli tool for exploring code metrics of a software project. Only dotnet & Windows for now.


  - make changes
  - test `cd src && py -m codemetrics_cli -p ...`
  - bump version in pyproject.toml
  - build distribution `py -m build`
  - upload new version to PyPI `py -m twine upload .\dist\codemetrics_cli-{new_version}*`
  - test new version `pip install codemetrics_cli --upgrade && codemetrics_cli -p ...`


pkgId: eb4454f5c58774dd6d8613a89a02250a3aa45ba9cd3359e8066d0c2a1590b724
name: python-codemmlu
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: CodeMMLU Evaluator: A framework for evaluating language models on CodeMMLU benchmark.
url: https://fsoft-ai4code.github.io/codemmlu/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemmlu-0.0.2-1.src.rpm
checksum_type: sha256
description:
  optional arguments:
    -h, --help            show this help message and exit
    -V, --version         Get version
    --subset SUBSET       Select evaluate subset
    --batch_size BATCH_SIZE
    --instruction_prefix INSTRUCTION_PREFIX
    --assistant_prefix ASSISTANT_PREFIX
    --output_dir OUTPUT_DIR
                          Save generation and result path
    --model_name MODEL_NAME
                          Local path or Huggingface Hub link to load model
    --peft_model PEFT_MODEL
                          Lora config
    --backend BACKEND     LLM generation backend (default: hf)
    --max_new_tokens MAX_NEW_TOKENS
                          Number of max new tokens
    --temperature TEMPERATURE
    --prompt_mode PROMPT_MODE
                          Prompt available: zeroshot, fewshot, cot_zs, cot_fs
    --cache_dir CACHE_DIR
                          Cache for save model download checkpoint and dataset
    --trust_remote_code
  ```
  </div>
  </details>
  List of supported backends:
  | Backend          	| DecoderModel 	| LoRA 	|
  |------------------	|--------------	|------	|
  | [Transformers](https://github.com/huggingface/transformers) (hf) 	| ✅            | ✅    |
  | [Vllm](https://github.com/vllm-project/vllm) (vllm)      	| ✅            | ✅    |

  To evaluate your model and submit your results to the [leaderboard](https://fsoft-ai4code.github.io/leaderboards/codemmlu/), please follow the instruction in [data/README.md](data/README.md).

  If you find this repository useful, please consider citing our paper:
  ```
  @article{nguyen2024codemmlu,
    title={CodeMMLU: A Multi-Task Benchmark for Assessing Code Understanding Capabilities},
    author={Nguyen, Dung Manh and Phan, Thang Chau and Le, Nam Hai and Doan, Thong T. and Nguyen, Nam V. and Pham, Quang and Bui, Nghi D. Q.},
    journal={arXiv preprint},
    year={2024}
  }
  ```


pkgId: 2ec9bf8bcdef3124f67cb8cc18eb63efe4f18f3851df998d69982580653ef5c5
name: python-codemod
arch: src
version: 1.0.0
epoch: 0
release: 1
url: http://github.com/facebook/codemod
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemod-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Codemod is a tool/library to assist you with large-scale codebase refactors that can be partially automated but still require human oversight and occasional intervention. Codemod was developed at Facebook and released as open source.

description:
  Codemod is a tool/library to assist you with large-scale codebase refactors that can be partially automated but still require human oversight and occasional intervention. Codemod was developed at Facebook and released as open source.


pkgId: b4dedeb044aa36bde4e4265b8397b3d6ce754a8c7566738f114f4f94e1c408cc
name: python-codemod-json
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Lib to modify json inplace
url: https://github.com/advice-animal/codemod-json/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemod-json-0.5.0-1.src.rpm
checksum_type: sha256
description:
  This library makes surgical edits to JSON documents, based on tree-sitter and
  inspired by tomlkit and pyupgrade.  Preserves _all_ whitespace and formatting
  on lines that don't require changes, and generally within a line as well, so
  you can make minimal diffs in your codemod tools.



  ```json
  {
      // some comment
      "version": ["foo"],
      "commands": [], // another comment
  }
  ```

  ```py
  from codemod_json import parse
  stream = parse(somepath.read_bytes())
  if stream["version"] == ["2.7"]:
      stream["version"][:] = ["3.6", "3.13"]
  somepath.write_bytes(stream.text)
  ```

  ```json
  {
      // some comment
      "version": ["3.6", "3.13"],
      "commands": [], // another comment
  }
  ```



  Usage of this library should work back to 3.9 (because of the tree-sitter dep),
  but development (and mypy compatibility) only on 3.10-3.12.  Linting requires
  3.12+ for full fidelity.



  This library follows [meanver](https://meanver.org/) which basically means
  [semver](https://semver.org/) along with a promise to rename when the major
  version changes.



  codemod-json is copyright [Tim Hatch](https://timhatch.com/), and licensed under
  the MIT license.  See the `LICENSE` file for details.


pkgId: 040919874532912df906ade0f7c20d5a4f1c56bc4c796dc3865ea5c61a215c4f
name: python-codemod-yaml
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Lib to modify yaml inplace
url: https://github.com/advice-animal/codemod-yaml/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemod-yaml-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This library is for making targeted edits to YAML documents.  The core design goal is:

  1. Only change lines with *data* changes.

  While you can't edit all YAML constructs, you can generally replace them and
  roundtrip them thanks to tree-sitter-yaml.

  This was roughly inspired by `pyupgrade` which combined AST-based parsing with
  more low-level edits.



  ```py
  from codemod_yaml import parse
  stream = parse(somepath.read_bytes())
  if stream["version"] == ["2.7"]:
      stream["version"][:] = ["3.6", "3.13"]
  somepath.write_bytes(stream.text)
  ```


  [x] round-tripping unedited sections verbatim
  [x] any valid yaml _after_ where you're editing
  [x] block maps with string keys
  [x] block sequences
  [x] python str/float/list/dict



  Usage of this library should work back to 3.7, but development (and mypy
  compatibility) only on 3.10-3.12.  Linting requires 3.12 for full fidelity.



  This library follows [meanver](https://meanver.org/) which basically means
  [semver](https://semver.org/) along with a promise to rename when the major
  version changes.



  codemod-yaml is copyright [Tim Hatch](https://timhatch.com/), and licensed under
  the MIT license.  See the `LICENSE` file for details.


pkgId: ec035007a19e11b1bd2d26a19793e286b4f456b7a550246fc8e06b8633bf6f9d
name: python-codemod-yaml
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Lib to modify yaml inplace
url: https://github.com/advice-animal/codemod-yaml/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemod-yaml-0.5.0-1.src.rpm
checksum_type: sha256
description:
  This library makes surgical edits to YAML documents, based on tree-sitter and
  inspired by tomlkit and pyupgrade.  Preserves _all_ whitespace and formatting
  on lines that don't require changes, and generally within a line as well, so
  you can make minimal diffs in your codemod tools.



  ```py
  from codemod_yaml import parse
  stream = parse(somepath.read_bytes())
  if stream["version"] == ["2.7"]:
      stream["version"][:] = ["3.6", "3.13"]
  somepath.write_bytes(stream.text)
  ```



  Usage of this library should work back to 3.9 (because of the tree-sitter dep),
  but development (and mypy compatibility) only on 3.10-3.12.  Linting requires
  3.12+ for full fidelity.



  This library follows [meanver](https://meanver.org/) which basically means
  [semver](https://semver.org/) along with a promise to rename when the major
  version changes.



  codemod-yaml is copyright [Tim Hatch](https://timhatch.com/), and licensed under
  the MIT license.  See the `LICENSE` file for details.


pkgId: f1eadb34de3cc6fa7425af7805ae2ad5f7f9ec4270f3025fc31c710266b8154d
name: python-codemodder
arch: src
version: 3.12.0
epoch: 0
release: 1
summary: A pluggable framework for building codemods in Python
url: https://codemodder.io
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemodder-3.12.0-1.src.rpm
checksum_type: sha256
description:
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="img/codemodder-dark.png">
    <source media="(prefers-color-scheme: light)" srcset="img/codemodder-light.png">
    <img alt="Pixee Logo" src="https://github.com/pixee/pixee-cli/raw/main/img/codemodder.png">
  </picture>



  This is the Python version of the [Codemodder Framework](https://codemodder.io/).

  Codemodder is sponsored by [pixee.ai](https://pixee.ai).



  As of [v0.80.0](https://github.com/pixee/codemodder-python/releases/tag/0.80.0) the codemod API is relatively stable. However, backwards compatibility between releases will not be guaranteed until version 1.0.0.


  See [CHANGELOG.md](CHANGELOG.md) for detailed release notes.



  The `codemodder` package is available [on PyPI](https://pypi.org/project/codemodder/). To install, run:
  ```
  $ pip install codemodder
  ```

  To install the package from source, use `pip`:

  ```
  $ pip install /path/to/codemodder-python
  ```





  Codemodder can be run as a CLI. The codemodder package provides an executable called `codemodder`. This should be available on your path by default after installation.

  For basic usage, run the `codemodder` command with a target directory path:

  ```
  $ codemodder /path/to/my-project
  ```

  Note that by default `codemodder` will make changes to files in your target directory. To run `codemodder` without making updates on disk, use the `--dry-run` flag:
  ```
  $ codemodder --dry-run /path/to/my-project
  ```

  To list all available codemods (including any that are registered with installed plugins), use the `--list` option:
  ```
  $ codemodder --list
  ```

  For a full list of options, use the `--help` flag:
  ```
  $ codemodder --help
  ```



  You can also run `codemodder` as a library by importing the module and running `run`. For basic usage, pass a target directory path and the `dry_run` argument:

  ```python
  import codemodder

  output, exit_code = codemodder.run("/path/to/my-project", dry_run=True)
  ```

  Unlike the CLI which has a default `dry_run` of `False`, when calling `codemodder` as a library you must indicate if you want `codemodder` to make changes to your files.




  Codemods are composed of the following key components:
  * Detector
  * Transformer(s)
  * Metadata

  <picture>
    <source srcset="img/base-codemod.jpg">
    <img alt="Base Codemod Diagram" src="https://github.com/pixee/pixee-cli/raw/main/img/base-codemod.jpg">
  </picture>



  The Python codemodder supports a plugin infrastructure for custom codemods. For users interested in developing a custom codemod plugin, we recommend starting with the [Cookiecutter template](https://github.com/pixee/cookiecutter-codemodder-plugin).



  Coming soon!


  See [CONTRIBUTING.md](CONTRIBUTING.md).

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


pkgId: 62090490ac62e2993320cd038da077122295a3eaf111dfd160d4fa4419728206
name: python-codemodpydanticv1
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/codemodpydanticv1/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemodpydanticv1-0.1.15-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/Peter554/codemodpydanticv1/actions/workflows/ci.yml/badge.svg)](https://github.com/Peter554/codemodpydanticv1/actions/workflows/ci.yml)

  A small codemod tool to upgrade pydantic from V1 to V2, but still use the V1 API.
  Pydantic V2 exposes the V1 API. By using the V1 API we can be sure nothing
  is being broken by the package upgrade, and usage can then gradually be migrated
  across to the V2 API.

  ```sh
  pip install codemodpydanticv1

  codemodpydanticv1 <file>
  ```

  Using [ripgrep](https://github.com/BurntSushi/ripgrep) and looping over files:

  ```sh
  for file in $(rg pydantic -g '*.py' -l); do
      echo $file
      codemodpydanticv1 $file
  done
  ```


pkgId: acc4042f9491ffedfe2015d17e81cc71372af8152da2f5703aca2f965cf8667c
name: python-codemonkeys
arch: src
version: 1.1.3
epoch: 0
release: 1
url: https://github.com/cooleydw494/codemonkeys
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codemonkeys-1.1.3-1.src.rpm
checksum_type: sha256
summary:
  CodeMonkeys gives devs control over their automated GPT logic. The current focus is working on codebases but it is lovingly designed to enable automations of all kinds. This framework aims to use AI effectively, while being reliable, predictable, and tailored to your needs. There is a strong focus on only involving AI at crucial areas of strength, and using good old-fashioned code for everything else.

description:
  CodeMonkeys gives devs control over their automated GPT logic. The current focus is working on codebases but it is lovingly designed to enable automations of all kinds. This framework aims to use AI effectively, while being reliable, predictable, and tailored to your needs. There is a strong focus on only involving AI at crucial areas of strength, and using good old-fashioned code for everything else.


pkgId: 1bf74329fc30ce04961413661834f3d9c1f23966752785677b6653252a6404ad
name: python-codenerix-lib
arch: src
version: 1.0.27
epoch: 0
release: 1
summary: Basic libraries used by CODENERIX.
url: https://github.com/codenerix/codenerix-lib
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codenerix-lib-1.0.27-1.src.rpm
checksum_type: sha256
description:
  |builds and tests| |builds_and_tests|
  Codenerix LIB is a base module of libraries used by
  `CODENERIX <https://www.codenerix.com/>`__. It is a very usefull library
  for any project and you can use it without
  `CODENERIX <https://www.codenerix.com>`__. you can visit the project at
  `GitHub Django
  CODENERIX <https://github.com/codenerix/django-codenerix>`__
     CODENERIX


pkgId: 2278ea649ff48295f34b2b7d371708cc6d11db6e57eafbfc2c2d5272f986e290
name: python-codeowners
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Codeowners parser for Python
url: https://github.com/sbdchd/codeowners
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeowners-0.7.0-1.src.rpm
checksum_type: sha256
description:
  > Python codeowners parser based on [softprops's Rust
  > library](https://crates.io/crates/codeowners) and [hmarr's Go
  > library](https://github.com/hmarr/codeowners/).



  To allow Python users to parse [codeowners
  files](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners#codeowners-syntax)
  in Python.



  ```shell
  pip install codeowners
  ```



  ```python
  from codeowners import CodeOwners

  example_file = """\

  *.js    @ghost

  *.py user@example.com

  /build/logs/ @dmin
  docs/*  docs@example.com
  """

  owners = CodeOwners(example_file)
  assert owners.of("test.js") ==  [('USERNAME', '@ghost')]
  ```



  ```shell
  poetry install

  s/test

  s/lint
  ```



  ```shell







  poetry publish --build


  ```


pkgId: 8c6d08a2c8c691143d4c87071653169bda88444498ec860f3b9915a04e907b0d
name: python-codeplot-ipython
arch: src
version: 1.15.0
epoch: 0
release: 1
url: https://github.com/codeplot-co/codeplot
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeplot-ipython-1.15.0-1.src.rpm
checksum_type: sha256
summary:
  codeplot is a canvas designed for code-driven data exploration where you can plot graphs, data frames, markdown and much more using plain Python

description:
  codeplot is a dynamic spatial canvas for data exploration, offering an interactive environment for graphing and visualizing data with Python.
  Created by [@antl3x](https://github.com/antl3x), [read more](https://antl3x.co/posts/2024-01-25-today-i-decided-to-create-a-tool-that-i-always-wanted/) about its inception.

  [![Watch the video](https://img.youtube.com/vi/nu5pY9nxXsA/maxresdefault.jpg)](https://youtu.be/nu5pY9nxXsA)
  **Why Choose codeplot?**
  - **Dynamic Visualization**: Break free from static images and rigid layouts. codeplot brings your data to life on an interactive canvas.
  - **Easy Integration**: Directly plot from your Python code or REPL into your canvas at [codeplot.co](https://codeplot.co).
  - **Varied Visualizations**: From basic charts to advanced widgets, codeplot supports a wide range of data representations.
  - **Flexible Layouts**: Arrange your visualizations to suit your workflow, with draggable and movable plots.
  - **Open to Everyone**: Designed for data scientists and enthusiasts alike, codeplot aims to enhance your data exploration experience.

  To use codeplot in a IPython Notebook like Jupyter, Google Colab, etc, you can install the IPython Extension using pip:
  ```bash
  pip install codeplot-ipython
  ```
  After install you can load the extension and connect to a new room:
  ```python
  %load_ext codeplot-ipython
  %cP_connect ws://your-ws-url/your-room-id
  ```
  Now the output of your cells will be automatically plotted in the codeplot canvas! So you don't need to use the `cP.plot` function.
  Thats all!

  If you want to use codeplot in a Python script, and have a more "fine-grained" control over the plots, you can use the Python SDK.
  To get started with codeplot, you can install the package using pip:
  ```bash
  pip install codeplot
  ```
  Once installed, you can start using codeplot by importing the package and connectig to a new room:
  ```python
  import asyncio
  import codeplot
  async def main():
      cP = await codeplot.connect("ws://your-ws-url/your-room-id")
      
      await cP.plot(df.describe())
      await cP.plot(df.head(10))
      await cP.plot(df)
  asyncio.run(main())
  ```
  You can use the public codeplot client & server to start plotting right away:
  1. Join the codeplot room at [codeplot.co](https://codeplot.co)
  2. Use the room id to connect to the room using the code above
  If you want to use codeplot in a Jupyter Notebook, you can use the following code:
  ```python
  import codeplot
  cP = await codeplot.connect("ws://your-ws-url/your-room-id")

  await cP.plot(df.describe())
  await cP.plot(df.head(10))
  await cP.plot(df)
  ```

  Instead of using the public codeplot server, you can self-host and run codeplot on your local machine using Docker. To do so, you can use the following command:
  ```bash
  curl -s https://raw.githubusercontent.com/codeplot-co/codeplot/master/minirepos/@codeplot-docker/docker-compose.yaml | docker-compose -f - up
  ```
  Or if you are using docker-compose v2, you can use the following command instead
  ```bash
  curl -s https://raw.githubusercontent.com/codeplot-co/codeplot/master/minirepos/@codeplot-docker/docker-compose.yaml | docker compose -f - up
  ```
  This will start a codeplot server and a client on your local machine, and you can access it at:
  - Client: [http://localhost:9107](http://localhost:9107)
  - Server: [ws://localhost:9108](ws://localhost:9108)
  **Join the codeplot Community**
  Become part of a forward-thinking community dedicated to advancing data visualization. Connect, engage, and grow with peers on **[Discord](https://codeplot.co/discord)**. With codeplot, data visualization is a shared journey. Let's explore new insights together!

  Codeplot is crafted to support a wide range of users, from individuals exploring their personal projects to enterprises seeking to enhance their business processes. To accommodate this diversity, Codeplot adopts a dual-license approach.
  Codeplot is free to use for personal and non-commercial purposes.
  Only pay if you use Codeplot commercially.
  Read more about [License and Pricing here](LICENSE.md).

  This project is sponsored by [LearnPolars.co](https://learnpolars.co). LearnPolars is a platform to learn data manipulation and analysis using Polars, a blazingly fast DataFrame library in Python (Rust).


pkgId: e9204373387012bd460261017ad698552d0e2d37a749b14a43e2fbb02513c74d
name: python-codepost
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Python bindings for the codePost API
url: https://github.com/codepost-io/codepost-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codepost-0.3.2-1.src.rpm
checksum_type: sha256
description:
  [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/codepost-python/community)
  [![Build Status](https://travis-ci.com/codepost-io/codePost-python.svg?branch=master)](https://travis-ci.com/codepost-io/codePost-python?branch=master)
  [![Coverage Status](https://coveralls.io/repos/github/codepost-io/codepost-python/badge.svg?branch=master)](https://coveralls.io/github/codepost-io/codepost-python?branch=master)

  This package provides a Python library to conveniently access the codePost API
  from any application or script written in the Python language.

  You can learn more about [codePost](https://codepost.io), the best tool for educational code feedback, or
  check out the documentation for powerful, best-in-class [REST API](https://docs.codepost.io/reference) that
  this Python SDK allows you to control.

  You can also dive in directly with the [codePost API Python SDK cheatsheet](https://docs.codepost.io/docs/python-sdk-cheatsheet).



  This section provides a quick overview of how to install the library and getting started, for more complete
  information, you can reference our [First Steps with the codePost API Python
  SDK](https://docs.codepost.io/docs/first-steps-with-the-codepost-python-sdk).


  1. This codePost API Python SDK is available on the Python package manager PyPi, and can be installed from all
  usual sources, such as with `pip`:
      ```shell
      sudo pipenv install codepost
      ```
      You can also install the package just for your account (`pip install --user codepost`) or using a tool such
      as `pipenv` which will install the library in a virtual environment (`pipenv install codepost`).
  2. Once you've import the `codepost` package, you need to configure it with the API key you've obtained
      from [your Settings page](https://codepost.io/settings)
      (for other means of setting the API key,
      [read here](https://docs.codepost.io/docs/first-steps-with-the-codepost-python-sdk)):
      ```python
      import codepost
      codepost.configure_api_key("ddafde24389de98434f8df3ee482389de98432afde24482f3428923491344f8df3eef34892349134")
      ```
  3. You can then directly access the codePost objects:
      ```python
      course = codepost.course.list_available(name="CS101", period="Spring 2020")[0]
      assignment = course.assignments.by_name("Hello World")
      submissions = assignment.list_submissions()
      for submission in submissions:
          print("{student},{grade}", student="+".join(submission.students), grade=submission.grade)
      ```
      to print the grades of all submissions of the assignment `"Hello World"` of the course CS101 in Spring 2020.



  The codePost API Python SDK is under active development. At this time, we are welcoming all
  issues, suggestions and feature requests. Please either [post a GitHub issue on this
  repository](https://github.com/codepost-io/codepost-python/issues), or [join our Gitter
  channel](https://gitter.im/codepost-python/community) to ask a question.




  To start developing, install [pipenv](https://github.com/pypa/pipenv), then install
  all dependencies (including development dependencies, with the flag `--dev`) for this project:

      git clone https://github.com/codepost-io/codepost-python
      cd codepost-python
      pipenv install --dev

  Run all tests on all supported versions of Python which you have locally installed:

      make test

  Run all tests for a specific Python version (modify `-e` according to your Python target):

      pipenv run tox -e py37

  Run all tests in a single file for a specific Python version:

      pipenv run tox -e py37 -- tests/util/test_misc.py


pkgId: 03e6d0c3ff83d1c5d97f193de873010d4d4e444b61d8b35df325951886a017eb
name: python-codepub
arch: src
version: 1.8
epoch: 0
release: 1
summary: CodePUB
url: https://codepub.readthedocs.io/en/latest/index.html
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codepub-1.8-1.src.rpm
checksum_type: sha256
description:
  <span style="color:white"> </span>



  | Authors     | Guanchen He, Qin Huang                                 |
  | ----------- | ------------------------------------------------------ |
  | Affiliation | Beihang University                                     |
  | ----------- | ------------------------------------------------------ |
  | Authors     | Vasilisa Kovaleva, Hannah Meyer                        |
  | ----------- | ------------------------------------------------------ |
  | Affiliation | Cold Spring Harbor Laboratory                          |
  | ----------- | ------------------------------------------------------ |
  | Authors     | Mikhail Pogorelyy, Paul Thomas                         |
  | ----------- | ------------------------------------------------------ |
  | Affiliation | St. Jude Research Hospital                             |
  | ----------- | ------------------------------------------------------ |
  | Authors     | Carl Barton                                            |
  | ----------- | ------------------------------------------------------ |
  | Affiliation | Birkbeck, University of London                         |
  | Date        | 09/02/2024                                             |


pkgId: 90b84a49bd68ca8609069817f03a53dfc9e25ddea663c967dc287af66493ea4a
name: python-codepub
arch: src
version: 2.1
epoch: 0
release: 1
summary: CodePUB
url: https://codepub.readthedocs.io/en/latest/index.html
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codepub-2.1-1.src.rpm
checksum_type: sha256
description:
  We introduce **balanced constant-weight Gray codes for detecting consecutive positives (DCP-CWGCs)** as a novel combinatorial pooling strategy. Items are assigned to pools using a sequence of binary vectors (binary addresses). Addresses have constant Hamming weight, adjacent addresses differ by a Hamming distance of 2, and their OR-sums are unique. These properties enable error detection, ensure constant testing for individual items and consecutive item pairs, and maintain stable detection by balancing the number of items per pool.


pkgId: bd8fe8de0f2e91fc19930e38f6e72eb9d8a45ef74821b56fddcbe9c50b7e8f6e
name: python-codepy
arch: src
version: 2023.1
epoch: 0
release: 1
summary: Generate and execute native code at run time.
url: http://mathema.tician.de/software/codepy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codepy-2023.1-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://gitlab.tiker.net/inducer/codepy/badges/main/pipeline.svg
      :alt: Gitlab Build Status
      :target: https://gitlab.tiker.net/inducer/codepy/commits/main
  .. image:: https://github.com/inducer/codepy/workflows/CI/badge.svg
      :alt: Github Build Status
      :target: https://github.com/inducer/codepy/actions?query=branch%3Amain+workflow%3ACI
  .. image:: https://badge.fury.io/py/codepy.svg
      :alt: Python Package Index Release Page
      :target: https://pypi.org/project/codepy/

  CodePy is a C/C++ metaprogramming toolkit for Python. It helps you compile
  source code and dynamically load it into the Python interpreter.
  This facility also works in conjunction with with `PyCuda
  <http://mathema.tician.de/software/pycuda>`_.  Dynamic compilation and linking
  are so far only supported in Linux with the GNU toolchain.

  See also the `documentation <http://documen.tician.de/codepy>`_ and the
  `git tree <http://github.com/inducer/codepy>`_.


pkgId: f41eaccd5c2150f31feec8960c16bac8471a57d5b4d7e83bd5ebdef109494c06
name: python-codeqai
arch: src
version: 0.0.18
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/codeqai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeqai-0.0.18-1.src.rpm
checksum_type: sha256
description:
  <div align="center">



  [![Build](https://github.com/fynnfluegge/codeqai/actions/workflows/build.yaml/badge.svg)](https://github.com/fynnfluegge/codeqai/actions/workflows/build.yaml)
  [![Publish](https://github.com/fynnfluegge/codeqai/actions/workflows/publish.yaml/badge.svg)](https://github.com/fynnfluegge/codeqai/actions/workflows/publish.yaml)
  [![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0)

  </div>

  <div align="center">

  Search your codebase semantically or chat with it from cli. Keep the vector database superfast up to date to the latest code changes.
  100% local support without any dataleaks.
  Built with [langchain](https://github.com/langchain-ai/langchain), [treesitter](https://github.com/tree-sitter/tree-sitter), [sentence-transformers](https://github.com/UKPLab/sentence-transformers), [instructor-embedding](https://github.com/xlang-ai/instructor-embedding),
  [faiss](https://github.com/facebookresearch/faiss), [lama.cpp](https://github.com/ggerganov/llama.cpp), [Ollama](https://github.com/jmorganca/ollama), [Streamlit](https://github.com/streamlit/streamlit).

  </div>



  - 🔎 &nbsp;Semantic code search
  - 💬 &nbsp;GPT-like chat with your codebase
  - ⚙️ &nbsp;Synchronize vector store and latest code changes with ease
  - 💻 &nbsp;100% local embeddings and llms
    - sentence-transformers, instructor-embeddings, llama.cpp, Ollama
  - 🌐 &nbsp;OpenAI, Azure OpenAI and Anthropic
  - 🌳 &nbsp;Treesitter integration

  > [!NOTE]
  > There will be better results if the code is well documented. You might consider [doc-comments-ai](https://github.com/fynnfluegge/doc-comments.ai) for code documentation generation.





  ```
  codeqai search
  ```

  <div align="center">

  <img src="https://github.com/fynnfluegge/codeqai/assets/16321871/142576f6-a2d4-41b9-a353-d82da78bc3b8" width="800">

  </div>



  ```
  codeqai chat
  ```

  <div align="center">

  <img src="https://github.com/fynnfluegge/codeqai/assets/16321871/84209b30-1940-4aa5-a9e2-03d699217adf" width="800">

  </div>



  ```
  codeqai sync
  ```



  ```
  codeqai app
  ```

  <div align="center">

    <img src="https://github.com/fynnfluegge/codeqai/assets/16321871/3a9105f1-066a-4cbd-a096-c8a7bd2068d3" width="800">

  </div>

  > [!NOTE]
  > At first usage, the repository will be indexed with the configured embeddings model which might take a while.



  - Python >=3.9,<3.12



  Install in an isolated environment with `pipx`:

  ```
  pipx install codeqai
  ```

  ⚠ Make sure pipx is using Python >=3.9,<3.12.
  To specify the Python version explicitly with pipx, activate the desired Python version (e.g. with `pyenv shell 3.X.X`) and intall with:

  ```
  pipx install codeqai --python $(which python)
  ```

  If you are still facing issues using pipx you can also install directly from source through PyPI with:

  ```
  pip install codeqai
  ```

  However, it is recommended to use pipx to benefit from isolated environments for the dependencies.
  Visit the [Troubleshooting](https://github.com/fynnfluegge/codeqai?tab=readme-ov-file#-troubleshooting) section for solutions of known issues during installation.

  > [!NOTE]
  > Some packages are not installed by default. At first usage it is asked to install `faiss-cpu` or `faiss-gpu`. Faiss-gpu is recommended if the hardware supports CUDA 7.5+.
  > If local embeddings and llms are used it will be further asked to install sentence-transformers, instructor or llama.cpp.



  At first usage or by running

  ```
  codeqai configure
  ```

  the configuration process is initiated, where the embeddings and llms can be chosen.

  > [!IMPORTANT]
  > If you want to change the embeddings model in the configuration later, delete the cached files in `~/.cache/codeqai`.
  > Afterwards the vector store files are created again with the recent configured embeddings model. This is neccessary since the similarity search does not work if the models differ.



  If remote models are used, the following environment variables are required.
  If the required environment variables are already set, they will be used, otherwise you will be prompted to enter them which are then stored in `~/.config/codeqai/.env`.



  ```bash
  export OPENAI_API_KEY = "your OpenAI api key"
  ```



  ```bash
  export OPENAI_API_TYPE = "azure"
  export AZURE_OPENAI_ENDPOINT = "https://<your-endpoint>.openai.azure.com/"
  export OPENAI_API_KEY = "your Azure OpenAI api key"
  export OPENAI_API_VERSION = "2023-05-15"
  ```



  ```bash
  export ANTHROPIC_API_KEY="your Anthropic api key"
  ```

  > [!NOTE]
  > To change the environment variables later, update the `~/.config/codeqai/.env` manually.



  - [x] Python
  - [x] Typescript
  - [x] Javascript
  - [x] Java
  - [x] Rust
  - [x] Kotlin
  - [x] Go
  - [x] C++
  - [x] C
  - [x] C#
  - [x] Ruby



  The entire git repo is parsed with treesitter to extract all methods with documentations and saved to a local FAISS vector database with either sentence-transformers, instructor-embeddings or OpenAI's text-embedding-ada-002.
  The vector database is saved to a file on your system and will be loaded later again after further usage.
  Afterwards it is possible to do semantic search on the codebase based on the embeddings model.
  To chat with the codebase locally llama.cpp or Ollama is used by specifying the desired model.
  For synchronization of recent changes in the repository, the git commit hashes of each file along with the vector Ids are saved to a cache.
  When synchronizing the vector database with the latest git state, the cached commit hashes are compared to the current git hash of each file in the repository.
  If the git commit hashes differ, the related vectors are deleted from the database and inserted again after recreating the vector embeddings.
  Using llama.cpp the specified model needs to be available on the system in advance.
  Using Ollama the Ollama container with the desired model needs to be running locally in advance on port 11434.
  Also OpenAI or Azure-OpenAI can be used for remote chat models.





  Install the `huggingface-cli` and download your desired model from the model hub.
  For example

  ```
  huggingface-cli download TheBloke/CodeLlama-13B-Python-GGUF codellama-13b-python.Q5_K_M.gguf
  ```

  will download the `codellama-13b-python.Q5_K_M` model. After the download has finished the absolute path of the model `.gguf` file is printed to the console.

  > [!IMPORTANT]
  > `llama.cpp` compatible models must be in the `.gguf` format.



  - ### During installation with `pipx`

    ```
    pip failed to build package: tiktoken

    Some possibly relevant errors from pip install:
      error: subprocess-exited-with-error
      error: can't find Rust compiler
    ```

    Make sure the rust compiler is installed on your system from [here](https://www.rust-lang.org/tools/install).

  - ### During installation of `faiss`
    ```
    × Building wheel for faiss-cpu (pyproject.toml) did not run successfully.
    │ exit code: 1
    ╰─> [12 lines of output]
        running bdist_wheel
        ...
    note: This error originates from a subprocess, and is likely not a problem with pip.
    ERROR: Failed building wheel for faiss-cpu
    Failed to build faiss-cpu
    ERROR: Could not build wheels for faiss-cpu, which is required to install pyproject.toml-based projects
    ```
    Make sure to have codeqai installed with Python <3.12. There is no faiss wheel available yet for Python 3.12.



  If you are missing a feature or facing a bug don't hesitate to open an issue or raise a PR.
  Any kind of contribution is highly appreciated!


pkgId: f010b2993f21a36a5ae37633ebdc81793fb5320b16d0c6ee9f8622941773cc93
name: python-coderadar
arch: src
version: 0.5.8
epoch: 0
release: 1
description:
  Pytest:
  Number of tests: 31 (+24)
  errors: 0 (+0)

url: https://gitlab.com/ck2go/coderadar
rpm_license: GNU GPLv3 License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coderadar-0.5.8-1.src.rpm
checksum_type: sha256
summary:
  Identifying the highest threats to your code quality by analyzing code metrics of your project using pytest and pylint.


pkgId: a1d8b155b1570065f136d5024ce311803e552186734beed1d36af46723356e54
name: python-coderedcms
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Wagtail-based CMS by CodeRed for building marketing websites.
url: https://github.com/coderedcorp/coderedcms
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coderedcms-4.0.1-1.src.rpm
checksum_type: sha256
description:
  The professional WordPress alternative for building marketing websites with
  Wagtail and Bootstrap.

  [Website](https://www.coderedcorp.com/cms/)
  |
  [Documentation](https://docs.coderedcorp.com/wagtail-crx/)
  |
  [Blog](https://www.coderedcorp.com/blog/tag/django-wagtail/)




  |                        |                      |
  |------------------------|----------------------|
  | Python Package         | [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/coderedcms)](https://pypi.org/project/coderedcms/) [![PyPI - Django Version](https://img.shields.io/pypi/djversions/coderedcms)](https://pypi.org/project/coderedcms/) [![PyPI - Wheel](https://img.shields.io/pypi/wheel/coderedcms)](https://pypi.org/project/coderedcms/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/coderedcms)](https://pypi.org/project/coderedcms/) [![PyPI](https://img.shields.io/pypi/v/coderedcms)](https://pypi.org/project/coderedcms/) |
  | Build                  | [![Build Status](https://dev.azure.com/coderedcorp/cr-github/_apis/build/status/coderedcms?branchName=main)](https://dev.azure.com/coderedcorp/coderedcms/_build/latest?definitionId=1&branchName=main) [![Azure DevOps tests (branch)](https://img.shields.io/azure-devops/tests/coderedcorp/cr-github/1/main)](https://dev.azure.com/coderedcorp/cr-github/_build/latest?definitionId=1&branchName=main) [![Azure DevOps coverage (branch)](https://img.shields.io/azure-devops/coverage/coderedcorp/cr-github/1/main)](https://dev.azure.com/coderedcorp/cr-github/_build/latest?definitionId=1&branchName=main) |




  CRX, formerly known as CodeRed CMS, provides a large set of enhancements and
  pre-built components for Wagtail which are ready to use out-of-the box! This
  saves development time and avoids "re-inventing the wheel" by providing features
  commonly needed by websites:

  * Streamfield blocks and page templates for Bootstrap 5: rows, columns, hero
    units, carousels, buttons, modals, cards, and more!

  * Settings for adding logo, navigation, footer, and other common elements.

  * Rich set of SEO tagging attributes on each page.

  * Configurable Google Analytics and other tracking.

  * Robust form builder including the ability for multi-step forms, conditional
    logic, customized confirmation emails, MailChimp integration, and more.

  * Article pages for building blogs, news, etc.

  * Calendar and event pages.

  * Google Maps blocks, and store locator functionality.

  * Dynamic classifier system, for creating filterable categories.

  * Website search functionality, filterable by page type.

  * Style your site using SASS/SCSS directly from Django, without the need for
    Node.js




  1. Run `pip install coderedcms`

  2. Run `coderedcms start mysite --sitename "My Company Inc." --domain www.example.com`

      *Note: `--sitename` and `--domain` are optional to pre-populate settings of your website.*

  3. Enter the project `cd mysite/`

  4. Run `python manage.py migrate` to create the core models.

  5. Run `python manage.py createsuperuser` to create the initial admin user.

  6. Run `python manage.py runserver` to launch the development server, and go to `http://localhost:8000` in your browser, or `http://localhost:8000/admin/` to log in with your admin account.

  See the [documentation](https://docs.coderedcorp.com/wagtail-crx/) for next steps and customizing your new site.




  In addition to the CodeRed team, many thanks to the Wagtail community and our
  [independent contributors](https://github.com/coderedcorp/coderedcms/graphs/contributors).

  If you're interested in building, developing, or contributing to Wagtail CRX,
  check out the [Contributing Guide](https://docs.coderedcorp.com/wagtail-crx/stable/contributing/index.html).




  Icon files in `coderedcms/templates/coderedcms/icons/`:

  * Were sourced from the Fork Awesome project at
    https://github.com/ForkAwesome/Fork-Awesome.
  * Are licensed under the Creative Commons Attribution 3.0 Unported
    license, a copy of which is available at
    https://creativecommons.org/licenses/by/3.0/
  * Have been modified from the original sources.




  We would love to hear your questions, comments, and feedback. Open an issue on Github, message us on [#coderedcms in the Wagtail slack](https://wagtailcms.slack.com/messages/CEU45SBRR).


pkgId: 8ef41093c51ac594c2b8ec1a707eca1bf72debbc93c7785f54ccc23a433ebfdd
name: python-coderev
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: AI-powered code review tool using LLMs
url: https://github.com/isavita/coderev
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coderev-0.1.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/coderev.svg)](https://badge.fury.io/py/coderev)
  [![Python versions](https://img.shields.io/pypi/pyversions/coderev.svg)](https://pypi.org/project/coderev/)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

  An AI-powered code review tool that uses LLMs to provide intelligent feedback on your pull requests.

  - Supports multiple LLM providers (OpenAI, Anthropic, Gemini, Mistral)
  - Seamless Git integration
  - Customizable review focus and guidelines
  - Command-line interface with persistent configuration



  ```bash
  pip install coderev
  ```



  - Python ≥ 3.8
  - Git repository
  - One of the following:
    - OpenAI API key for GPT-4 models
    - Anthropic API key for Claude models
    - Mistral API key for Mistral models
    - Gemini API key for Google models
    - Local Ollama installation



  1. Initialize Coderev in your git repository:
  ```bash
  coderev init
  ```

  2. Set up your preferred LLM provider (e.g., OpenAI):
  ```bash
  export OPENAI_API_KEY='your-api-key'
  ```

  3. Review your changes:
  ```bash
  coderev review
  ```





  ```bash

  coderev review


  coderev review feature/xyz


  coderev review -f src/main.py tests/test_main.py


  coderev list
  ```



  ```bash
  coderev review [OPTIONS] [BRANCH_NAME]

  Options:
    --base-branch TEXT          Base branch for comparison (default: main/master)
    -f, --review-files FILE     Review specific files
    --model TEXT                LLM model to use (default: gpt-4o)
    --temperature FLOAT         Model temperature 0-1 (default: 0.0)
    --system-message TEXT       Custom system message/persona
    --review-instructions TEXT  Custom review guidelines
    --debug                     Enable debug mode
    --help                      Show this message and exit
  ```



  Configure defaults in `.coderev.config`:

  ```bash

  coderev config list


  coderev config set model gpt-4o
  coderev config set base_branch main
  coderev config set temperature 0.0
  coderev config set system_message "Custom reviewer persona"
  coderev config set review_instructions "Custom review focus"
  ```



  Coderev uses [litellm](https://docs.litellm.ai/docs/) for model integration and supports:

  - OpenAI models (requires `OPENAI_API_KEY`):
    - `gpt-4o` (recommended)
    - `o1-mini` (faster)

  - Anthropic models (requires `ANTHROPIC_API_KEY`):
    - `claude-3-sonnet-20240320`

  - Mistral models (requires `MISTRAL_API_KEY`):
    - `mistral/mistral-large-latest`

  - Gemini models (requires `GEMINI_API_KEY`):
    - `gemini/gemini-1.5-pro-latest`

  - Local models (requires Ollama):
    - `ollama/qwen2.5-coder`



  | Variable | Description | Required For |
  |----------|-------------|-------------|
  | `OPENAI_API_KEY` | OpenAI API key | OpenAI models |
  | `ANTHROPIC_API_KEY` | Anthropic API key | Claude models |
  | `MISTRAL_API_KEY` | Mistral API key | Mistral models |
  | `GEMINI_API_KEY` | Google API key | Gemini models |
  | `CODEREV_DEBUG_ENABLED` | Enable debug mode | Debugging (optional) |





  ```bash

  git clone https://github.com/isavita/coderev
  cd coderev


  python -m venv venv
  source venv/bin/activate  # or `venv\Scripts\activate` on Windows


  pip install -e ".[dev]"
  ```



  ```bash

  pytest


  pytest tests/test_main.py -k test_name


  pytest -vv
  ```



  ```
  coderev/
  ├── src/
  │   └── coderev/
  │       ├── __init__.py     # Package version and metadata
  │       └── main.py         # Core functionality
  ├── tests/
  │   ├── __init__.py
  │   └── test_main.py        # Tests
  ├── setup.cfg               # Package metadata and config
  ├── pyproject.toml          # Build system requirements
  └── README.md               # This file
  ```



  Contributions are welcome! Please feel free to submit a Pull Request.



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



  - [litellm](https://github.com/BerriAI/litellm) - LLM provider integration
  - [Click](https://click.palletsprojects.com/) - CLI framework
  - [Rich](https://rich.readthedocs.io/) - Terminal formatting


pkgId: 80a0c7c7eb27d3158c7756d2a9f5f6eaca65d13f0df9229e25535e204171dd8a
name: python-codescanai
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A CLI tool that scans your codebases for security vulnerabilities powered by powerful AI models.
url: https://github.com/codescan-ai/codescan
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codescanai-0.1.1-1.src.rpm
checksum_type: sha256
description:
  CodeScanAI utilizes a variety of AI models, including OpenAI, Gemini, and custom self-hosted AI servers, to scan your codebase for bad development practices. It is currently configure to catch potential security vulnerabilities, but will be extended to other use cases in the future.

  It has been designed to enable  seamless integration into CI/CD pipelines like GitHub Actions, or can be used via a simple command. CodeScanAI enables developers to automatically detect potential security issues in their code throughout the development process. [Try it out today](#getting-started)!



  - **Support for Multiple AI Models:**

    - **OpenAI Integration:**  Utilize OpenAI's advanced models, such as GPT-4, to scan your code and identify potential security vulnerabilities, OR
    - **Gemini Integration:** Tap into Gemini's expertise to analyze your code for security risks, OR
    - **Custom AI Server Integration:** Connect with self-hosted or private AI servers for security scans, offering fully customizable and self-managed AI solutions.

  - **CI/CD Integration:**

    - Seamlessly integrate the CLI tool into GitHub Actions for automated security vulnerability scanning on every pull request.
    - Supports targeted scans on specific branches or changes within a repository.

  - **Flexible Scanning Options:**
    - **Full Directory Scans:** Perform a comprehensive security analysis by scanning all files within a directory.
    - **Changes Only Scan:** Only scan those files that have chnaged since the last scan.
    - **PR-Specific Scans:** Target files modified in a specific pull request to optimize the scanning process and reduce overhead.





  - Python 3.10 or higher
  - API keys for the supported AI models:
    - OpenAI API key
    - Gemini API key
    - Access to a custom AI server (host, port, and optional token)
  - Set an environment variable for your API key(s).

  ```bash
  export OPENAI_API_KEY = 'your_openai_api_key'
  ```
  OR

  ```bash
  export GEMINI_API_KEY = 'your_gemini_api_key'
  ```





  You can install the tool directly from the repository using pip:

  ```bash
  pip install codescanai
  ```

  This will allow you to use the `codescanai` command directly in your terminal.



  If you prefer to clone the repository and install the dependencies manually:

  ```bash
  git clone https://github.com/codescan-ai/codescan.git
  cd codescan
  pip install -r requirements.txt
  ```





  ```bash
  codescanai --provider openai
  ```
  OR if you're cloning the repository,
  ```bash
  python3 -m core.runner --provider openai
  ```



  To scan code using a custom AI server:

  ```bash
  codescanai --provider custom --host http://localhost --port 5000 --token your_token --directory path/to/your/code
  ```



  | name           | description                                               | required | default        |
  | -------------- | --------------------------------------------------------- | -------- | -------------- |
  | `provider`     | <p>AI provider</p>                                        | `true`   | `""`           |
  | `model`        | <p>AI model to use</p>                                    | `false`  | `""`           |
  | `directory`    | <p>Directory to scan</p>                                  | `false`  | `.`            |
  | `changes_only` | <p>Scan only changed files</p>                            | `false`  | `false`        |
  | `repo`         | <p>GitHub repository</p>                                  | `false`  | `""`           |
  | `pr_number`    | <p>Pull request number</p>                                | `false`  | `""`           |
  | `github_token` | <p>GitHub API token</p>                                   | `false`  | `""`           |
  | `host`         | <p>Custom AI server host</p>                              | `false`  | `""`           |
  | `port`         | <p>Custom AI server port</p>                              | `false`  | `""`           |
  | `token`        | <p>Token for authenticating with the custom AI server</p> | `false`  | `""`           |
  | `endpoint`     | <p>API endpoint for the custom server</p>                 | `false`  | `/api/v1/scan` |



  - **OpenAI:** Utilizes GPT models for in-depth security analysis.
  - **Gemini:** Delivers strong security insights through Gemini's advanced capabilities.
  - **Custom:** Connects with self-hosted or private AI servers for fully customizable solutions.



  - **Large number of files:** We currently do not support scalable way to scan a large number of files on a single run. Depending on the capacity of your AI Provider, you might run into a `rate_limit_exceeded` error. To do this, you can create a custom solution that breaks down the number of files for each run.



  - **Batch Processing:** For the limitation above, a future version will be to implement batch processing for a large number of files.

  - **Caching Implementation:** A caching mechanism to store results of previously scanned files, reducing the number of API calls and optimizing performance.

  - **Expanded Git Provider Support:** The tool is currently integrated with GitHub for PR-based scanning, future plans include extending support to other Git providers like GitLab, Bitbucket, and Azure Repos.

  - **Expanded Development tools:** This will be a plan to expand this tool to be accessible in other development environments. For example, as a VSCode extension.



  Contributions are welcome! Please fork the repository and submit a pull request with your improvements.



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


pkgId: 8290725a03bc273d1e306f0ee32af5da6345f77d670333d2770630cd20eac79b
name: python-codesearch
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A fast code search tool using Tantivy
url: https://github.com/yourusername/codesearch
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codesearch-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A fast and efficient code search tool powered by Tantivy, allowing you to search through your codebase with ease.



  ```bash
  pip install codesearch
  ```



  Index your code:
  ```bash
  codesearch --index /path/to/your/code --extensions py,js,ts
  ```

  Search in your indexed code:
  ```bash
  codesearch --search "your search query"
  ```



  - Fast full-text search in your codebase
  - Support for multiple file extensions
  - Preview of search results
  - Configurable search options



  - Python 3.7+
  - Tantivy
  - Loguru



  MIT License


pkgId: 42508a8a3ba052232e3e138c7b51cf3ed6db8fe002d134cc98836a5e83d81bc9
name: python-codesee-util
arch: src
version: 0.88.0
epoch: 0
release: 1
summary: CodeSee Python utilities
url: https://www.codesee.io
rpm_license: Other/Proprietary License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codesee-util-0.88.0-1.src.rpm
checksum_type: sha256
description:
  A collection of Python utilities devloped by
  [CodeSee](https://www.codesee.io). Includes the following:



  A command-line utility we use when generating CodeSee Maps. It
  has the ability to introspect a directory containing a Python package,
  and emits information about that package.


pkgId: a2a0089e4ca226fb838354a125c9eb7f5a4fc329210378a472953b0b5ab230ee
name: python-codeshield
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Shield against LLM generated insecure code
url: https://github.com/meta-llama/PurpleLlama
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codeshield-1.0.1-1.src.rpm
checksum_type: sha256
description:
  > Shield against LLM generated insecure code
  <p align="center">
    <img src="https://raw.githubusercontent.com/meta-llama/PurpleLlama/main/CodeShield/images/codeshield_logo.png" width="400"/>
  </p>

  CodeShield is a robust inference time filtering tool engineered to prevent the introduction of insecure code generated by LLMs into production systems. LLMs, while instrumental in automating coding tasks and aiding developers, can sometimes output insecure code, even when they have been security-conditioned.  CodeShield stands as a guardrail to help ensure that such code is intercepted and filtered out before making it into the codebase.


  LLMs have become an integral part of the coding process, automating coding tasks and serving as a co-pilot for developers. However, our study [CyberSecEval](https://arxiv.org/abs/2312.04724), revealed that it is not uncommon for these code-producing models to inadvertently generate insecure code. This poses a significant risk when developers incorporate this insecure code without verification, especially for those who do not have strong cybersecurity background
  CodeShield helps mitigate this risk by intercepting and blocking insecure code generated by LLMs in a configurable way. CodeShield leverages a static analysis library, the Insecure Code Detector (ICD), to identify insecure code. ICD uses a suite of static analysis tools to perform the analysis across 7 programming languages, covering more than 50+ CWEs. For more details, please see  [here](https://github.com/meta-llama/PurpleLlama/tree/main/CodeShield/insecure_code_detector?tab=readme-ov-file#insecure-code-detector)



  CodeShield is designed to be applicable for various scenarios, here are a few example use cases
  * LLM is utilized as a coding assistant. CodeShield is an ideal fit for AI Coding assistants integrated with IDEs like VSCode or any other development framework, where it is able to block insecure code suggestions
  * Chatbots are used to help with coding tasks. It has become a common practice for developers to ask LLMs for code snippets. Consequently, more and more code is produced by LLMs nowadays. Codeshield is able to fortify any code-producing LLMs by either adding a warning message or completely blocking the response

  <p align = "center">
      <img src="https://raw.githubusercontent.com/meta-llama/PurpleLlama/main/CodeShield/images/design.png" alt="ImageA" width="400">
      <figcaption style="text-align: center;">Fig1: Depicting the flow of how CodeShield should be used for output scanning from LLM before the suggestions are propagated for the user facing applications.</figcaption>
  </p>


  CodeShield is optimized for production environments where latency is a critical factor for user experience. It is designed to swiftly process the input by a two-layer scanning solution. Specifically, CodeShield will first identify alarming code patterns in the to be scanned content, and perform a more comprehensive analysis if the content is deemed suspicious in the first step.

  Our studies indicate that in production environments, over 98% of the traffic is classified as benign and does not necessitate comprehensive scanning. This means that in approximately 99% of cases, requests are processed within a swift 70ms window. For the remaining traffic that requires more thorough scanning, the p90 latency is 450ms in modern production server environments.
  This optimization ensures that CodeShield provides robust security without compromising on performance, making it an ideal choice for production environments where both security and speed are crucial.




  CodeShield's primary function is to flag insecure code snippets, acting as a preventative shield to enforce secure coding guidelines. As such, it may not only flag directly exploitable vulnerabilities, but also focuses on enhancing  code hygiene by preventing insecure coding practices.

  Signals generated from CodeShield can be used in different ways. For example, one can expedite the productionization of benign code. Some applications might opt to prevent insecure code from being suggested at all. Alternatively, they could display a warning message to developers about potential security issues within a code snippet.



  Follow the instructions and examples as shown in the [notebook](https://github.com/meta-llama/PurpleLlama/tree/main/CodeShield/notebook/CodeShieldUsageDemo.ipynb)


pkgId: a5e95492619dda499431fc0a67e5c1f272d7a9256e95ebb93e9722553ad05b1a
name: python-codesnipper
arch: src
version: 0.1.18.16
epoch: 0
release: 1
summary: A lightweight framework for censoring student solutions files and extracting code + output
url: https://lab.compute.dtu.dk/tuhe/snipper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codesnipper-0.1.18.16-1.src.rpm
checksum_type: sha256
description:
  A lightweight framework for removing code from student solutions.

  ```console
  pip install codesnipper
  ```

  This project address the following three challenges for administering a python-based course

   - Maintain a (working) version for debugging as well as a version handed out to students (with code missing)
   - Use LaTeX references in source code to link to course material (i.e. `\ref{mylabel}` -> *"(see equation 2.1 in exercise 5)"*)
   - Including code snippets and console output in lectures notes/exercises/beamer slides
   - Automatically create student solutions

  This framework address these problems and allow you to maintain a **single**, working project repository. Below is an example of the snippets produced and included using simple `\inputminted{python}{...}` commands (see the `examples/` directory):

  ![LaTeX sample](https://gitlab.compute.dtu.dk/tuhe/snipper/-/raw/main/docs/latex_nup.png)

  The project is currently used in **02465** at DTU. An example of student code can be found at:
   - https://gitlab.gbar.dtu.dk/02465material/02465students/blob/master/irlc/ex02/dp.py

  A set of lectures notes where all code examples/output are automatically generated from the working repository can be found a
  - https://lab.compute.dtu.dk/tuhe/books (see **Sequential decision making**)


  All examples can be found in the `/examples` directory. The idea is all our (complete) files are found in the instructor directory and snipper keeps everything up-to-date:
  ```text
  examples/cs101_instructor  # This directory contains the (hidden) instructor files. You edit these
  examples/cs101_students    # This directory contains the (processed) student files. Don't edit these
  examples/cs101_output      # This contains automatically generated contents (snippets, etc.).
  ```
  The basic functionality is you insert special comment tags in your source, such as `#!b` or `#!s` and the script then process
  the sources based on the tags.  The following will show most common usages:


  Let's start with the simplest example, blocking out a function (see `examples/cs101_instructor/f_tag.py`; actually it will work for any scope)
  You insert a comment like: `#!f <exception message>` like so:
  ```python
  def myfun(a,b): #!f return the sum of a and b
      """ The doc-string is not removed. """
      sm = a+b
      return sm
  ```
  To compile this (and all other examples) use the script `examples/process_cs101.py`
  ```python
  if __name__ == "__main__":
      from snipper.snip_dir import snip_dir
      snip_dir("./cs101_instructor", "./cs101_students", output_dir="./cs101_output")
  ```
  The output can be found in `examples/students/f_tag.py`. It will cut out the body of the function but leave any return statement and docstrings. It will also raise an exception (and print how many lines are missing) to help students.
  ```python
  def myfun(a,b):
      """ The doc-string is not removed. """
      
      raise NotImplementedError("return the sum of a and b")
      return sm
  ```


  The #!b-tag allows you more control over what is cut out. The instructor file:
  ```python
  def primes_sieve(limit):
      limitn = limit+1 #!b
      primes = range(2, limitn)
      for i in primes:
          factors = list(range(i, limitn, i))
          for f in factors[1:]:
              if f in primes:
                  primes.remove(f) #!b Compute the list `primes` here of all primes up to `limit`
      return primes
  width, height = 2, 4
  print("Area of square of width", width, "and height", height, "is:")
  print(width*height) #!b #!b Compute and print area here
  print("and that is a fact!")
  ```
  Is compiled into:
  ```python
  def primes_sieve(limit):
      
      raise NotImplementedError("Compute the list `primes` here of all primes up to `limit`")
      return primes
  width, height = 2, 4
  print("Area of square of width", width, "and height", height, "is:")

  raise NotImplementedError("Compute and print area here")
  print("and that is a fact!")
  ```
  This allows you to cut out text across scopes, but still allows you to insert exceptions.




  The #!s-tag is useful for making examples to include in exercises and lecture notes. The #!s (snip) tag cuts out the text between
  tags and places it in files found in the output-directory. As an example, here is the instructor file:
  ```python
  width, height = 2, 4
  print("Area of square of width", width, "and height", height, "is:") #!s
  print(width*height)  #!s  # This is an example of a simple cutout
  print("and that is a fact!")
  print("An extra cutout") #!s #!s  # This will be added to the above cutout
  def primes_sieve(limit): #!s=a # A named cutout
      limitn = limit+1
      primes = range(2, limitn)
      for i in primes: #!s=b A nested/named cutout.
          factors = list(range(i, limitn, i))
          for f in factors[1:]:
              if f in primes:
                  primes.remove(f)  #!s=b
      return primes #!s=a
  ```
  Note it allows
   - naming using the #!s=<name> command
   - automatically join snippets with the same name (useful to cut out details)
   - The named tags will be matched, and do not have to strictly contained in each other

  This example will produce three files
  `cs101_output/s_tag.py`, `cs101_output/s_tag_a.py`, and `cs101_output/s_tag_b.py` containing the output:
  ```python

  print("Area of square of width", width, "and height", height, "is:")
  print(width*height)
  print("An extra cutout")
  ```
  and
  ```python

  def primes_sieve(limit):
      limitn = limit+1
      primes = range(2, limitn)
      for i in primes: #!s=b A nested/named cutout.
          factors = list(range(i, limitn, i))
          for f in factors[1:]:
              if f in primes:
                  primes.remove(f)  #!s=b
      return primes
  ```
  and finally:
  ```python

      for i in primes:
          factors = list(range(i, limitn, i))
          for f in factors[1:]:
              if f in primes:
                  primes.remove(f)
  ```
  I recommend using `\inputminted{filename}` to insert the cutouts in LaTeX.



  The #!o-tag allows you to capture output from the code, which can be useful when showing students the expected
  behavior of their scripts. Like the #!s-tag, the #!o-tags can be named.

  As an example, Consider the instructor file
  ```python
  if __name__ == "__main__":
      print("Here are the first 4 square numbers") #!o=a
      for k in range(1,5):
          print(k*k, "is a square")
      
      print("This line will not be part of a cutout.")
      width, height = 2, 4 #!o=b
      print("Area of square of width", width, "and height", height, "is:")
      print(width*height)
      print("and that is a fact!") #!o=b
  ```
  This example will produce two files `cs101_output/o_tag_a.txt`, `cs101_output/o_tag_b.txt`:
  ```terminal
  Here are the first 4 square numbers
  1 is a square
  4 is a square
  9 is a square
  16 is a square
  ```
  and
  ```terminal
  Area of square of width 2 and height 4 is:
  8
  and that is a fact!
  ```


  The #!i-tag allows you to create interactive python shell-snippets that can be imported using
   the minted `pycon` environment (`\inputminted{python}{input.shell}`).
   As an example, consider the instructor file
  ```python
  for animal in ["Dog", "cat", "wolf"]: #!i=a
      print("An example of a four legged animal is", animal) #!i=a

  def myfun(a,b):
      return a+b
  myfun(3,4) #!i=b

  ```
  This example will produce two files `cs101_output/i_tag_a.shell`, `cs101_output/i_tag_b.shell`:
  ```pycon
  >>> for animal in ["Dog", "cat", "wolf"]:
  ...     print("An example of a four legged animal is", animal)
  ...
  An example of a four legged animal is Dog
  An example of a four legged animal is cat
  An example of a four legged animal is wolf
  ```
  and
  ```pycon
  >>> def myfun(a,b):
  ...     return a+b
  ...
  >>> myfun(3,4)
  7
  ```
  Note that apparently there
   is no library for converting python code to shell sessions so I had to write it myself, which means it can properly get confused with multi-line statements (lists, etc.). On the plus-side, it will automatically insert newlines after the end of scopes.
   My parse is also known to be a bit confused if your code outputs `...` since it has to manually parse the interactive python session and this normally indicates a new line.


  One of the most annoying parts of maintaining student code is to constantly write *"see equation on slide 41 bottom"* only to have the reference go stale because slide 23 got removed. Well not anymore, now you can direcly refence anything with a bibtex or aux file!
  Let's consider the following example of a simple document with a couple of references: (see `examples/latex/index.pdf`):

  ![LaTeX sample](https://gitlab.compute.dtu.dk/tuhe/snipper/-/raw/main/docs/index.png)

  The code for this document is:
  ```latex
  \documentclass{article}
  \usepackage{url,graphics,rotating,hyperref}
  \usepackage{cleveref}
  \usepackage{showlabels}
  \begin{document}
  \section{First section}\label{sec1}
  Math is hard \cite{bertsekasII,rosolia2018data,herlau}, see also \cref{eq1} and \cref{fig1}.
  \begin{equation}
  	2+2 = 4 \label{eq1}
  \end{equation}
  \begin{figure}\centering
  \includegraphics[width=.8\linewidth]{br}\caption{A figure}\label{fig1}
  \end{figure}
  \bibliographystyle{alpha}
  \bibliography{library}
  \end{document}
  ```

  To use the references in code we first have to load the `references.bib` file and the `index.aux`-file and then:
   - Snipper allows you to directly insert this information using `\cite` and `\ref`
   - You can also define custom citation command which allows you to reference common sources like
     - Lecture notes
      - Exercise sheets
      - Slides for a particular week

  Let's look at all of these in turn. The file we will consider in the instructor-version looks like this: (`examples/cs101_instructor/references.py`):
  ```python
  def myfun():
      """
      Simple aux references \ref{eq1} in \ref{sec1}.
      Simple bibtex citations: \cite{bertsekasII} and \cite[Somewhere around the middle]{herlau}
      Example of custom command (reference notes)
      > \nref{fig1}
      Other example of custom command (reference assignment)
      > \aref2{sec1}
      """
      print("See \ref{sec1}")  # Also works.
      return 42
  ```
  Note the last parts of the file contains the special commands `\nref` (references to lecture notes) and `\aref2` (assignment 2) which I want to define.
  This can be done by changing the call to snipper as follows (`examples/process_cs101_references.py`)
  ```python
  from snipper.snip_dir import snip_dir
  from snipper.load_citations import get_aux, get_bibtex
  def main():
      bibfile = get_bibtex('latex/library.bib')
      auxfile = get_aux('latex/index.aux')
      references = dict(bibtex=bibfile,
                        aux=auxfile,
                        commands=[dict(command='\\aref2', output="(Assignment 2, %s)", aux=auxfile),
                                  dict(command='\\nref', output="\cite[%s]{herlau}", aux=auxfile),
                                 ])
      snip_dir("./cs101_instructor", "./cs101_students", output_dir="./cs101_output", references=references)
  if __name__ == "__main__":
      main()
  ```
  And this then produce the output:
  ```python
  """
  References:
    [Ber07] Dimitri P. Bertsekas. Dynamic Programming and Optimal Control, Vol. II. Athena Scientific, 3rd edition, 2007. ISBN 1886529302.
    [Her21] Tue Herlau. Sequential decision making. (See 02465_Notes.pdf), 2021.
  """
  def myfun():
      """
      Simple aux references eq. (1) in Section 1.
      Simple bibtex citations: (Ber07) and (Her21, Somewhere around the middle)
      Example of custom command (reference notes)
      > (Her21, Figure 1)
      Other example of custom command (reference assignment)
      > (Assignment 2, Section 1)
      """
      print("See Section 1")  # Also works.
      return 42
  ```
  Since the aux/bibtex databases are just dictionaries it is easy to join them together from different sources.
   I have written reference tags to lecture and exercise material as well as my notes and it makes reference management very easy.



  The default behavior for code removal (#!b and #!f-tags) is to simply remove the code and insert the number of missing lines.
  We can easily create more interesting behavior. The code for the following example can be found in `examples/b_example.py` and will deal with the following problem:
  ```python
  import numpy as np

  def primes_sieve(limit):
      limitn = limit+1 #!b
      primes = range(2, limitn)
      for i in primes:
          factors = list(range(i, limitn, i))
          for f in factors[1:]:
              if f in primes:
                  primes.remove(f)
      return primes #!b

  ```
  The examples below shows how we can easily define custom functions for processing the code which is to be removed; I have not included the functions here for brevity,
  but they are all just a few lines long and all they do is take a list of lines (to be obfuscated) and return a new list of lines (the obfuscated code).


  This example simple randomly permutes the line and prefix them with a comment tag to ensure the code still compiles
  ```python
  import numpy as np

  def primes_sieve(limit):
      
      
      
      
      
      
      
      
      

  raise NotImplementedError('Complete the above program')
  ```

  This example replaces non-keyword, non-special-symbol parts of the lines:
  ```python
  import numpy as np

  def primes_sieve(limit):
      
      
      
      
      
      
      
      
      

  raise NotImplementedError('Complete the above program')
  ```


  The final example displays half of the proposed solution:
  ```python
  import numpy as np

  def primes_sieve(limit):
      
      
      
      
      
      
      
      
      

  raise NotImplementedError('Complete the above program')
  ```



  ```bibtex
  @online{codesnipper,
  	title={Codesnipper (0.1.0): \texttt{pip install codesnipper}},
  	url={https://lab.compute.dtu.dk/tuhe/snipper},
  	urldate = {2021-09-07},
  	month={9},
  	publisher={Technical University of Denmark (DTU)},
  	author={Tue Herlau},
  	year={2021},
  }
  ```


pkgId: 022d8931fbab7751014149fc351f7d6de95950456bd2b3b3db53dfe46d64c6da
name: python-codespell
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Codespell
url: https://pypi.org/project/codespell/
rpm_license: GPL-2.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codespell-2.3.0-1.src.rpm
checksum_type: sha256
description:
  Fix common misspellings in text files. It's designed primarily for checking
  misspelled words in source code (backslash escapes are skipped), but it can be used with other files as well.
  It does not check for word membership in a complete dictionary, but instead
  looks for a set of common misspellings. Therefore it should catch errors like
  "adn", but it will not catch "adnasdfasdf". This also means it shouldn't
  generate false-positives when you use a niche term it doesn't know about.


pkgId: 4f9763ee6bc6ced123a59e83e924460a634f69165902127060e1efc708d80b37
name: python-codestyle
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Extendable codestyle checker and fixer
url: https://github.com/webpp-studio/codestyle
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codestyle-0.4.3-1.src.rpm
checksum_type: sha256
description:
  This script checks and auto fixes codestyle for all supported languages:
  1. PHP (phpcs)
  2. Python (flake8)
  3. Javascript (jscs and jshint)
  4. CSS (csscomb)
  5. HTML (htmlcs)


pkgId: 09e1f836bcc9f2c9b6ec27b1a443e6c9ef721dc79afb07a3e7b44a9ca121ad39
name: python-codetiming
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: A flexible, customizable timer for your Python code.
url: https://realpython.com/python-timer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codetiming-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Python Timer Functions: Three Ways to Monitor Your Code](https://files.realpython.com/media/Three-Ways-to-Time-Your-Code_Watermarked.8d561fcc7a35.jpg)](https://realpython.com/python-timer)



  [![Latest version](https://img.shields.io/pypi/v/codetiming)](https://pypi.org/project/codetiming/)
  [![Python versions](https://img.shields.io/pypi/pyversions/codetiming)](https://pypi.org/project/codetiming/)
  [![Downloads](https://img.shields.io/pypi/dd/codetiming)](https://pypi.org/project/codetiming/)
  [![Tests](https://img.shields.io/github/workflow/status/realpython/codetiming/unit_tests?label=tests)](https://github.com/realpython/codetiming/actions)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![Interrogate DocStrings](https://raw.githubusercontent.com/realpython/codetiming/main/interrogate_badge.svg)](https://interrogate.readthedocs.io/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![MIT license](https://img.shields.io/pypi/l/codetiming)](https://mit-license.org/)

  Install `codetiming` from PyPI:

  ```
  $ python -m pip install codetiming
  ```

  The source code is [available on GitHub](https://github.com/realpython/codetiming).

  For a complete tutorial on `codetiming`, see [Python Timer Functions: Three Ways to Monitor Your Code](https://realpython.com/python-timer) on [Real Python](https://realpython.com/).



  You can use `codetiming.Timer` in several different ways:

  1. As a **class**:

      ```python
      t = Timer(name="class")
      t.start()
      
      t.stop()
      ```

  2. As a **context manager**:

      ```python
      with Timer(name="context manager"):
          
      ```

  3. As a **decorator**:

      ```python
      @Timer(name="decorator")
      def stuff():
          
      ```




  `Timer` accepts the following arguments when it's created. All arguments are optional:

  - **`name`:** An optional name for your timer
  - **`text`:** The text that's shown when your timer ends. It should contain a `{}` placeholder that will be filled by the elapsed time in seconds (default: `"Elapsed time: {:.4f} seconds"`)
  - **`initial_text`:** Show text when your timer starts. You may provide the string to be logged or `True` to show the default text `"Timer {name} started"` (default: `False`)
  - **`logger`:** A function/callable that takes a string argument and will report the elapsed time when the logger is stopped (default: `print()`)

  You can turn off explicit reporting of the elapsed time by setting `logger=None`.

  In the template text, you can also use explicit attributes to refer to the `name` of the timer or log the elapsed time in `milliseconds`, `seconds` (the default), or `minutes`. For example:

  ```python
  t1 = Timer(name="NamedTimer", text="{name}: {minutes:.1f} minutes")
  t2 = Timer(text="Elapsed time: {milliseconds:.0f} ms")
  ```

  Note that the strings used by `text` are **not** f-strings. Instead, they are used as templates that will be populated using `.format()` behind the scenes. If you want to combine the `text` template with an f-string, you need to use double braces for the template values:

  ```python
  t = Timer(text=f"{__file__}: {{:.4f}}")
  ```

  `text` is also allowed to be a callable like a function or a class. If `text` is a callable, it is expected to require one argument: the number of seconds elapsed. It should return a text string that will be logged using logger:

  ```python
  t = Timer(text=lambda secs: f"{secs / 86400:.0f} days")
  ```

  This allows you to use third-party libraries like [`humanfriendly`](https://pypi.org/project/humanfriendly/) to do the text formatting:

  ```python
  from humanfriendly import format_timespan

  t1 = Timer(text=format_timespan)
  t2 = Timer(text=lambda secs: f"Elapsed time: {format_timespan(secs)}")
  ```

  You may include a text that should be logged when the timer starts by setting `initial_text`:

  ```python
  t = Timer(initial_text="And so it begins ...")
  ```

  You can also set `initial_text=True` to use a default initial text.




  When using `Timer` as a class, you can capture the elapsed time when calling `.stop()`:

  ```python
  elapsed_time = t.stop()
  ```

  You can also find the last measured elapsed time in the `.last` attribute. The following code will have the same effect as the previous example:

  ```python
  t.stop()
  elapsed_time = t.last
  ```




  Named timers are made available in the class dictionary `Timer.timers`. The elapsed time will accumulate if the same name or same timer is used several times. Consider the following example:

  ```pycon
  >>> import logging
  >>> from codetiming import Timer

  >>> t = Timer("example", text="Time spent: {:.2f}", logger=logging.warning)

  >>> t.start()
  >>> t.stop()
  WARNING:root:Time spent: 3.58
  3.5836678670002584

  >>> with t:
  ...     _ = list(range(100_000_000))
  ...
  WARNING:root:Time spent: 1.73

  >>> Timer.timers
  {'example': 5.312697440000193}
  ```

  The example shows how you can redirect the timer output to the logging module. Note that the elapsed time spent in the two different uses of `t` has been accumulated in `Timer.timers`.

  You can also get simple statistics about your named timers. Continuing from the example above:

  ```pycon
  >>> Timer.timers.max("example")
  3.5836678670002584

  >>> Timer.timers.mean("example")
  2.6563487200000964

  >>> Timer.timers.stdev("example")
  1.311427314335879
  ```

  `timers` support `.count()`, `.total()`, `.min()`, `.max()`, `.mean()`, `.median()`, and `.stdev()`.




  `codetiming` is based on a similar module initially developed for the [Midgard Geodesy library](https://kartverket.github.io/midgard/) at the [Norwegian Mapping Authority](https://www.kartverket.no/en/).


pkgId: 1c2fbf97df83db5c4e620c576f5a963dbbc6547a5bf8bc2e4498a823d2df3afe
name: python-codetocad
arch: src
version: 0.4.1728739615
epoch: 0
release: 1
summary: 3D modeling automation in your favorite modeling software.
url: https://github.com/CodeToCAD/CodeToCAD
rpm_license: GPL v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codetocad-0.4.1728739615-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
      <a href="https://pypi.org/project/codetocad/0.2.1688153771/">
      <h1>CodeToCAD</h1>
      </a>
      <p><strong>One language for all your CAD needs</p>
  </div>
  <p align="center">
     <a href="https://codetocad.github.io/CodeToCAD/docs.html"><img src="https://img.shields.io/badge/Read_the_docs-white?logo=readthedocs&logoColor=black"/></a>
     <a href="https://discord.gg/MnZEtqwt74"><img alt="Discord" src="https://img.shields.io/discord/955573351806562335?logo=discord&logoColor=black&label=Discord&labelColor=white&color=blue"></a>
     <a href="https://github.com/CodeToCAD/CodeToCAD/stargazers"><img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/CodeToCAD/CodeToCAD"/></a>
     <a href="https://github.com/search?q=repo%3ACodeToCAD%2FCodeToCAD++language%3APython&type=code"><img alt="GitHub top language" src="https://img.shields.io/github/languages/top/CodeToCAD/CodeToCAD?logo=python&labelColor=white&color=blue"></a>
     <a href="https://codetocad.github.io/CodeToCAD/examples.html"><img alt="Static Badge" src="https://img.shields.io/badge/Examples-white?logo=internetarchive&logoColor=black"></a>
  </p>



  - [Table of Contents](#table-of-contents)
  - [What is CodeToCAD](#what-is-codetocad)
  - [Why CodeToCAD?](#why-codetocad)
  - [Getting started](#getting-started)
  - [Supported Applications](#supported-applications)
      - [Alpha/Beta Support](#alphabeta-support)
      - [To Be Developed](#to-be-developed)
  - [Working with the software of your choice](#working-with-the-software-of-your-choice)
    - [Compatible software](#compatible-software)
    - [Blender](#blender)
      - [Sidebar Panel](#sidebar-panel)
      - [Fusion 360](#fusion-360)
      - [Onshape](#onshape)
  - [What's next](#whats-next)
  - [For the developers](#for-the-developers)
  - [Additional Resources](#additional-resources)
  - [Contributors](#contributors)
  - [Support us ❤️](#support-us-️)



  CodeToCAD is an open source code-CAD automation. It provides extendable, declarative and imperative interfaces that allow engineers and developers to write code-CAD scripts that can be checked into source control, collaborated on, and run on any supported 3D modeling software.



  ✅ Simplified modeling interface - it's all text! No more scrolling and clicking into sub-menus to edit your models.

  🔓 Not vendor locked - your models are created in an open-source language. If you want to use another software, you do not lose the features you have defined. Note: There is no guarantee that a model created for, e.g. Blender, will work right away for another software, but with some refactoring, it theoretically should!

  🪶 Lightweight and portable. All you need is a text-editor to model. You can occasionally fire-up your modeling software to run your creations.

  💪 Leverages existing programming languages, like Python. You can keep using the languages you're familiar with and love. There is no one-off language you and your team has to learn. Use CodeToCAD like a library or a framework.

  🚦Easy version control. Your models are written in code, you can use industry-loved git to keep track of versions of your models.

  💕 Built by people who believe in automation and that modeling workflows should be intuitive, reliable and most importantly free and open source!

  <div align="center">
  <image src="https://raw.githubusercontent.com/CodeToCAD/CodeToCAD/develop/docs/images/three_axis_mill.gif"/>
  </div>



  > Pre-requisites: [Python 3.11 or newer](https://www.python.org/downloads/).

  1. Install the [CodeToCAD PIP Package](https://pypi.org/project/CodeToCAD/) to get intellisense syntax highlighting.

     ```
     pip install CodeToCAD
     ```

  2. Create your own CodeToCAD python file and save it ([docs](https://codetocad.github.io/CodeToCAD/docs.html)):

     ```python
     
     
     from codetocad import *

     my_material = Material("material").set_color(169, 76, 181, 0.8)
     Part("Cube").create_cube(1, 1, 1).set_material(my_material)
     ```

  3. Watch as your code gets seemlessly translated into CAD using our [custom addon](#working-with-the-software-of-your-choice) for your desired application

  ![Material Cube](https://raw.githubusercontent.com/CodeToCAD/CodeToCAD/develop/docs/images/material_cube.png)

  4. You may also run `codetocad my_codetocad_script.py` from the CLI to run your script.

  > Above is the above script being run in blender using our [Blender Addon](#blender) below.

  > Warning: Since CodeToCAD scripts are written and executed in Python, be careful when running scripts you find on the internet!





  - [Blender 4.1](https://www.blender.org/) - Digital Modeling Software
     - [Instructions](#blender)
  - [Fusion 360](https://www.autodesk.com/products/fusion-360/overview) - M-CAD, E-CAD and CAE Software developed by Autodesk
     - [Instructions](#fusion-360)
  - [Onshape](https://www.onshape.com/en/) - Product Development and CAD Software
     - [Instructions](#onshape)


  - [PyBullet](https://pybullet.org/) - Real-time Physics Simulation Library
  - [KiCAD](https://www.kicad.org/) - Electronic/PCB Design Software
  - LLM/AI based model generation
  - [FreeCAD](https://www.freecad.org/) - CAD Software
  - [ThreeJS](https://threejs.org/) - Web-based 3D Library
  - [Libfive](https://libfive.com/) - Signed Distance Field Modeling library


  > Remember to first follow the getting [started instructions](#getting-started)


  1. [Blender 4.1](#blender)
  2. [Fusion360](#fusion-360)
  2. [Onshape](#onshape)



  1. Download a release of the Blender Addon from the latest [release](https://github.com/CodeToCAD/CodeToCAD/releases)
     > Note for developers: instead of downloading a release, you can clone this repository, then import [blender_addon.py](./providers/blender/blender_addon.py) and set to CodeToCAD path in the addon to the root of this repository. Please watch this guide to get set up: [Video Guide](https://youtu.be/YD_4nj0QUJ4)

  2. Install the Blender Addon in the blender software

      <img src="https://raw.githubusercontent.com/CodeToCAD/CodeToCAD/develop/docs/images/Blender_Install_Addon.gif" width=400 />

  3. Import your script using the file menu > import > CodeToCAD or the CodeToCAD menu in the sidebar.

     <img src="https://raw.githubusercontent.com/CodeToCAD/CodeToCAD/develop/docs/images/import_file_in_blender.png" width=400 />

  > Note, you can also run CodeToCAD in Blender via cli: `blender -- --codetocad $(pwd)/yourScript.py` or `codetocad yourScript.py blender /path/to/blender/executable`



  You can use the side-panel to import CodeToCAD files or start a debugger server.

     <img src="https://raw.githubusercontent.com/CodeToCAD/CodeToCAD/develop/docs/images/blender_panel.png" width=400 />



  To use CodeToCAD with Fusion 360, please install the Add-In. Please check out the [README](./providers/fusion360/codetocad_fusion360_addin/README.md) for more information.

     <img src="https://raw.githubusercontent.com/CodeToCAD/CodeToCAD/develop/providers/fusion360/codetocad_fusion360_addin/fusion360_addin.png" width=400 />



  Please refer to the [Onshape README](./providers/onshape/README.md) for more information on how to setup an API key and connect to the Onshape Client.


  - Run or browse the [examples](./examples/)!

    ![Stacked Cubes](docs/images/stacked_cubes.png)

  - Join the [Discord Server](https://discord.gg/MnZEtqwt74) to receive updates and help from the community!


  We welcome all contributors to the project, to get started with contributing check out our [Contributing guidelines](/development/README.md)


   - [CodeToCAD docs](https://codetocad.github.io/CodeToCAD/docs.html)
   - [CodeToCAD PyPI](https://pypi.org/project/codetocad/)
   - [Blender API docs](https://docs.blender.org/api/current/index.html)


  Thank you to all our contributors for their invaluable time, effort, and expertise in making CodeToCAD possible:

  <a href="https://github.com/CodeToCAD/CodeToCAD/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=CodeToCAD/CodeToCAD" />
  </a>



  Any and all donations toward the project are much appreciated and help greatly:
   - [GitHub Sponsors](https://github.com/sponsors/CodeToCAD)
   - [Patreon](https://www.patreon.com/CodeToCAD)


pkgId: 4ba3f589050fd4a0fbbacc4b60fef60635b4d7dedfbbd1e152427cbc0497eee3
name: python-codex
arch: src
version: 1.7.10
epoch: 0
release: 1
summary: A comic archive web server.
url: https://github.com/ajslater/codex
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codex-1.7.10-1.src.rpm
checksum_type: sha256
description:
  A comic archive browser and reader.

  <img src="codex/static_src/img/logo.svg" style="
  height: 128px;
  width: 128px;
  border-radius: 128px;
  " />



  - Codex is a web server.
  - GPLv3 Licenced.
  - Full text search of metadata and bookmarks.
  - Filter and sort on all comic metadata and unread status per user.
  - Browse a tree of Publishers, Imprints, Series, Volumes, or your own folder
    hierarchy, or by tagged Story Arc.
  - Read comics in a variety of aspect ratios and directions that fit your screen.
  - Watches the filesystem and automatically imports new or changed comics.
  - Anonymous browsing and reading or reigistered users only, to your preference.
  - Per user bookmarking & settings, even before you make an account.
  - Private Libraries accessible only to certain groups of users.
  - Reads CBZ, CBR, CBT, and PDF formatted comics.
  - Syndication with OPDS 1 & 2, streaming, search and authentication.
  - Add custom covers to Folders, Publishers, Imprints, Series, and Story Arcs.
  - Runs in 1GB of RAM, faster with more.



  - _Filter by_ Story Arc and Unread, _Order by_ Publish Date to create an event
    reading list.
  - _Filter by_ Unread and _Order by_ Added Time to see your latest unread comics.
  - _Search by_ your favorite character to find their appearances across different
    comics.



  You may browse a [live demo server](https://demo.codex-reader.app/) to get a
  feel for Codex.



  Codex has a <a href="NEWS.md">NEWS file</a> to summarize changes that affect
  users.





  Run the official [Docker Image](https://hub.docker.com/r/ajslater/codex).
  Instructions for running the docker image are on the Docker Hub README. This is
  the recommended way to run Codex.

  You'll then want to read the [Administration](#administration) section of this
  document.



  If you have a [HomeAssistant](https://www.home-assistant.io/) server, Codex can
  be installed with the following steps :

  - Add the `https://github.com/alexbelgium/hassio-addons` repository by
    [clicking here](https://my.home-assistant.io/redirect/supervisor_add_addon_repository/?repository_url=https%3A%2F%2Fgithub.com%2Falexbelgium%2Fhassio-addons)
  - Install the addon :
    [click here to automatically open the addon store, then install the addon](https://my.home-assistant.io/redirect/supervisor)
  - Customize addon options, then then start the add-on.



  You can also run Codex as a natively installed python application with pip.



  You'll need to install the appropriate system dependencies for your platform
  before installing Codex.





  ...and Ubuntu, Mint, MX, Window Subsystem for Linux, and others.

  ```sh
  apt install build-essential libimagequant0 libjpeg-turbo8 libopenjp2-7 libssl libyaml-0-2 libtiff6 libwebp7 python3-dev python3-pip mupdf sqlite3 unrar zlib1g
  ```

  Versions of packages like libjpeg, libssl, libtiff may differ between flavors
  and versions of your distribution. If the package versions listed in the example
  above are not available, try searching for ones that are with `apt-cache` or
  `aptitude`.

  ```sh
  apt-cache search libjpeg-turbo
  ```



  ```sh
  apk add bsd-compat-headers build-base jpeg-dev libffi-dev libwebp openssl-dev sqlite yaml-dev zlib-dev
  ```



  Codex requires unrar to read CBR formatted comic archives. Unrar is often not
  packaged for Linux, but here are some instructions:
  [How to install unrar in Linux](https://www.unixtutorial.org/how-to-install-unrar-in-linux/)

  Unrar as packaged for Alpine Linux v3.14 seems to work on Alpine v3.15+



  Using [Homebrew](https://brew.sh/):

  ```sh
  brew install jpeg libffi libyaml libzip openssl python sqlite unrar webp
  ```



  Windows users are encouraged to use Docker to run Codex, but it will also run
  natively on the Windows Subsystem for Linux.

  Installation instructions are in the <a href="/WINDOWS.md">Native Windows
  Dependencies Installation Document</a>.



  Once you have installed codex, the codex binary should be on your path. To start
  codex, run:

  ```sh
  codex
  ```



  Once installed and running you may navigate to <http://localhost:9810/>





  - Click the hamburger menu ☰ to open the browser settings drawer.
  - Log in as the 'admin' user. The default administrator password is also
    'admin'.
  - Navigate to the Admin Panel by clicking on its link in the browser settings
    drawer after you have logged in.



  The first thing you should do is log in as the admin user and change the admin
  password.

  - Navigate to the Admin Panel as described above.
  - Select the Users tab.
  - Change the admin user's password using the small lock button.
  - You may also change the admin user's name with the edit button.
  - You may create other users and grant them admin privileges by making them
    staff.



  The second thing you will want to do is log in as an Administrator and add one
  or more comic libraries.

  - Navigate to the Admin Panel as described above.
  - Select the Libraries tab in the Admin Panel
  - Add a Library with the "+ LIBRARY" button in the upper left.



  If you forget all your superuser passwords, you may restore the original default
  admin account by running codex with the `CODEX_RESET_ADMIN` environment variable
  set.

  ```sh
  CODEX_RESET_ADMIN=1 codex
  ```

  or, if using Docker:

  ```sh
  docker run -e CODEX_RESET_ADMIN=1 -v host-parent-dir/config:/config ajslater/codex
  ```



  In the Admin Panel you may configure private libraries that are only accessible
  to specific groups.

  A library with _no_ groups is accessible to every user including anonymous
  users.

  A library with _any_ groups is accessible only to users who are in those groups.

  Use the Groups admin panel to create groups and the Users admin panel to add and
  remove users to groups.



  Codex can make groups for libraries that exclude groups of users or exclude
  everyone and include only certain groups of users.



  Codex reads PDF metadata from the filename, PDF metadata fields and also many
  formats of common complex comic metadata if they are embedded in the PDF
  `keywords` field.

  If you decide to include PDFs in your comic library, I recommend taking time to
  rename your files so Codex can find some metadata. Codex recognizes several file
  naming schemes. This one has good results:

  `{series} v{volume} #{issue} {title} ({year}) {ignored}.pdf`

  Complex comic metadata, such as ComicInfo.xml, can be also be embedded in the
  keywords field by using the [comicbox](https://github.com/ajslater/comicbox)
  command line tool. Codex will read this data because it relies on comicbox
  internally. Not many people use comicbox or embedded metadata in PDFs in this
  fashion, so you likely won't find it unless you've added it yourself.



  Codex has a limited number of API endpoints available with API Key Access. The
  API Key is available on the admin/stats tab.





  The default config directory is `config/` directly under the working directory
  you run codex from. You may specify an alternate config directory with the
  environment variable `CODEX_CONFIG_DIR`.

  The config directory contains a file named `hypercorn.toml` where you can
  specify ports and bind addresses. If no `hypercorn.toml` is present Codex copies
  a default one to that directory on startup.

  The default values for the config options are:

  ```toml
  bind = ["0.0.0.0:9810"]
  quick_bind = ["0.0.0.0:9810"]
  root_path = "/codex"
  ```

  The config directory also holds the main sqlite database, the Whoosh search
  index, a Django cache and comic book cover thumbnails.





  - `TIMEZONE` or `TZ` will explicitly set the timezone in long format (e.g.
    `"America/Los Angeles"`). This is useful inside Docker because codex cannot
    automatically detect the host machine's timezone.
  - `CODEX_CONFIG_DIR` will set the path to codex config directory. Defaults to
    `$CWD/config`
  - `CODEX_RESET_ADMIN=1` will reset the admin user and its password to defaults
    when codex starts.
  - `CODEX_FIX_FOREIGN_KEYS=1` will check for and try to repair illegal foreign
    keys on startup.
  - `CODEX_INTEGRITY_CHECK=1` will perform database integrity check on startup.
  - `CODEX_FTS_INTEGRITY_CHECK=1` will perform an integrity check on the full text
    search index.
  - `CODEX_FTS_REBUILD=1` will rebuild the full text search index.
  - `DEBUG_TRANSFORM` will show verbose information about how the comicbox library
    reads all archive metadata sources and transforms it into a the comicbox
    schema.



  - `LOGLEVEL` will change how verbose codex's logging is. Valid values are
    `ERROR`, `WARNING`, `INFO`, `DEBUG`. The default is `INFO`.
  - `CODEX_LOG_DIR` sets a custom directory for saving logfiles. Defaults to
    `$CODEX_CONFIG_DIR/logs`
  - `CODEX_LOG_TO_FILE=0` will not log to files.
  - `CODEX_LOG_TO_CONSOLE=0` will not log to the console.



  Codex contains some experimental throttling controls. The value supplied to
  these variables will be interpreted as the maximum number of allowed requests
  per minute. For example, the following settings would limit each described group
  to 2 queries per second.

  - `CODEX_THROTTLE_ANON=30` Anonymous users
  - `CODEX_THROTTLE_USER=30` Authenticated users
  - `CODEX_THROTTLE_OPDS=30` The OPDS v1 & v2 APIs (Panels uses this for search)
  - `CODEX_THROTTLE_OPENSEARCH=30` The OPDS v1 Opensearch API



  [nginx](https://nginx.org/) is often used as a TLS terminator and subpath proxy.

  Here's an example nginx config with a subpath named '/codex'.

  ```nginx

  proxy_set_header   Host $http_host;
  proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
  proxy_set_header   X-Forwarded-Host $server_name;
  proxy_set_header   X-Forwarded-Port $server_port;
  proxy_set_header   X-Forwarded-Proto $scheme;
  proxy_set_header   X-Real-IP $remote_addr;
  proxy_set_header   X-Scheme $scheme;

  proxy_http_version 1.1;
  proxy_set_header   Upgrade $http_upgrade;

  proxy_set_header Connection "Upgrade" location /codex {
    proxy_pass       http://codex:9810;
    
    
    
    proxy_set_header Authorization "";
  }
  ```

  Specify a reverse proxy sub path (if you have one) in `config/hypercorn.toml`

  ```toml
  root_path = "/codex"
  ```



  Nginx requires a special trick to refresh dns when linked Docker containers
  recreate. See this
  [nginx with dynamix upstreams](https://tenzer.dk/nginx-with-dynamic-upstreams/)
  article.



  Codex can run with as little as 1GB available RAM. Large batch jobs –like
  importing and indexing tens of thousands of comics at once– will run faster the
  more memory is available to Codex. The biggest gains in speed happen when you
  increase memory up to about 6GB. Codex batch jobs do get faster the more memory
  it has above 6GB, but with diminishing returns.

  If you must run Codex in an admin restricted memory environment you might want
  to temporarily give Codex a lot of memory to run a very large import job and
  then restrict it for normal operation.





  Once your administrator has added some comic libraries, you may browse and read
  comics. Codex will remember your preferences, bookmarks and progress in the
  browser session. Codex destroys anonymous sessions and bookmarks after 60 days.
  To preserve these settings across browsers and after sessions expire, you may
  register an account with a username and password. You will have to contact your
  administrator to reset your password if you forget it.



  Codex supports OPDS syndication and OPDS streaming. You may find the OPDS url in
  the side drawer. It should take the form:

  `http(s)://host.tld(:9810)(/root_path)/opds/v1.2/`

  or

  `http(s)://host.tld(:9810)(/root_path)/opds/v2.0/`

  OPDS 2.0 support is experimental and not widely or well supported by clients.
  OPDS 2.0 book readers exist, but I am not yet aware of an OPDS 2.0 comic reader.



  - iOS has [Panels](https://panels.app/), [PocketBooks](https://pocketbook.ch/),
    [KYBook 3](http://kybook-reader.com/), and
    [Chunky Comic Reader](https://apps.apple.com/us/app/chunky-comic-reader/id663567628)
  - Android has
    [Moon+](https://play.google.com/store/apps/details?id=com.flyersoft.moonreader)
    and
    [Librera](https://play.google.com/store/apps/details?id=com.foobnix.pdf.reader)

  Kybook 3 does not seem to support http basic authentication, so Cbbodex users
  are not supported.



  If you wish to access OPDS as your Codex User. You will have to add your
  username and password to the URL. Some OPDS clients do not asssist you with
  authentication. In that case the OPDS url will look like:

  `http(s)://username:password@host.tld(:9810)(/root_path)/opds/v1.2/`





  - [OPDS 1.2](https://specs.opds.io/opds-1.2.html)
  - [OPDS-PSE 1.2](https://github.com/anansi-project/opds-pse/blob/master/v1.2.md)
  - [OPDS Authentication 1.0](https://drafts.opds.io/authentication-for-opds-1.0.html)
  - [OpenSearch 1.1](https://github.com/dewitt/opensearch)



  - [OPDS 2.0 (draft)](https://drafts.opds.io/opds-2.0.html)
  - [OPDS 2.0 Progression (proposal)](https://github.com/opds-community/drafts/discussions/67)





  Codex collects its logs in the `config/logs` directory. Take a look to see what
  th e server is doing.

  You can change how much codex logs by setting the `LOGLEVEL` environment
  variable. By default this level is `INFO`. To see more verbose messages, run
  codex like:

  ```sh
  LOGLEVEL=DEBUG codex
  ```



  Codex tries to watch for filesystem events to instantly update your comic
  libraries when they change on disk. But these native filesystem events are not
  translated between macOS & Windows Docker hosts and the Docker Linux container.
  If you find that your installation is not updating to filesystem changes
  instantly, you might try enabling polling for the affected libraries and
  decreasing the `poll_every` value in the Admin console to a frequency that suits
  you.



  If the database becomes corrupt, Codex includes a facility to rebuild the
  database. Place a file named `rebuild_db` in your Codex config directory like
  so:

  ```sh
  touch config/rebuild_db
  ```

  Shut down and restart Codex.

  The next time Codex starts it will back up the existing database and try to
  rebuild it. The database lives in the config directory as the file
  `config/db.sqlite3`. If this procedure goes kablooey, you may recover the
  original database at `config/backups/codex.sqlite3.before-rebuild`. Codex will
  remove the `rebuild_db` file.





  ```pycon
  packages/django/http/response.py:517: Warning: StreamingHttpResponse must consume synchronous iterators in order to serve them asynchronously. Use an asynchronous iterator instead.
  ```

  This is a known warning and does not represent anything bad happening. It's an
  artifact of the Django framework slowly supporting asynchronous server endpoints
  and unfortunately isn't practical to remove yet.



  - [Kavita](https://www.kavitareader.com/) has light metadata filtering/editing,
    supports comics, eBooks, and features for manga.
  - [Komga](https://komga.org/) has light metadata editing.
  - [Ubooquity](https://vaemendis.net/ubooquity/) reads both comics and eBooks.
  - [Mylar](https://github.com/mylar3/mylar3) is the best comic book manager which
    also has a built in reader.
  - [Comictagger](https://github.com/comictagger/comictagger) is a comic metadata
    editor. It comes with a powerful command line and desktop GUI.





  Issues and feature requests are best filed on the
  [Github issue tracker](https://github.com/ajslater/codex/issues).



  - I have no intention of making this an eBook reader.
  - I think metadata editing would be better placed in a comic manager than a
    reader.



  Codex is a Django Python webserver with a VueJS front end.

  `/codex/codex/` is the main django app which provides the webserver and
  database.

  `/codex/frontend/` is where the vuejs frontend lives.

  Most of Codex development is now controlled through the Makefile. Type `make`
  for a list of commands.



  By the generosity of the good people of
  [Mylar](https://github.com/mylar3/mylar3), I and other Codex users answer
  questions on the [Mylar Discord](https://discord.gg/6UG94R7E8T). Please use the
  `#codex-support` channel to ask for help with Codex.



  - [Docker Image](https://hub.docker.com/r/ajslater/codex)
  - [PyPi Package](https://pypi.org/project/codex/)
  - [GitHub Project](https://github.com/ajslater/codex/)



  - Thanks to [Aurélien Mazurie](https://pypi.org/user/ajmazurie/) for allowing me
    to use the PyPi name 'codex'.
  - To [ProfessionalTart](https://github.com/professionaltart) for providing
    native Windows installation instructions.
  - Thanks to the good people of
    [#mylar](https://github.com/mylar3/mylar3#live-support--conversation) for
    continuous feedback and comic ecosystem education.



  ![These simple people have managed to tap into the spiritual forces that mystics and yogis spend literal lifetimes seeking. I feel... ...I feel...](strange.jpg)


pkgId: 30acf9933a10e415fed46b42dac6d88412f8ca89919a3b79b9981e5cf4659721
name: python-codex
arch: src
version: 1.7.2
epoch: 0
release: 1
summary: A comic archive web server.
url: https://github.com/ajslater/codex
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codex-1.7.2-1.src.rpm
checksum_type: sha256
description:
  A comic archive browser and reader.

  <img src="codex/static_src/img/logo.svg" style="
  height: 128px;
  width: 128px;
  border-radius: 128px;
  " />



  - Codex is a web server.
  - GPLv3 Licenced.
  - Full text search of metadata and bookmarks.
  - Filter and sort on all comic metadata and unread status per user.
  - Browse a tree of Publishers, Imprints, Series, Volumes, or your own folder
    hierarchy, or by tagged Story Arc.
  - Read comics in a variety of aspect ratios and directions that fit your screen.
  - Watches the filesystem and automatically imports new or changed comics.
  - Anonymous browsing and reading or reigistered users only, to your preference.
  - Per user bookmarking & settings, even before you make an account.
  - Private Libraries accessible only to certain groups of users.
  - Reads CBZ, CBR, CBT, and PDF formatted comics.
  - Syndication with OPDS 1 & 2, streaming, search and authentication.
  - Add custom covers to Folders, Publishers, Imprints, Series, and Story Arcs.
  - Runs in 1GB of RAM, faster with more.



  - _Filter by_ Story Arc and Unread, _Order by_ Publish Date to create an event
    reading list.
  - _Filter by_ Unread and _Order by_ Added Time to see your latest unread comics.
  - _Search by_ your favorite character to find their appearances across different
    comics.



  You may browse a [live demo server](https://demo.codex-reader.app/) to get a
  feel for Codex.



  Codex has a <a href="NEWS.md">NEWS file</a> to summarize changes that affect
  users.





  Run the official [Docker Image](https://hub.docker.com/r/ajslater/codex).
  Instructions for running the docker image are on the Docker Hub README. This is
  the recommended way to run Codex.

  You'll then want to read the [Administration](#administration) section of this
  document.



  If you have a [HomeAssistant](https://www.home-assistant.io/) server, Codex can
  be installed with the following steps :

  - Add the `https://github.com/alexbelgium/hassio-addons` repository by
    [clicking here](https://my.home-assistant.io/redirect/supervisor_add_addon_repository/?repository_url=https%3A%2F%2Fgithub.com%2Falexbelgium%2Fhassio-addons)
  - Install the addon :
    [click here to automatically open the addon store, then install the addon](https://my.home-assistant.io/redirect/supervisor)
  - Customize addon options, then then start the add-on.



  You can also run Codex as a natively installed python application with pip.



  You'll need to install the appropriate system dependencies for your platform
  before installing Codex.





  ...and Ubuntu, Mint, MX, Window Subsystem for Linux, and others.

  <!-- eslint-skip -->

  ```sh
  apt install build-essential libimagequant0 libjpeg-turbo8 libopenjp2-7 libssl libyaml-0-2 libtiff6 libwebp7 python3-dev python3-pip mupdf sqlite3 unrar zlib1g
  ```

  Versions of packages like libjpeg, libssl, libtiff may differ between flavors
  and versions of your distribution. If the package versions listed in the example
  above are not available, try searching for ones that are with `apt-cache` or
  `aptitude`.

  <!-- eslint-skip -->

  ```sh
  apt-cache search libjpeg-turbo
  ```



  <!-- eslint-skip -->

  ```sh
  apk add bsd-compat-headers build-base jpeg-dev libffi-dev libwebp openssl-dev sqlite yaml-dev zlib-dev
  ```



  Codex requires unrar to read CBR formatted comic archives. Unrar is often not
  packaged for Linux, but here are some instructions:
  [How to install unrar in Linux](https://www.unixtutorial.org/how-to-install-unrar-in-linux/)

  Unrar as packaged for Alpine Linux v3.14 seems to work on Alpine v3.15+



  Using [Homebrew](https://brew.sh/):

  <!-- eslint-skip -->

  ```sh
  brew install jpeg libffi libyaml libzip openssl python sqlite unrar webp
  ```



  Windows users are encouraged to use Docker to run Codex, but it will also run
  natively on the Windows Subsystem for Linux.

  Installation instructions are in the <a href="/WINDOWS.md">Native Windows
  Dependencies Installation Document</a>.



  Once you have installed codex, the codex binary should be on your path. To start
  codex, run:

  <!-- eslint-skip -->

  ```sh
  codex
  ```



  Once installed and running you may navigate to <http://localhost:9810/>





  - Click the hamburger menu ☰ to open the browser settings drawer.
  - Log in as the 'admin' user. The default administrator password is also
    'admin'.
  - Navigate to the Admin Panel by clicking on its link in the browser settings
    drawer after you have logged in.



  The first thing you should do is log in as the admin user and change the admin
  password.

  - Navigate to the Admin Panel as described above.
  - Select the Users tab.
  - Change the admin user's password using the small lock button.
  - You may also change the admin user's name with the edit button.
  - You may create other users and grant them admin privileges by making them
    staff.



  The second thing you will want to do is log in as an Administrator and add one
  or more comic libraries.

  - Navigate to the Admin Panel as described above.
  - Select the Libraries tab in the Admin Panel
  - Add a Library with the "+ LIBRARY" button in the upper left.



  If you forget all your superuser passwords, you may restore the original default
  admin account by running codex with the `CODEX_RESET_ADMIN` environment variable
  set.

  <!-- eslint-skip -->

  ```sh
  CODEX_RESET_ADMIN=1 codex
  ```

  or, if using Docker:

  <!-- eslint-skip -->

  ```sh
  docker run -e CODEX_RESET_ADMIN=1 -v host-parent-dir/config:/config ajslater/codex
  ```



  In the Admin Panel you may configure private libraries that are only accessible
  to specific groups.

  A library with _no_ groups is accessible to every user including anonymous
  users.

  A library with _any_ groups is accessible only to users who are in those groups.

  Use the Groups admin panel to create groups and the Users admin panel to add and
  remove users to groups.



  Codex can make groups for libraries that exclude groups of users or exclude
  everyone and include only certain groups of users.



  Codex reads PDF metadata from the filename, PDF metadata fields and also many
  formats of common complex comic metadata if they are embedded in the PDF
  `keywords` field.

  If you decide to include PDFs in your comic library, I recommend taking time to
  rename your files so Codex can find some metadata. Codex recognizes several file
  naming schemes. This one has good results:

  `{series} v{volume} #{issue} {title} ({year}) {ignored}.pdf`

  Complex comic metadata, such as ComicInfo.xml, can be also be embedded in the
  keywords field by using the [comicbox](https://github.com/ajslater/comicbox)
  command line tool. Codex will read this data because it relies on comicbox
  internally. Not many people use comicbox or embedded metadata in PDFs in this
  fashion, so you likely won't find it unless you've added it yourself.



  Codex has a limited number of API endpoints available with API Key Access. The
  API Key is available on the admin/stats tab.





  The default config directory is `config/` directly under the working directory
  you run codex from. You may specify an alternate config directory with the
  environment variable `CODEX_CONFIG_DIR`.

  The config directory contains a file named `hypercorn.toml` where you can
  specify ports and bind addresses. If no `hypercorn.toml` is present Codex copies
  a default one to that directory on startup.

  The default values for the config options are:

  <!-- eslint-skip -->

  ```toml
  bind = ["0.0.0.0:9810"]
  quick_bind = ["0.0.0.0:9810"]
  root_path = "/codex"
  ```

  The config directory also holds the main sqlite database, the Whoosh search
  index, a Django cache and comic book cover thumbnails.





  - `TIMEZONE` or `TZ` will explicitly set the timezone in long format (e.g.
    `"America/Los Angeles"`). This is useful inside Docker because codex cannot
    automatically detect the host machine's timezone.
  - `CODEX_CONFIG_DIR` will set the path to codex config directory. Defaults to
    `$CWD/config`
  - `CODEX_RESET_ADMIN=1` will reset the admin user and its password to defaults
    when codex starts.
  - `CODEX_FIX_FOREIGN_KEYS=1` will check for and try to repair illegal foreign
    keys on startup.
  - `CODEX_INTEGRITY_CHECK=1` will perform database integrity check on startup.
  - `CODEX_FTS_INTEGRITY_CHECK=1` will perform an integrity check on the full text
    search index.
  - `CODEX_FTS_REBUILD=1` will rebuild the full text search index.
  - `DEBUG_TRANSFORM` will show verbose information about how the comicbox library
    reads all archive metadata sources and transforms it into a the comicbox
    schema.



  - `LOGLEVEL` will change how verbose codex's logging is. Valid values are
    `ERROR`, `WARNING`, `INFO`, `DEBUG`. The default is `INFO`.
  - `CODEX_LOG_DIR` sets a custom directory for saving logfiles. Defaults to
    `$CODEX_CONFIG_DIR/logs`
  - `CODEX_LOG_TO_FILE=0` will not log to files.
  - `CODEX_LOG_TO_CONSOLE=0` will not log to the console.



  Codex contains some experimental throttling controls. The value supplied to
  these variables will be interpreted as the maximum number of allowed requests
  per minute. For example, the following settings would limit each described group
  to 2 queries per second.

  - `CODEX_THROTTLE_ANON=30` Anonymous users
  - `CODEX_THROTTLE_USER=30` Authenticated users
  - `CODEX_THROTTLE_OPDS=30` The OPDS v1 & v2 APIs (Panels uses this for search)
  - `CODEX_THROTTLE_OPENSEARCH=30` The OPDS v1 Opensearch API



  [nginx](https://nginx.org/) is often used as a TLS terminator and subpath proxy.

  Here's an example nginx config with a subpath named '/codex'.

  <!-- eslint-skip -->

  ```nginx

  proxy_set_header   Host $http_host;
  proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
  proxy_set_header   X-Forwarded-Host $server_name;
  proxy_set_header   X-Forwarded-Port $server_port;
  proxy_set_header   X-Forwarded-Proto $scheme;
  proxy_set_header   X-Real-IP $remote_addr;
  proxy_set_header   X-Scheme $scheme;

  proxy_http_version 1.1;
  proxy_set_header   Upgrade $http_upgrade;

  proxy_set_header Connection "Upgrade" location /codex {
    proxy_pass       http://codex:9810;
    
    
    
    proxy_set_header Authorization "";
  }
  ```

  Specify a reverse proxy sub path (if you have one) in `config/hypercorn.toml`

  <!-- eslint-skip -->

  ```toml
  root_path = "/codex"
  ```



  Nginx requires a special trick to refresh dns when linked Docker containers
  recreate. See this
  [nginx with dynamix upstreams](https://tenzer.dk/nginx-with-dynamic-upstreams/)
  article.



  Codex can run with as little as 1GB available RAM. Large batch jobs –like
  importing and indexing tens of thousands of comics at once– will run faster the
  more memory is available to Codex. The biggest gains in speed happen when you
  increase memory up to about 6GB. Codex batch jobs do get faster the more memory
  it has above 6GB, but with diminishing returns.

  If you must run Codex in an admin restricted memory environment you might want
  to temporarily give Codex a lot of memory to run a very large import job and
  then restrict it for normal operation.





  Once your administrator has added some comic libraries, you may browse and read
  comics. Codex will remember your preferences, bookmarks and progress in the
  browser session. Codex destroys anonymous sessions and bookmarks after 60 days.
  To preserve these settings across browsers and after sessions expire, you may
  register an account with a username and password. You will have to contact your
  administrator to reset your password if you forget it.



  Codex supports OPDS syndication and OPDS streaming. You may find the OPDS url in
  the side drawer. It should take the form:

  `http(s)://host.tld(:9810)(/root_path)/opds/v1.2/`

  or

  `http(s)://host.tld(:9810)(/root_path)/opds/v2.0/`

  OPDS 2.0 support is experimental and not widely or well supported by clients.
  OPDS 2.0 book readers exist, but I am not yet aware of an OPDS 2.0 comic reader.



  - iOS has [Panels](https://panels.app/), [PocketBooks](https://pocketbook.ch/),
    [KYBook 3](http://kybook-reader.com/), and
    [Chunky Comic Reader](https://apps.apple.com/us/app/chunky-comic-reader/id663567628)
  - Android has
    [Moon+](https://play.google.com/store/apps/details?id=com.flyersoft.moonreader)
    and
    [Librera](https://play.google.com/store/apps/details?id=com.foobnix.pdf.reader)

  Kybook 3 does not seem to support http basic authentication, so Cbbodex users
  are not supported.



  If you wish to access OPDS as your Codex User. You will have to add your
  username and password to the URL. Some OPDS clients do not asssist you with
  authentication. In that case the OPDS url will look like:

  `http(s)://username:password@host.tld(:9810)(/root_path)/opds/v1.2/`



  - [OPDS 1.2](https://specs.opds.io/opds-1.2.html)
  - [OPDS-PSE 1.2](https://github.com/anansi-project/opds-pse/blob/master/v1.2.md)
  - [OPDS Authentication 1.0](https://drafts.opds.io/authentication-for-opds-1.0.html)
  - [OpenSearch 1.1](https://github.com/dewitt/opensearch)
  - [OPDS 2.0 (draft)](https://drafts.opds.io/opds-2.0.html)





  Codex collects its logs in the `config/logs` directory. Take a look to see what
  th e server is doing.

  You can change how much codex logs by setting the `LOGLEVEL` environment
  variable. By default this level is `INFO`. To see more verbose messages, run
  codex like:

  <!-- eslint-skip -->

  ```bash
  LOGLEVEL=DEBUG codex
  ```



  Codex tries to watch for filesystem events to instantly update your comic
  libraries when they change on disk. But these native filesystem events are not
  translated between macOS & Windows Docker hosts and the Docker Linux container.
  If you find that your installation is not updating to filesystem changes
  instantly, you might try enabling polling for the affected libraries and
  decreasing the `poll_every` value in the Admin console to a frequency that suits
  you.



  If the database becomes corrupt, Codex includes a facility to rebuild the
  database. Place a file named `rebuild_db` in your Codex config directory like
  so:

  <!-- eslint-skip -->

  ```sh
  touch config/rebuild_db
  ```

  Shut down and restart Codex.

  The next time Codex starts it will back up the existing database and try to
  rebuild it. The database lives in the config directory as the file
  `config/db.sqlite3`. If this procedure goes kablooey, you may recover the
  original database at `config/backups/codex.sqlite3.before-rebuild`. Codex will
  remove the `rebuild_db` file.



  - [Kavita](https://www.kavitareader.com/) has light metadata filtering/editing,
    supports comics, eBooks, and features for manga.
  - [Komga](https://komga.org/) has light metadata editing.
  - [Ubooquity](https://vaemendis.net/ubooquity/) reads both comics and eBooks.
  - [Mylar](https://github.com/mylar3/mylar3) is the best comic book manager which
    also has a built in reader.
  - [Comictagger](https://github.com/comictagger/comictagger) is a comic metadata
    editor. It comes with a powerful command line and desktop GUI.





  Issues and feature requests are best filed on the
  [Github issue tracker](https://github.com/ajslater/codex/issues).



  - I have no intention of making this an eBook reader.
  - I think metadata editing would be better placed in a comic manager than a
    reader.



  Codex is a Django Python webserver with a VueJS front end.

  `/codex/codex/` is the main django app which provides the webserver and
  database.

  `/codex/frontend/` is where the vuejs frontend lives.

  Most of Codex development is now controlled through the Makefile. Type `make`
  for a list of commands.



  By the generosity of the good people of
  [Mylar](https://github.com/mylar3/mylar3), I and other Codex users answer
  questions on the [Mylar Discord](https://discord.gg/6UG94R7E8T). Please use the
  `#codex-support` channel to ask for help with Codex.



  - [Docker Image](https://hub.docker.com/r/ajslater/codex)
  - [PyPi Package](https://pypi.org/project/codex/)
  - [GitHub Project](https://github.com/ajslater/codex/)



  - Thanks to [Aurélien Mazurie](https://pypi.org/user/ajmazurie/) for allowing me
    to use the PyPi name 'codex'.
  - To [ProfessionalTart](https://github.com/professionaltart) for providing
    native Windows installation instructions.
  - Thanks to the good people of
    [#mylar](https://github.com/mylar3/mylar3#live-support--conversation) for
    continuous feedback and comic ecosystem education.



  ![These simple people have managed to tap into the spiritual forces that mystics and yogis spend literal lifetimes seeking. I feel... ...I feel...](strange.jpg)


pkgId: 35d3d5b9a017b92f11e5fb15c5e119a4e19c91a84330fe3975984426009b1eeb
name: python-codex-engine-pyqt
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: A universal translator for serial devices.
url: https://github.com/Codex-Engine/codex-engine-pyqt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codex-engine-pyqt-0.3.1-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/pypi/l/codex-engine-pyqt.svg)](./LICENSE)
  [![pypi version](https://img.shields.io/pypi/v/codex-engine-pyqt.svg)](https://pypi.org/project/codex-engine-pyqt/)
  [![PyPI status](https://img.shields.io/pypi/status/codex-engine-pyqt.svg)](https://github.com/DaelonSuzuka/codex-engine-pyqt/)

  A universal translator for serial devices.



  This is the reference implementation of Codex, a framework for managing serial communication with physical devices.


  - serial port detection
  - automatic handshaking
  - device profiles as drop-in plugins
  - supports many styles of serial communication
  - extensible



  `pip install codex-engine-pyqt`


  - pyserial
  - PyQt5 or PySide2

rpm_license:
  MIT License  Copyright (c) 2021 Codex-Engine  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: b6d03b46f7c5570dae32fb07374d10ed5ca526b9e3ae44c4c1ef817038c16f6a
name: python-codex-of-the-damned
arch: src
version: 1.81
epoch: 0
release: 1
summary: Website on VTES Strategy, cards rulings and TWD search interface
url: https://codex-of-the-damned.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codex-of-the-damned-1.81-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/codex-of-the-damned.svg)](https://badge.fury.io/py/codex-of-the-damned)
  [![Validation](https://github.com/lionel-panhaleux/codex-of-the-damned/actions/workflows/validation.yaml/badge.svg)](https://github.com/lionel-panhaleux/codex-of-the-damned/actions)
  [![Python version](https://img.shields.io/badge/python-3.11-blue)](https://www.python.org/downloads/)
  [![License](https://img.shields.io/badge/License-MIT-blue)](https://opensource.org/licenses/MIT)
  [![Code Style](https://img.shields.io/badge/code%20style-black-black)](https://github.com/psf/black)

  This site is a compilation of Vampire: the Eternal Struggle strategy resources.
  The site is publicly available at [codex-of-the-damned.org](http://www.codex-of-the-damned.org).

  Portions of the materials are the copyrights and trademarks of Paradox Interactive AB,
  and are used with permission. All rights reserved.
  For more information please visit [www.worldofdarkness.com](http://www.worldofdarkness.com.).

  ![Dark Pack](codex_of_the_damned/static/img/dark-pack.png)



  Contributions are welcome. Pull Requests will be merged if they respect the general style.
  Issues will be dealt with as quickly as possible.

  This site uses [Flask](https://flask.palletsprojects.com) and [Babel](http://babel.pocoo.org)
  to generate pages dynamically and handle internationalisation.




  To install a working developpment version of the site, use `pip`:

  ```bash
  python3 -m venv venv
  pip install -e ".[dev]"
  ```



  Install a PO editor like [POEdit](https://poedit.net), call the following command
  to generate the messages in the language you're interested in:

  ```bash
  BABEL_LANG=es make po-update
  ```

  Then open the generated catalog file,
  `codex_of_the_damned/translations/es/LC_MESSAGES/messages.po`, in your PO editor.


  While translating, beware to keep the `HTML` tags like `<p>`, `<em>` as they are,
  and make sure you keep the exact same format parameters in the translated text.
  They include anything dynamic, from disciplines like `s` and clans like
  `s`, to cards like `s` and external urls like ``.


  Once you're done translating, generate the translation files with:

  ```bash
  make po
  ```

  To make a new language accessible in the website, you simply have to add the matching
  line in the translation `nav` header of the global layout
  `codex_of_the_damned/templates/layout.html`:

  ```html
  <nav role="translation">
      {{ translation('en', "🇬🇧") }}
      {{ translation('fr', "🇫🇷") }}
  </nav>
  ```



  You can run the development version of the site using the `codex` entrypoint:

  ```bash
  $ codex
   * Serving Flask app "codex_of_the_damned" (lazy loading)
   * Environment: production
     WARNING: This is a development server. Do not use it in a production deployment.
     Use a production WSGI server instead.
   * Debug mode: off
   * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
  ```

  You can set the `DEBUG` environment variable to activate the debug mode:

  ```bash
  DEBUG=1 codex
  ```



  To run the production server, you'll need a web server like
  [uWSGI](https://uwsgi-docs.readthedocs.io):

  ```bash
  uwsgi --module codex_of_the_damned:app
  ```

  or [Gunicorn](https://gunicorn.org):

  ```bash
  gunicorn codex_of_the_damned:app
  ```





  Convert icons from raster to SVG using `imagemagick` and `potrace`,
  depending on the icon, smoothing may be better or not:

  ```bash
  convert -morphology Smooth Octagon:2 clan-ahrimanes.gif clan-ahrimanes.svg
  ```



  Use [POEdit](https://poedit.net) and [Google Translate](https://translate.google.com) to help with translations.

  Run `make po` to build the translation files under `codex-of-the-damned/translations`,
  edit them with [POEdit](https://poedit.net), then run `make po` when you're done to streamline them.


pkgId: df1d1cc65895a7cbee89959c076a7b06af6da0cd12083525b82646c5a8cb0aae
name: python-codexec
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: compiles and executes code files written in c, cpp, java, python and javascript
url: https://pypi.org/project/codexec/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codexec-0.1.10-1.src.rpm
checksum_type: sha256
description:
  codexec is a Python package that allows you to execute code written in various programming languages (C, C++, Java, Python, and JavaScript) by making API calls to a server. The package takes code files and optional input files, executes the code, and returns the output.



  - Execute code in multiple languages: C, C++, Java, Python, and JavaScript.
  - Simple command-line interface (CLI) for executing code files.
  - Supports optional input files for code that requires input.



  1. **Install the package**:

     You can install the `codexec` package using `pip`:

     ```bash
     pip install codexec
     ```

  2. **Basic Usage**:

     You can run the `codexec` command in your terminal to execute code files.

     Example of executing a Python file:

     ```bash
     codexec path/to/your/code.py
     ```

  3. **With Input File**:

     If your code requires input, you can specify an input file:

     ```bash
     codexec path/to/your/code.py -i path/to/input.txt
     ```

  4. **Supported Languages**:

     - `C` (.c)
     - `C++` (.cpp)
     - `Java` (.java)
     - `Python` (.py)
     - `JavaScript` (.js)



  Uses [codehelp.in](https://www.codehelp.in/quick-compiler) API under the hood.

  > [credits](https://github.com/thepranaygupta/codehelp-compiler)

rpm_license:
  MIT License  Copyright (c) 2024 Prajesh Pratap Singh  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: f15963ee4dea75e8cee765c8b942b49bd822dc1e76aa57df4f2b6c89845ce509
name: python-codext
arch: src
version: 1.15.4
epoch: 0
release: 1
summary: Native codecs extension
url: https://pypi.org/project/codext/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codext-1.15.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center"><img src="https://github.com/dhondta/python-codext/raw/main/docs/pages/img/logo.png"></p>
  <h1 align="center">CodExt <a href="https://twitter.com/intent/tweet?text=CodExt%20-%20Encoding%2Fdecoding%20anything.%0D%0APython%20library%20extending%20the%20native%20codecs%20library%20with%20many%20new%20encodings%20and%20providing%20CLI%20tools%20with%20a%20guess%20feature%20based%20on%20AI.%0D%0Ahttps%3a%2f%2fgithub%2ecom%2fdhondta%2fpython-codext%0D%0A&hashtags=python,programming,encodings,codecs,cryptography,morse,base,ctftools"><img src="https://img.shields.io/badge/Tweet--lightgrey?logo=twitter&style=social" alt="Tweet" height="20"/></a></h1>
  <h3 align="center">Encode/decode anything.</h3>

  [![PyPi](https://img.shields.io/pypi/v/codext.svg)](https://pypi.python.org/pypi/codext/)
  [![Read The Docs](https://readthedocs.org/projects/python-codext/badge/?version=latest)](https://python-codext.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://github.com/dhondta/python-codext/actions/workflows/python-package.yml/badge.svg)](https://github.com/dhondta/python-codext/actions/workflows/python-package.yml)
  [![Coverage Status](https://raw.githubusercontent.com/dhondta/python-codext/main/docs/coverage.svg)](#)
  [![Python Versions](https://img.shields.io/pypi/pyversions/codext.svg)](https://pypi.python.org/pypi/codext/)
  [![Known Vulnerabilities](https://snyk.io/test/github/dhondta/python-codext/badge.svg?targetFile=requirements.txt)](https://snyk.io/test/github/dhondta/python-codext?targetFile=requirements.txt)
  [![DOI](https://zenodo.org/badge/236679865.svg)](https://zenodo.org/badge/latestdoi/236679865)
  [![License](https://img.shields.io/pypi/l/codext.svg)](https://pypi.python.org/pypi/codext/)

  [**CodExt**](https://github.com/dhondta/python-codext) is a (Python2-3 compatible) library that extends the native [`codecs`](https://docs.python.org/3/library/codecs.html) library (namely for adding new custom encodings and character mappings) and provides **120+ new codecs**, hence its name combining *CODecs EXTension*. It also features a **guess mode** for decoding multiple layers of encoding and **CLI tools** for convenience.

  ```sh
  $ pip install codext
  ```

  Want to contribute a new codec ?    |     Want to contribute a new macro ?
  :----------------------------------:|:------------------------------------:
  Check the [documentation](https://python-codext.readthedocs.io/en/latest/howto.html) first<br>Then [PR](https://github.com/dhondta/python-codext/pulls) your new codec | [PR](https://github.com/dhondta/python-codext/pulls) your updated version of [`macros.json`](https://github.com/dhondta/python-codext/blob/main/codext/macros.json)



  <p align="center"><img src="https://raw.githubusercontent.com/dhondta/python-codext/main/docs/pages/demos/using-codext.gif" alt="Using CodExt from the command line"></p>
  <p align="center"><img src="https://raw.githubusercontent.com/dhondta/python-codext/main/docs/pages/demos/using-bases.gif" alt="Using base tools from the command line"></p>
  <p align="center"><img src="https://raw.githubusercontent.com/dhondta/python-codext/main/docs/pages/demos/using-unbase.gif" alt="Using the unbase command line tool"></p>



  ```session
  $ codext -i test.txt encode dna-1
  GTGAGCGGGTATGTGA

  $ echo -en "test" | codext encode morse
  - . ... -

  $ echo -en "test" | codext encode braille
  ⠞⠑⠎⠞

  $ echo -en "test" | codext encode base100
  👫👜👪👫
  ```



  ```sh
  $ echo -en "Test string" | codext encode reverse
  gnirts tseT

  $ echo -en "Test string" | codext encode reverse morse
  --. -. .. .-. - ... / - ... . -

  $ echo -en "Test string" | codext encode reverse morse dna-2
  AGTCAGTCAGTGAGAAAGTCAGTGAGAAAGTGAGTGAGAAAGTGAGTCAGTGAGAAAGTCAGAAAGTGAGTGAGTGAGAAAGTTAGAAAGTCAGAAAGTGAGTGAGTGAGAAAGTGAGAAAGTC

  $ echo -en "Test string" | codext encode reverse morse dna-2 octal
  101107124103101107124103101107124107101107101101101107124103101107124107101107101101101107124107101107124107101107101101101107124107101107124103101107124107101107101101101107124103101107101101101107124107101107124107101107124107101107101101101107124124101107101101101107124103101107101101101107124107101107124107101107124107101107101101101107124107101107101101101107124103

  $ echo -en "AGTCAGTCAGTGAGAAAGTCAGTGAGAAAGTGAGTGAGAAAGTGAGTCAGTGAGAAAGTCAGAAAGTGAGTGAGTGAGAAAGTTAGAAAGTCAGAAAGTGAGTGAGTGAGAAAGTGAGAAAGTC" | codext -d dna-2 morse reverse
  test string
  ```



  ```sh
  $ codext add-macro my-encoding-chain gzip base63 lzma base64

  $ codext list macros
  example-macro, my-encoding-chain

  $ echo -en "Test string" | codext encode my-encoding-chain
  CQQFAF0AAIAAABuTgySPa7WaZC5Sunt6FS0ko71BdrYE8zHqg91qaqadZIR2LafUzpeYDBalvE///ug4AA==

  $ codext remove-macro my-encoding-chain

  $ codext list macros
  example-macro
  ```



  ```session
  $ echo "Test string !" | base122
  *.7!ft9�-f9Â

  $ echo "Test string !" | base91
  "ONK;WDZM%Z%xE7L

  $ echo "Test string !" | base91 | base85
  B2P|BJ6A+nO(j|-cttl%

  $ echo "Test string !" | base91 | base85 | base36 | base58-flickr
  QVx5tvgjvCAkXaMSuKoQmCnjeCV1YyyR3WErUUErFf

  $ echo "Test string !" | base91 | base85 | base36 | base58-flickr | base58-flickr -d | base36 -d | base85 -d | base91 -d
  Test string !
  ```

  ```session
  $ echo "Test string !" | base91 | base85 | base36 | base58-flickr | unbase -m 3
  Test string !

  $ echo "Test string !" | base91 | base85 | base36 | base58-flickr | unbase -f Test
  Test string !
  ```



  Getting the list of available codecs:

  ```python
  >>> import codext

  >>> codext.list()
  ['ascii85', 'base85', 'base100', 'base122', ..., 'tomtom', 'dna', 'html', 'markdown', 'url', 'resistor', 'sms', 'whitespace', 'whitespace-after-before']

  >>> codext.encode("this is a test", "base58-bitcoin")
  'jo91waLQA1NNeBmZKUF'

  >>> codext.encode("this is a test", "base58-ripple")
  'jo9rA2LQwr44eBmZK7E'

  >>> codext.encode("this is a test", "base58-url")
  'JN91Wzkpa1nnDbLyjtf'

  >>> codecs.encode("this is a test", "base100")
  '👫👟👠👪🐗👠👪🐗👘🐗👫👜👪👫'

  >>> codecs.decode("👫👟👠👪🐗👠👪🐗👘🐗👫👜👪👫", "base100")
  'this is a test'

  >>> for i in range(8):
          print(codext.encode("this is a test", "dna-%d" % (i + 1)))
  GTGAGCCAGCCGGTATACAAGCCGGTATACAAGCAGACAAGTGAGCGGGTATGTGA
  CTCACGGACGGCCTATAGAACGGCCTATAGAACGACAGAACTCACGCCCTATCTCA
  ACAGATTGATTAACGCGTGGATTAACGCGTGGATGAGTGGACAGATAAACGCACAG
  AGACATTCATTAAGCGCTCCATTAAGCGCTCCATCACTCCAGACATAAAGCGAGAC
  TCTGTAAGTAATTCGCGAGGTAATTCGCGAGGTAGTGAGGTCTGTATTTCGCTCTG
  TGTCTAACTAATTGCGCACCTAATTGCGCACCTACTCACCTGTCTATTTGCGTGTC
  GAGTGCCTGCCGGATATCTTGCCGGATATCTTGCTGTCTTGAGTGCGGGATAGAGT
  CACTCGGTCGGCCATATGTTCGGCCATATGTTCGTCTGTTCACTCGCCCATACACT
  >>> codext.decode("GTGAGCCAGCCGGTATACAAGCCGGTATACAAGCAGACAAGTGAGCGGGTATGTGA", "dna-1")
  'this is a test'

  >>> codecs.encode("this is a test", "morse")
  '- .... .. ... / .. ... / .- / - . ... -'

  >>> codecs.decode("- .... .. ... / .. ... / .- / - . ... -", "morse")
  'this is a test'

  >>> with open("morse.txt", 'w', encoding="morse") as f:
  	f.write("this is a test")
  14

  >>> with open("morse.txt",encoding="morse") as f:
  	f.read()
  'this is a test'

  >>> codext.decode("""
        =
                X
     :
        x
    n
      r
          y
        Y
                y
       p
           a
   `
              n
            |
    a
  o
         h
            `
            g
             o
     z      """, "whitespace-after+before")
  'CSC{not_so_invisible}'

  >>> print(codext.encode("An example test string", "baudot-tape"))
  ***.**
     . *
  ***.*
  *  .
     .*
  *  .*
     . *
  ** .*
  ***.**
  ** .**
     .*
  *  .
  * *. *
     .*
  * *.
  * *. *
  *  .
  * *.
  * *. *
  ***.
    *.*
  ***.*
   * .*
  ```





  - [X] `base1`: useless, but for the sake of completeness
  - [X] `base2`: simple conversion to binary (with a variant with a reversed alphabet)
  - [X] `base3`: conversion to ternary (with a variant with a reversed alphabet)
  - [X] `base4`: conversion to quarternary (with a variant with a reversed alphabet)
  - [X] `base8`: simple conversion to octal (with a variant with a reversed alphabet)
  - [X] `base10`: simple conversion to decimal
  - [X] `base11`: conversion to digits with a "*a*"
  - [X] `base16`: simple conversion to hexadecimal (with a variant holding an alphabet with digits and letters inverted)
  - [X] `base26`: conversion to alphabet letters
  - [X] `base32`: classical conversion according to the RFC4648 with all its variants ([zbase32](https://philzimmermann.com/docs/human-oriented-base-32-encoding.txt), extended hexadecimal, [geohash](https://en.wikipedia.org/wiki/Geohash), [Crockford](https://www.crockford.com/base32.html))
  - [X] `base36`: [Base36](https://en.wikipedia.org/wiki/Base36) conversion to letters and digits (with a variant inverting both groups)
  - [X] `base45`: [Base45](https://datatracker.ietf.org/doc/html/draft-faltstrom-base45-04.txt) DRAFT algorithm (with a variant inverting letters and digits)
  - [X] `base58`: multiple versions of [Base58](https://en.bitcoinwiki.org/wiki/Base58) (bitcoin, flickr, ripple)
  - [X] `base62`: [Base62](https://en.wikipedia.org/wiki/Base62) conversion to lower- and uppercase letters and digits (with a variant with letters and digits inverted)
  - [X] `base63`: similar to `base62` with the "`_`" added
  - [X] `base64`: classical conversion according to RFC4648 with its variant URL (or *file*) (it also holds a variant with letters and digits inverted)
  - [X] `base67`: custom conversion using some more special characters (also with a variant with letters and digits inverted)
  - [X] `base85`: all variants of Base85 ([Ascii85](https://fr.wikipedia.org/wiki/Ascii85), [z85](https://rfc.zeromq.org/spec/32), [Adobe](https://dencode.com/string/ascii85), [(x)btoa](https://dencode.com/string/ascii85), [RFC1924](https://datatracker.ietf.org/doc/html/rfc1924), [XML](https://datatracker.ietf.org/doc/html/draft-kwiatkowski-base85-for-xml-00))
  - [X] `base91`: [Base91](http://base91.sourceforge.net) custom conversion
  - [X] `base100` (or *emoji*): [Base100](https://github.com/AdamNiederer/base100) custom conversion
  - [X] `base122`: [Base100](http://blog.kevinalbs.com/base122) custom conversion
  - [X] `base-genericN`: see [base encodings](https://python-codext.readthedocs.io/en/latest/enc/base.html) ; supports any possible base

  This category also contains `ascii85`, `adobe`, `[x]btoa`, `zeromq` with the `base85` codec.



  - [X] `baudot`: supports CCITT-1, CCITT-2, EU/FR, ITA1, ITA2, MTK-2 (Python3 only), UK, ...
  - [X] `baudot-spaced`: variant of `baudot` ; groups of 5 bits are whitespace-separated
  - [X] `baudot-tape`: variant of `baudot` ; outputs a string that looks like a perforated tape
  - [X] `bcd`: _Binary Coded Decimal_, encodes characters from their (zero-left-padded) ordinals
  - [X] `bcd-extended0`: variant of `bcd` ; encodes characters from their (zero-left-padded) ordinals using prefix bits `0000`
  - [X] `bcd-extended1`: variant of `bcd` ; encodes characters from their (zero-left-padded) ordinals using prefix bits `1111`
  - [X] `excess3`: uses Excess-3 (aka Stibitz code) binary encoding to convert characters from their ordinals
  - [X] `gray`: aka reflected binary code
  - [X] `manchester`: XORes each bit of the input with `01`
  - [X] `manchester-inverted`: variant of `manchester` ; XORes each bit of the input with `10`
  - [X] `rotateN`: rotates characters by the specified number of bits (*N* belongs to [1, 7] ; Python 3 only)



  - [X] `a1z26`: keeps words whitespace-separated and uses a custom character separator
  - [X] `cases`: set of case-related encodings (including camel-, kebab-, lower-, pascal-, upper-, snake- and swap-case, slugify, capitalize, title)
  - [X] `dummy`: set of simple encodings (including integer, replace, reverse, word-reverse, substite and strip-spaces)
  - [X] `octal`: dummy octal conversion (converts to 3-digits groups)
  - [X] `octal-spaced`: variant of `octal` ; dummy octal conversion, handling whitespace separators
  - [X] `ordinal`: dummy character ordinals conversion (converts to 3-digits groups)
  - [X] `ordinal-spaced`: variant of `ordinal` ; dummy character ordinals conversion, handling whitespace separators



  - [X] `gzip`: standard Gzip compression/decompression
  - [X] `lz77`: compresses the given data with the algorithm of Lempel and Ziv of 1977
  - [X] `lz78`: compresses the given data with the algorithm of Lempel and Ziv of 1978
  - [X] `pkzip_deflate`: standard Zip-deflate compression/decompression
  - [X] `pkzip_bzip2`: standard BZip2 compression/decompression
  - [X] `pkzip_lzma`: standard LZMA compression/decompression

  > :warning: Compression functions are of course definitely **NOT** encoding functions ; they are implemented for leveraging the `.encode(...)` API from `codecs`.



  - [X] `affine`: aka Affine Cipher
  - [X] `atbash`: aka Atbash Cipher
  - [X] `bacon`: aka Baconian Cipher
  - [X] `barbie-N`: aka Barbie Typewriter (*N* belongs to [1, 4])
  - [X] `citrix`: aka Citrix CTX1 password encoding
  - [X] `railfence`: aka Rail Fence Cipher
  - [X] `rotN`: aka Caesar cipher (*N* belongs to [1,25])
  - [X] `scytaleN`: encrypts using the number of letters on the rod (*N* belongs to [1,[)
  - [X] `shiftN`: shift ordinals (*N* belongs to [1,255])
  - [X] `xorN`: XOR with a single byte (*N* belongs to [1,255])

  > :warning: Crypto functions are of course definitely **NOT** encoding functions ; they are implemented for leveraging the `.encode(...)` API from `codecs`.



  - [X] `blake`: includes BLAKE2b and BLAKE2s (Python 3 only ; relies on `hashlib`)
  - [X] `checksums`: includes Adler32 and CRC32 (relies on `zlib`)
  - [X] `crypt`: Unix's crypt hash for passwords (Python 3 and Unix only ; relies on `crypt`)
  - [X] `md`: aka Message Digest ; includes MD4 and MD5 (relies on `hashlib`)
  - [X] `sha`: aka Secure Hash Algorithms ; includes SHA1, 224, 256, 384, 512 (Python2/3) but also SHA3-224, -256, -384 and -512 (Python 3 only ; relies on `hashlib`)
  - [X] `shake`: aka SHAKE hashing (Python 3 only ; relies on `hashlib`)

  > :warning: Hash functions are of course definitely **NOT** encoding functions ; they are implemented for convenience with the `.encode(...)` API from `codecs` and useful for chaning codecs.



  - [X] `braille`: well-known braille language (Python 3 only)
  - [X] `ipsum`: aka lorem ipsum
  - [X] `galactic`: aka galactic alphabet or Minecraft enchantment language (Python 3 only)
  - [X] `leetspeak`: based on minimalistic elite speaking rules
  - [X] `morse`: uses whitespace as a separator
  - [X] `navajo`: only handles letters (not full words from the Navajo dictionary)
  - [X] `radio`: aka NATO or radio phonetic alphabet
  - [X] `southpark`: converts letters to Kenny's language from Southpark (whitespace is also handled)
  - [X] `southpark-icase`: case insensitive variant of `southpark`
  - [X] `tap`: converts text to tap/knock code, commonly used by prisoners
  - [X] `tomtom`: similar to `morse`, using slashes and backslashes



  - [X] `dna`: implements the 8 rules of DNA sequences (N belongs to [1,8])
  - [X] `letter-indices`: encodes consonants and/or vowels with their corresponding indices
  - [X] `markdown`: unidirectional encoding from Markdown to HTML



  - [X] `hexagram`: uses Base64 and encodes the result to a charset of [I Ching hexagrams](https://en.wikipedia.org/wiki/Hexagram_%28I_Ching%29) (as implemented [here](https://github.com/qntm/hexagram-encode))
  - [X] `klopf`: aka Klopf code ; Polybius square with trivial alphabetical distribution
  - [X] `resistor`: aka resistor color codes
  - [X] `rick`: aka Rick cipher (in reference to Rick Astley's song "*Never gonna give you up*")
  - [X] `sms`: also called _T9 code_ ; uses "`-`" as a separator for encoding, "`-`" or "`_`" or whitespace for decoding
  - [X] `whitespace`: replaces bits with whitespaces and tabs
  - [X] `whitespace_after_before`: variant of `whitespace` ; encodes characters as new characters with whitespaces before and after according to an equation described in the codec name (e.g. "`whitespace+2*after-3*before`")



  - [X] `html`: implements entities according to [this reference](https://dev.w3.org/html5/html-author/charref)
  - [X] `url`: aka URL encoding

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


pkgId: 626dad4513c30f0cfe46ffe0024bd690dde87759ecb400e953b1ddfd58b7e099
name: python-codiac
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: CoDIAC: Comprehensive Domain Interface Anlysis of Contacts
url: https://github.com/NaegleLab/CoDIAC
rpm_license: GNU General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codiac-0.1.0-1.src.rpm
checksum_type: sha256
description:
  This is the source code for CoDIAC, an open source Python toolkit for harnessing InterPro, Uniprot, PDB, and AlphaFold for generating references of proteins containing domains of interest and analyzing the contacts that exist between that domain and other regions of interest.


pkgId: efc5589b1b6e5c7e987f99d65aeeddf07e6bfb7814f1303df1e19ce6130204ed
name: python-codingnow
arch: src
version: 0.1.26
epoch: 0
release: 1
summary: A simple example Python package
url: https://github.com/cflab2017/codingnow_py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codingnow-0.1.26-1.src.rpm
checksum_type: sha256
description:
  CodingNow

  pip install setuptools wheel twine


  python setup.py sdist bdist_wheel


  twine upload dist/*
  twine upload --verbose dist/*


  pip install codingnow --upgrade


  add background
  add level control


  add draw mouse position
  add effect for game-over


  bug fix gameover


  x,y mouse position clipboard


  add mouse left-click (x,y mouse position clipboard)
  add weapon


  add led control learning


  add image player-level
  add change jump value



  add pip auto install



  add up using left, right


  Add background per level


  change led ctrl


  change led ctrl (key)


  modify img load delay (platfomr)


  disable debug-print


  monster move


  monster move

  add hp


pkgId: 1db3f9b8c10cdda8e13e6fe41a46d71b8296fd185a6acafdef90e9c0ae45bfc7
name: python-codrone-simulator
arch: src
version: 0.2.2
epoch: 0
release: 1
url: https://pypi.org/project/codrone-simulator/
rpm_license: CC-BY-ND-4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-codrone-simulator-0.2.2-1.src.rpm
checksum_type: sha256
summary:
  A Python package for simulating drone operations and learning drone programming in a virtual environment.

description:
  - Simulate drone commands in a virtual environment.
  - Compatible with Python and Blocky-to-Python conversions.


pkgId: f4596127a2cbb5f67279db7fba049b8eee109aceeda6d13e5e8f546b0459c095
name: python-coeusfactory
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A Database Connector interface that follows a factory model pattern.
url: https://github.com/mamerisawesome/coeusfactory
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coeusfactory-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/coeusfactory)](https://pypi.python.org/pypi/coeusfactory/)
  [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/mamerisawesome/coeusfactory/graphs/commit-activity)
  [![Coverage](https://raw.githubusercontent.com/mamerisawesome/coeusfactory/master/assets/coverage.svg?sanitize=true)](https://github.com/mamerisawesome/coeusfactory)
  [![Awesome Badges](https://img.shields.io/badge/badges-awesome-green.svg)](https://github.com/Naereen/badges)

  A Database Connector interface that follows a factory model pattern.



  ```bash


  poetry add coeusfactory


  pip install coeusfactory
  ```

  Then add necessary database interfaces as necessary. Below are the libraries that works with Coeus Factory.

  | Database | Python Library | Status            |
  |----------|----------------|-------------------|
  | **MongoDB**  | *pymongo*      | ![Passed unit tests](https://img.shields.io/static/v1?label=&message=Passed%20unit%20tests&color=green) |
  | **DynamoDB** | *boto3*        | ![Needs unit tests](https://img.shields.io/static/v1?label=&message=Needs%20unit%20tests&color=yellow) |



  For every first step for any database, initialization and connections will come first. As long as it is supported in the factory, you can pass the parameters you normally handle in supported databse interfaces.

  ```python
  from coeusfactory import ConnectorFactory
  cf = ConnectorFactory(
      interface="<database>",
      db="<database-name>"
      
      username="",
      password=""
  )


  cf.handler.initialize()
  cf.handler.connect()
  ```





  ```python
  Users = cf.get_model("Users")
  Carts = cf.get_model("Carts")
  CustomerReviews = cf.get_model("CustomerReviews")
  ```



  ```python
  Users.get_by_id(0)
  Users.get({"name": "Test User"})
  ```



  ```python
  Users.add({"name": "Test User"})
  ```



  ```python
  Users.delete_by_id(0)
  Users.delete({"name": "Test User"})
  ```



  ```python
  Users.update_by_id(0, {"name": "New Name"})
  Users.update({"name": "Test User"}, {"name": "New Name"})
  ```



  ```python
  Users.count()
  ```



  Almer Mendoza
  [![Ask Me Anything !](https://img.shields.io/badge/Ask%20me-anything-1abc9c.svg)](mailto:atmalmer23@gmail.com)

  [![ForTheBadge built-with-love](http://ForTheBadge.com/images/badges/built-with-love.svg)](https://GitHub.com/Naereen/)
  [![forthebadge](https://forthebadge.com/images/badges/powered-by-responsibility.svg)](https://forthebadge.com)
  [![forthebadge](https://forthebadge.com/images/badges/kinda-sfw.svg)](https://forthebadge.com)


pkgId: 3955dcc281db1ebc731e78332aea2edfac4aa2cdb56bbfb934015ac4e9a18108
name: python-cofactr
arch: src
version: 5.38.0
epoch: 0
release: 1
summary: Client library for accessing Cofactr data.
url: https://github.com/Cofactr/cofactr-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cofactr-5.38.0-1.src.rpm
checksum_type: sha256
description:
  Python client library for accessing Cofactr.



  ```python
  from typing import List
  from cofactr.graph import GraphAPI


  from cofactr.schema.flagship.part import Part

  graph = GraphAPI(client_id=..., api_key=...)

  part_res = graph.get_product(id="IM60640MOX6H")
  part: Part = part_res["data"]

  parts_res = graph.get_products(query="esp32")
  parts: List[Part] = parts_res["data"]
  ```


pkgId: fff6b4eb72f69e83c652973d6e0ff403ccbd2dbf1e586c8601bf6849d2b6879e
name: python-coffe
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Python wrapper for the COrrelation Function Full-sky Estimator code
url: https://pypi.org/project/coffe/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coffe-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This is the public repository for the code COFFE (COrrelation Function Full-sky Estimator), which can be used to compute the following quantities in linear perturbation theory:

  * full-sky and flat-sky 2-point correlation function (2PCF) of galaxy number counts, taking into account all of the effects (density, RSD, lensing, etc.)
  * full-sky and flat-sky multipoles of the 2PCF
  * redshift-averaged multipoles of the 2PCF
  * flat-sky Gaussian covariance matrix of the multipoles of the 2PCF
  * flat-sky Gaussian covariance matrix of the redshift-averaged multipoles of the 2PCF

  The relevant theoretical papers are:

  * [The full-sky relativistic correlation function and power spectrum of galaxy number counts: I. Theoretical aspects, arXiv:1708.00492](https://arxiv.org/abs/1708.00492)
  * [COFFE: a code for the full-sky relativistic galaxy correlation function, arXiv:1806.11090](https://arxiv.org/abs/1806.11090)
  * [The flat-sky approximation to galaxy number counts - redshift space correlation function, arXiv:2011.01878](https://arxiv.org/abs/2011.01878)





  If you are on Linux or MacOS, the latest version of COFFE can be installed using:

  ```sh
  pip install coffe
  ```

  Note that Windows is not officially supported.

  If you wish to install the development version of COFFE, please refer to the section below.



  **NOTE**: the use of a virtual environment (such as Python's [venv](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/#creating-a-virtual-environment)) is highly recommended.



  If you would like to install the development version, you will need to first have the following:

  * a C compiler, compatible with the C99 standard
  * a Python interpreter, version 3.8 or above
  * [GSL](https://www.gnu.org/software/gsl/) (GNU Scientific Library) and the corresponding headers, version 2.1 or above (available as `libgsl-dev` on Debian-based, and as `gsl-devel` on RHEL/CentOS-based distros)
  * [FFTW](http://www.fftw.org/download.html) and the corresponding headers, version 3 or above (available as `libfftw3-dev` on Debian-based, and as `fftw-devel` on RHEL/CentOS-based distros)
  * [libconfig](http://hyperrealm.github.io/libconfig/)

  Then clone this repository:

  ```sh
  git clone https://github.com/JCGoran/coffe
  ```

  then change directory to it:

  ```sh
  cd coffe
  ```



  Run the script:

  ```sh
  bash scripts/install_other.sh gsl fftw libconfig
  ```



  Run the following command:

  ```sh
  sudo apt install libgsl-dev libfftw3-dev libconfig-dev
  ```

  and follow the instructions from the prompt.



  You can install the necessary prerequisites using Homebrew:

  ```sh
  brew install gsl fftw libconfig
  ```

  **NOTE**: as a technical aside, Homebrew-installed packages (whether installed as pre-build binaries or from source) are built for the current version of your operating system. This means that they **CANNOT** be used to create a redistributable Python wheel, i.e. a wheel that works on any older version of MacOS.



  As an alternative to Homebrew, one can use Conan to build the dependencies.

  First install Conan using:

  ```sh
  pip install conan
  ```

  Then, generate a profile:

  ```sh
  conan profile detect
  ```

  Finally, install all of the dependencies in the `_build` directory:

  ```sh
  conan install . --output-folder=_build --build=missing
  ```

  Note that this may take a while as the packages are usually built from source.

  **IMPORTANT NOTE**: Due to the fact that newer Apple devices have dual architectures (both `arm64` and `x86_64`), it is recommended to not mix these together, i.e. you should re-run _all_ of the above in clean `arm64` and `x86_64` environments (terminals) in separate COFFE directories to avoid any issues.



  COFFE also depends on the CLASS and CUBA libraries, which are not available on Homebrew or Conan, or the default Linux package repositories.
  To install them, one needs to install `automake`, either via Homebrew (`brew install automake`) or via some other package manager.
  They can then be built and installed by running:

  ```sh
  bash scripts/install_other.sh class cuba
  ```

  This will install the two packages in the directories `/opt/cuba_[ARCH]` and `/opt/class_public_[ARCH]`, where arch is either `x86_64` or `arm64` depending on your CPU architecture.



  Now that the prerequisites are installed, you can install COFFE using:

  ```sh
  pip install .
  ```

  If you would additionally like to install all of the various tools for testing, generating docs, and development, you can additionally run:

  ```sh
  pip install '.[all]'
  ```



  The documentation for the latest version is available [here](https://jcgoran.github.io/coffe/).
  To build the documentation, you can run `bash scripts/generate_docs.sh`, after which the documentation will be available under `docs/`.



  Please use the [issue tracker](https://github.com/JCGoran/coffe/issues) to submit any bug reports and feature requests.



  COFFE is licensed under the GNU GPL 3.0. See the [LICENSE](LICENSE) file for more information.



  If you use COFFE in a publication, we kindly ask that you cite the original paper describing the code, located at [arXiv:1806.11090](https://arxiv.org/abs/1806.11090).
  A `bibTeX` entry is provided below for convenience.
  ```
  @article{coffe:v1,
        author         = "Tansella, Vittorio and Jelic-Cizmek, Goran and Bonvin,
                          Camille and Durrer, Ruth",
        title          = "{COFFE: a code for the full-sky relativistic galaxy
                          correlation function}",
        year           = "2018",
        eprint         = "1806.11090",
        archivePrefix  = "arXiv",
        primaryClass   = "astro-ph.CO",
        SLACcitation   = "%CITATION = ARXIV:1806.11090;%"
  }
  ```





  If you would like to test COFFE, you can do so in two ways: using either `pytest`, or `cmake` (deprecated).



  To run the tests via `pytest`, first install COFFE using the instructions above, and then run:

  ```sh
  python -m pytest tests/
  ```



  If you do not want to build COFFE using `pip install`, you can instead use `cmake`, which is installable via `pip install cmake`. To do so, follow all of the above instructions, but instead of doing `pip install .`, you can instead do:

  ```sh
  mkdir build
  cd build
  cmake -DCMAKE_INSTALL_PREFIX=./install -DCOFFE_ENABLE_PYTHON=ON -DCOFFE_ENABLE_CLASS=ON -DCOFFE_ENABLE_CUBA=ON -DCOFFE_ENABLE_MATHOPTS=ON -DCOFFE_ENABLE_TESTS=ON ..
  ```

  In case of issues with missing detection of GSL, FFTW, etc., which can happen when using Conan on MacOS, you can use:

  ```sh
  cmake -DCMAKE_INSTALL_PREFIX=./install -DCOFFE_ENABLE_PYTHON=ON -DCOFFE_ENABLE_CLASS=ON -DCOFFE_ENABLE_CUBA=ON -DCOFFE_ENABLE_MATHOPTS=ON -DCOFFE_ENABLE_TESTS=ON -DCMAKE_TOOLCHAIN_FILE=../_build/conan_toolchain.cmake -DCOFFE_PYTHON_MINOR_VERSION=[VERSION] ..
  ```

  where you must replace `[VERSION]` with whatever minor version of Python you are using (for instance, when using Python 3.9, replace `[VERSION]` with `9`).
  Then you can build COFFE tests using:

  ```sh
  make
  ```

  **NOTE**: if you have Ninja installed, you can additionally pass `-G Ninja` to the above `cmake` command, and then run `ninja build` instead of `make`.

  Finally, run the tests using:

  ```sh
  ctest
  ```



  The building of wheels is done using the [`cibuildwheel`](https://cibuildwheel.readthedocs.io/en/stable/) utility.
  To install it, run:

  ```sh
  pip install cibuildwheel
  ```



  Building of wheels on Linux requires a container engine like [Docker](https://docs.docker.com/engine/install/) or [Podman](https://podman.io/docs/installation).
  Once one of those is installed, the wheels can be built using:

  ```sh
  cibuildwheel --platform linux
  ```

  The wheels will then be available in the `wheelhouse` subdirectory, and can then be uploaded to PyPI.



  The MacOS wheels require an [official Python installer](https://www.python.org/downloads/macos/); the ones from Homebrew, Conda, etc. will most likely not work.
  To build the wheels, run:

  ```sh
  cibuildwheel --platform macos
  ```

  The wheels will then be available in the `wheelhouse` subdirectory, and can then be uploaded to PyPI.

  **IMPORTANT NOTE**: if you installed GSL, FFTW, or libconfig via Brew, make sure to unlink them first using:

  ```sh
  brew unlink gsl fftw libconfig
  ```

  because otherwise `cibuildwheel` (or rather, `auditwheel`) may complain about mismatching OS versions.



  To automate the tedious task of building the wheels, they are now setup in the CI.

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


pkgId: c07e4bd4e135d4f6a8b307fb61d35c71f2f4cd86fa830d59bed4e9e70c7659ba
name: python-coffea
arch: src
version: 2024.11.0
epoch: 0
release: 1
url: https://github.com/coffeateam/coffea
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coffea-2024.11.0-1.src.rpm
checksum_type: sha256
summary:
  Basic tools and wrappers for enabling not-too-alien syntax when running columnar Collider HEP analysis.

description:
  Basic tools and wrappers for enabling not-too-alien syntax when running columnar Collider HEP analysis.
  coffea is a prototype package for pulling together all the typical needs
  of a high-energy collider physics (HEP) experiment analysis using the scientific
  python ecosystem. It makes use of `uproot <https://github.com/scikit-hep/uproot4>`_
  and `awkward-array <https://github.com/scikit-hep/awkward-1.0>`_ to provide an
  array-based syntax for manipulating HEP event data in an efficient and numpythonic
  way. There are sub-packages that implement histogramming, plotting, and look-up
  table functionalities that are needed to convey scientific insight, apply transformations
  to data, and correct for discrepancies in Monte Carlo simulations compared to data.
  coffea also supplies facilities for horizontally scaling an analysis in order to reduce
  time-to-insight in a way that is largely independent of the resource the analysis
  is being executed on. By making use of modern *big-data* technologies like
  `Apache Spark <https://spark.apache.org/>`_,  `parsl <https://github.com/Parsl/parsl>`_,
  `Dask <https://dask.org>`_ , and `Work Queue <http://ccl.cse.nd.edu/software/workqueue>`_,
  it is possible with coffea to scale a HEP analysis from a testing
  on a laptop to: a large multi-core server, computing clusters, and super-computers without
  the need to alter or otherwise adapt the analysis code itself.
  coffea is a HEP community project collaborating with `iris-hep <http://iris-hep.org/>`_
  and is currently a prototype. We welcome input to improve its quality as we progress towards
  a sensible refactorization into the scientific python ecosystem and a first release. Please
  feel free to contribute at our `github repo <https://github.com/CoffeaTeam/coffea>`_!


pkgId: 03952dde7a6f13c8624ac6777cfda8dec04721ccad06efb9d03e5ee6add3276e
name: python-coffeehouse
arch: src
version: 2.2.6
epoch: 0
release: 1
summary: Official CoffeeHouse API Wrapper for Python
url: https://coffeehouse.intellivoid.net/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coffeehouse-2.2.6-1.src.rpm
checksum_type: sha256
description:
  This is a very simple API Wrapper for the CoffeeHouse API. Using
  This Library only supports the V1IVA2.0 CoffeeHouse API which is based from
  this [Documentation](https://gist.github.com/Netkas/e8977b26f482ca40911a949df7dd286f)



  ```sh
  pip install coffeehouse
  ```

  or
  ```sh
  python setup.py build
  python setup.py install
  ```




  ```python
  from coffeehouse.lydia import LydiaAI


  api_key = input("API Key: ")


  lydia = LydiaAI(api_key)


  session = lydia.create_session()
  print("Session ID: {0}".format(session.id))
  print("Session Available: {0}".format(str(session.available)))
  print("Session Language: {0}".format(str(session.language)))
  print("Session Expires: {0}".format(str(session.expires)))


  while True:
      output = session.think_thought(input("Input: "))
      print("Output: {0}".format(output))









  ```


pkgId: 868b289dbd1725ad8b9ecae42095d6e76a3328d2146cc5f8ff9f83ef3e1c6554
name: python-cofi
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: Common Framework for Inference
url: https://pypi.org/project/cofi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cofi-0.2.9-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/cofi?logo=pypi&style=flat-square&color=cae9ff&labelColor=f8f9fa)](https://pypi.org/project/cofi/)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/cofi.svg?logo=condaforge&style=flat-square&color=cce3de&labelColor=f8f9fa&logoColor=344e41)](https://anaconda.org/conda-forge/cofi)
  [![Documentation Status](https://img.shields.io/readthedocs/cofi?logo=readthedocs&style=flat-square&color=fed9b7&labelColor=f8f9fa&logoColor=eaac8b)](https://cofi.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://img.shields.io/codecov/c/github/inlab-geo/cofi?logo=pytest&style=flat-square&token=T8R9VKM4D7&color=ffcad4&labelColor=f8f9fa&logoColor=ff99c8)](https://codecov.io/gh/inlab-geo/cofi)
  [![Slack](https://img.shields.io/badge/Slack-InLab_community-4A154B?logo=slack&style=flat-square&color=cdb4db&labelColor=f8f9fa&logoColor=9c89b8)](https://join.slack.com/t/inlab-community/shared_invite/zt-1ejny069z-v5ZyvP2tDjBR42OAu~TkHg)
  <!-- [![Wheels](https://img.shields.io/pypi/wheel/cofi)](https://pypi.org/project/cofi/) -->

  > Related repositories by [InLab](https://inlab.edu.au/community/):
  > - [CoFI Examples](https://github.com/inlab-geo/cofi-examples)
  > - [Espresso](https://github.com/inlab-geo/espresso)



  CoFI (Common Framework for Inference) is an open source initiative for interfacing between generic inference algorithms and specific geoscience problems.

  With a mission to bridge the gap between the domain expertise and the inference expertise, CoFI provides an interface across a wide range of inference algorithms from different sources, underpinned by a rich set of domain relevant [examples](https://cofi.readthedocs.io/en/latest/examples/generated/index.html).

  Read [the documentation](https://cofi.readthedocs.io/en/latest/), and let us know your feedback or any issues!



  From PyPI:

  ```console
  $ pip install cofi
  ```

  Or alternatively, from conda-forge:

  ```console
  $ conda install -c conda-forge cofi
  ```

  Check CoFI documentation -
  [installation page](https://cofi.readthedocs.io/en/latest/installation.html)
  for details on dependencies and setting up with virtual environments.



  ```mermaid
  graph TD;
      base_problem_details(inv_problem = BaseProblem#40;#41;\ninv_problem.set_objective#40;DEFINE ME#41;\ninv_problem.set_jacobian#40;DEFINE ME#41;\ninv_problem.set_initial_model#40;DEFINE ME#41;):::cls_code_block
      inversion_options_details(inv_options = InversionOptions#40;#41;\ninv_options.set_tool#40;#34;scipy.linalg.lstsq#34;#41;):::cls_code_block
      inversion_details(inv=Inversion#40;inv_problem, inv_options#41;\nresult = inv.run#40;#41;):::cls_code_block

      subgraph base_problem ["Base Problem"]
          base_problem_details
      end

      subgraph inversion_options ["Inversion Options"]
          inversion_options_details
      end

      subgraph inversion ["Inversion"]
          inversion_details
      end

      base_problem --> inversion;
      inversion_options --> inversion;

      classDef cls_base_problem fill: oldlace, stroke-width: 0;
      classDef cls_inversion_options fill: oldlace, stroke-width: 0;
      classDef cls_inversion fill: lavender, stroke-width: 0;
      classDef cls_code_block fill: lightgrey, stroke-width: 0, text-align: left;

      class base_problem cls_base_problem;
      class inversion_options cls_inversion_options;
      class inversion cls_inversion;
  ```

  CoFI API has flexible ways of defining an inversion problem. For instance:

  ```python
  import cofi

  inv_problem = cofi.BaseProblem()
  inv_problem.set_objective(my_objective_func)
  inv_problem.set_initial_model(my_starting_point)
  ```

  Once a problem is defined, `cofi` can tell you what inference tools you can use based on what level of
  information you've provided:

  ```python
  inv_problem.suggest_tools()   # a tree will be printed
  ```

  Run an inversion with these lines:

  ```python
  inv_options = cofi.InversionOptions()
  inv_options.set_tool("torch.optim")
  inv_options.set_params(options={"num_iterations": 50, "algorithm": "Adam"})

  inv = cofi.Inversion(inv_problem, inv_options)
  result = inv.run()
  print(result.success)
  print(result.model)
  ```

  And now an inversion is completed! Check out our [example gallery](https://cofi.readthedocs.io/en/latest/examples/generated/index.html)
  and [tutorial](https://cofi.readthedocs.io/en/latest/tutorials/generated/index.html) pages for more
  real-world or advanced use cases.



  Interested in contributing? Please check out our [contributor's guide](https://cofi.readthedocs.io/en/latest/contribute.html).




  This project is distributed under a 2-clause BSD licence. A copy of this licence is
  provided with distributions of the software.


pkgId: 231b57f2ac7efda11933d37066504978f50d341ed84617f3c5d1c8241cc682e2
name: python-coflux
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/coflux/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coflux-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Coflux is an open-source workflow engine. Use it to orchestrate and observe computational workflows, defined in plain Python. Suitable for data pipelines, background tasks, chat bots.

  This is the Python client, which is used for defining workflows. It also includes the CLI, which can be used for running agents, configuring new projects, and starting runs.

  Refer to the [docs](https://docs.coflux.com) for more details.


pkgId: 83ab5e84f8ca8bba5492288c6c957da720a43b4b406b3af1cdd31160ddf81f79
name: python-cog
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: Containers for machine learning
url: https://pypi.org/project/cog/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cog-0.13.2-1.src.rpm
checksum_type: sha256
description:
  Cog is an open-source tool that lets you package machine learning models in a standard, production-ready container.

  You can deploy your packaged model to your own infrastructure, or to [Replicate](https://replicate.com/).



  - 📦 **Docker containers without the pain.** Writing your own `Dockerfile` can be a bewildering process. With Cog, you define your environment with a [simple configuration file](#how-it-works) and it generates a Docker image with all the best practices: Nvidia base images, efficient caching of dependencies, installing specific Python versions, sensible environment variable defaults, and so on.

  - 🤬️ **No more CUDA hell.** Cog knows which CUDA/cuDNN/PyTorch/Tensorflow/Python combos are compatible and will set it all up correctly for you.

  - ✅ **Define the inputs and outputs for your model with standard Python.** Then, Cog generates an OpenAPI schema and validates the inputs and outputs with Pydantic.

  - 🎁 **Automatic HTTP prediction server**: Your model's types are used to dynamically generate a RESTful HTTP API using [FastAPI](https://fastapi.tiangolo.com/).

  - 🥞 **Automatic queue worker.** Long-running deep learning models or batch processing is best architected with a queue. Cog models do this out of the box. Redis is currently supported, with more in the pipeline.

  - ☁️ **Cloud storage.** Files can be read and written directly to Amazon S3 and Google Cloud Storage. (Coming soon.)

  - 🚀 **Ready for production.** Deploy your model anywhere that Docker images run. Your own infrastructure, or [Replicate](https://replicate.com).



  Define the Docker environment your model runs in with `cog.yaml`:

  ```yaml
  build:
    gpu: true
    system_packages:
      - "libgl1-mesa-glx"
      - "libglib2.0-0"
    python_version: "3.12"
    python_packages:
      - "torch==2.3"
  predict: "predict.py:Predictor"
  ```

  Define how predictions are run on your model with `predict.py`:

  ```python
  from cog import BasePredictor, Input, Path
  import torch

  class Predictor(BasePredictor):
      def setup(self):
          """Load the model into memory to make running multiple predictions efficient"""
          self.model = torch.load("./weights.pth")

      
      def predict(self,
            image: Path = Input(description="Grayscale input image")
      ) -> Path:
          """Run a single prediction on the model"""
          processed_image = preprocess(image)
          output = self.model(processed_image)
          return postprocess(output)
  ```

  Now, you can run predictions on this model:

  ```console
  $ cog predict -i image=@input.jpg
  --> Building Docker image...
  --> Running Prediction...
  --> Output written to output.jpg
  ```

  Or, build a Docker image for deployment:

  ```console
  $ cog build -t my-colorization-model
  --> Building Docker image...
  --> Built my-colorization-model:latest

  $ docker run -d -p 5000:5000 --gpus all my-colorization-model

  $ curl http://localhost:5000/predictions -X POST \
      -H 'Content-Type: application/json' \
      -d '{"input": {"image": "https://.../input.jpg"}}'
  ```

  Or, combine build and run via the `serve` command:

  ```console
  $ cog serve -p 8080

  $ curl http://localhost:8080/predictions -X POST \
      -H 'Content-Type: application/json' \
      -d '{"input": {"image": "https://.../input.jpg"}}'
  ```

  <!-- NOTE (bfirsh): Development environment instructions intentionally left out of readme for now, so as not to confuse the "ship a model to production" message.

  In development, you can also run arbitrary commands inside the Docker environment:

  ```console
  $ cog run python train.py
  ...
  ```

  Or, [spin up a Jupyter notebook](docs/notebooks.md):

  ```console
  $ cog run -p 8888 jupyter notebook --allow-root --ip=0.0.0.0
  ```
  -->



  It's really hard for researchers to ship machine learning models to production.

  Part of the solution is Docker, but it is so complex to get it to work: Dockerfiles, pre-/post-processing, Flask servers, CUDA versions. More often than not the researcher has to sit down with an engineer to get the damn thing deployed.

  [Andreas](https://github.com/andreasjansson) and [Ben](https://github.com/bfirsh) created Cog. Andreas used to work at Spotify, where he built tools for building and deploying ML models with Docker. Ben worked at Docker, where he created [Docker Compose](https://github.com/docker/compose).

  We realized that, in addition to Spotify, other companies were also using Docker to build and deploy machine learning models. [Uber](https://eng.uber.com/michelangelo-pyml/) and others have built similar systems. So, we're making an open source version so other people can do this too.

  Hit us up if you're interested in using it or want to collaborate with us. [We're on Discord](https://discord.gg/replicate) or email us at [team@replicate.com](mailto:team@replicate.com).



  - **macOS, Linux or Windows 11**. Cog works on macOS, Linux and Windows 11 with [WSL 2](docs/wsl2/wsl2.md)
  - **Docker**. Cog uses Docker to create a container for your model. You'll need to [install Docker](https://docs.docker.com/get-docker/) before you can run Cog. If you install Docker Engine instead of Docker Desktop, you will need to [install Buildx](https://docs.docker.com/build/architecture/#buildx) as well.



  If you're using macOS, you can install Cog using Homebrew:

  ```console
  brew install cog
  ```

  You can also download and install the latest release using our
  [install script](https://cog.run/install):

  ```sh

  sh (curl -fsSL https://cog.run/install.sh | psub)


  sh <(curl -fsSL https://cog.run/install.sh)


  wget -qO- https://cog.run/install.sh
  sh ./install.sh
  ```

  You can manually install the latest release of Cog directly from GitHub
  by running the following commands in a terminal:

  ```console
  sudo curl -o /usr/local/bin/cog -L "https://github.com/replicate/cog/releases/latest/download/cog_$(uname -s)_$(uname -m)"
  sudo chmod +x /usr/local/bin/cog
  ```

  Alternatively, you can build Cog from source and install it with these commands:

  ```console
  make
  sudo make install
  ```

  Or if you are on docker:

  ```
  RUN sh -c "INSTALL_DIR=\"/usr/local/bin\" SUDO=\"\" $(curl -fsSL https://cog.run/install.sh)"
  ```



  If you're using macOS and you previously installed Cog with Homebrew, run the following:

  ```console
  brew upgrade cog
  ```

  Otherwise, you can upgrade to the latest version by running the same commands you used to install it.



  - [Get started with an example model](docs/getting-started.md)
  - [Get started with your own model](docs/getting-started-own-model.md)
  - [Using Cog with notebooks](docs/notebooks.md)
  - [Using Cog with Windows 11](docs/wsl2/wsl2.md)
  - [Take a look at some examples of using Cog](https://github.com/replicate/cog-examples)
  - [Deploy models with Cog](docs/deploy.md)
  - [`cog.yaml` reference](docs/yaml.md) to learn how to define your model's environment
  - [Prediction interface reference](docs/python.md) to learn how the `Predictor` interface works
  - [Training interface reference](docs/training.md) to learn how to add a fine-tuning API to your model
  - [HTTP API reference](docs/http.md) to learn how to use the HTTP API that models serve



  [Join us in #cog on Discord.](https://discord.gg/replicate)



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://fir.sh/"><img src="https://avatars.githubusercontent.com/u/40906?v=4?s=100" width="100px;" alt="Ben Firshman"/><br /><sub><b>Ben Firshman</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=bfirsh" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=bfirsh" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://replicate.ai/"><img src="https://avatars.githubusercontent.com/u/713993?v=4?s=100" width="100px;" alt="Andreas Jansson"/><br /><sub><b>Andreas Jansson</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=andreasjansson" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=andreasjansson" title="Documentation">📖</a> <a href="#maintenance-andreasjansson" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://zeke.sikelianos.com/"><img src="https://avatars.githubusercontent.com/u/2289?v=4?s=100" width="100px;" alt="Zeke Sikelianos"/><br /><sub><b>Zeke Sikelianos</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=zeke" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=zeke" title="Documentation">📖</a> <a href="#tool-zeke" title="Tools">🔧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://rory.bio/"><img src="https://avatars.githubusercontent.com/u/9436784?v=4?s=100" width="100px;" alt="Rory Byrne"/><br /><sub><b>Rory Byrne</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=synek" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=synek" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/commits?author=synek" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/hangtwenty"><img src="https://avatars.githubusercontent.com/u/2420688?v=4?s=100" width="100px;" alt="Michael Floering"/><br /><sub><b>Michael Floering</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=hangtwenty" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=hangtwenty" title="Documentation">📖</a> <a href="#ideas-hangtwenty" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://bencevans.io/"><img src="https://avatars.githubusercontent.com/u/638535?v=4?s=100" width="100px;" alt="Ben Evans"/><br /><sub><b>Ben Evans</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=bencevans" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://shashank.pw/"><img src="https://avatars.githubusercontent.com/u/778870?v=4?s=100" width="100px;" alt="shashank agarwal"/><br /><sub><b>shashank agarwal</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=imshashank" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=imshashank" title="Documentation">📖</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://victorxlr.me/"><img src="https://avatars.githubusercontent.com/u/22397950?v=4?s=100" width="100px;" alt="VictorXLR"/><br /><sub><b>VictorXLR</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=VictorXLR" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=VictorXLR" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/commits?author=VictorXLR" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://annahung31.github.io/"><img src="https://avatars.githubusercontent.com/u/39179888?v=4?s=100" width="100px;" alt="hung anna"/><br /><sub><b>hung anna</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aannahung31" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://notes.variogr.am/"><img src="https://avatars.githubusercontent.com/u/76612?v=4?s=100" width="100px;" alt="Brian Whitman"/><br /><sub><b>Brian Whitman</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Abwhitman" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JimothyJohn"><img src="https://avatars.githubusercontent.com/u/24216724?v=4?s=100" width="100px;" alt="JimothyJohn"/><br /><sub><b>JimothyJohn</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3AJimothyJohn" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ericguizzo"><img src="https://avatars.githubusercontent.com/u/26746670?v=4?s=100" width="100px;" alt="ericguizzo"/><br /><sub><b>ericguizzo</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aericguizzo" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.dominicbaggott.com"><img src="https://avatars.githubusercontent.com/u/74812?v=4?s=100" width="100px;" alt="Dominic Baggott"/><br /><sub><b>Dominic Baggott</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=evilstreak" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=evilstreak" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dashstander"><img src="https://avatars.githubusercontent.com/u/7449128?v=4?s=100" width="100px;" alt="Dashiell Stander"/><br /><sub><b>Dashiell Stander</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Adashstander" title="Bug reports">🐛</a> <a href="https://github.com/replicate/cog/commits?author=dashstander" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=dashstander" title="Tests">⚠️</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Hurricane-eye"><img src="https://avatars.githubusercontent.com/u/31437546?v=4?s=100" width="100px;" alt="Shuwei Liang"/><br /><sub><b>Shuwei Liang</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3AHurricane-eye" title="Bug reports">🐛</a> <a href="#question-Hurricane-eye" title="Answering Questions">💬</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ericallam"><img src="https://avatars.githubusercontent.com/u/534?v=4?s=100" width="100px;" alt="Eric Allam"/><br /><sub><b>Eric Allam</b></sub></a><br /><a href="#ideas-ericallam" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://perdomo.me"><img src="https://avatars.githubusercontent.com/u/178474?v=4?s=100" width="100px;" alt="Iván Perdomo"/><br /><sub><b>Iván Perdomo</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aiperdomo" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://charlesfrye.github.io"><img src="https://avatars.githubusercontent.com/u/10442975?v=4?s=100" width="100px;" alt="Charles Frye"/><br /><sub><b>Charles Frye</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=charlesfrye" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/phamquiluan"><img src="https://avatars.githubusercontent.com/u/24642166?v=4?s=100" width="100px;" alt="Luan Pham"/><br /><sub><b>Luan Pham</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aphamquiluan" title="Bug reports">🐛</a> <a href="https://github.com/replicate/cog/commits?author=phamquiluan" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/TommyDew42"><img src="https://avatars.githubusercontent.com/u/46992350?v=4?s=100" width="100px;" alt="TommyDew"/><br /><sub><b>TommyDew</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=TommyDew42" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://m4ke.org"><img src="https://avatars.githubusercontent.com/u/27?v=4?s=100" width="100px;" alt="Jesse Andrews"/><br /><sub><b>Jesse Andrews</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=anotherjesse" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=anotherjesse" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/commits?author=anotherjesse" title="Tests">⚠️</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://whiteink.com"><img src="https://avatars.githubusercontent.com/u/3602?v=4?s=100" width="100px;" alt="Nick Stenning"/><br /><sub><b>Nick Stenning</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=nickstenning" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=nickstenning" title="Documentation">📖</a> <a href="#design-nickstenning" title="Design">🎨</a> <a href="#infra-nickstenning" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/replicate/cog/commits?author=nickstenning" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://merrell.io/"><img src="https://avatars.githubusercontent.com/u/14996837?v=4?s=100" width="100px;" alt="Justin Merrell"/><br /><sub><b>Justin Merrell</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=justinmerrell" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ruriky"><img src="https://avatars.githubusercontent.com/u/19946546?v=4?s=100" width="100px;" alt="Rurik Ylä-Onnenvuori"/><br /><sub><b>Rurik Ylä-Onnenvuori</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aruriky" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.youka.club/"><img src="https://avatars.githubusercontent.com/u/59315275?v=4?s=100" width="100px;" alt="Youka"/><br /><sub><b>Youka</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Ayoukaclub" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/afiaka87"><img src="https://avatars.githubusercontent.com/u/3994972?v=4?s=100" width="100px;" alt="Clay Mullis"/><br /><sub><b>Clay Mullis</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=afiaka87" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mattt"><img src="https://avatars.githubusercontent.com/u/7659?v=4?s=100" width="100px;" alt="Mattt"/><br /><sub><b>Mattt</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=mattt" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=mattt" title="Documentation">📖</a> <a href="#infra-mattt" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Juneezee"><img src="https://avatars.githubusercontent.com/u/20135478?v=4?s=100" width="100px;" alt="Eng Zer Jun"/><br /><sub><b>Eng Zer Jun</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=Juneezee" title="Tests">⚠️</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bbedward"><img src="https://avatars.githubusercontent.com/u/550752?v=4?s=100" width="100px;" alt="BB"/><br /><sub><b>BB</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=bbedward" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/williamluer"><img src="https://avatars.githubusercontent.com/u/85975676?v=4?s=100" width="100px;" alt="williamluer"/><br /><sub><b>williamluer</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=williamluer" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://sirupsen.com"><img src="https://avatars.githubusercontent.com/u/97400?v=4?s=100" width="100px;" alt="Simon Eskildsen"/><br /><sub><b>Simon Eskildsen</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=sirupsen" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://erbridge.co.uk"><img src="https://avatars.githubusercontent.com/u/1027364?v=4?s=100" width="100px;" alt="F"/><br /><sub><b>F</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aerbridge" title="Bug reports">🐛</a> <a href="https://github.com/replicate/cog/commits?author=erbridge" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/philandstuff"><img src="https://avatars.githubusercontent.com/u/581269?v=4?s=100" width="100px;" alt="Philip Potter"/><br /><sub><b>Philip Potter</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aphilandstuff" title="Bug reports">🐛</a> <a href="https://github.com/replicate/cog/commits?author=philandstuff" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/joannejchen"><img src="https://avatars.githubusercontent.com/u/33409024?v=4?s=100" width="100px;" alt="Joanne Chen"/><br /><sub><b>Joanne Chen</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=joannejchen" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://technillogue.github.io"><img src="https://avatars.githubusercontent.com/u/945691?v=4?s=100" width="100px;" alt="technillogue"/><br /><sub><b>technillogue</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=technillogue" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="http://aroncarroll.com"><img src="https://avatars.githubusercontent.com/u/47144?v=4?s=100" width="100px;" alt="Aron Carroll"/><br /><sub><b>Aron Carroll</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=aron" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/commits?author=aron" title="Code">💻</a> <a href="#ideas-aron" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Theodotus1243"><img src="https://avatars.githubusercontent.com/u/32220358?v=4?s=100" width="100px;" alt="Bohdan Mykhailenko"/><br /><sub><b>Bohdan Mykhailenko</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=Theodotus1243" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/issues?q=author%3ATheodotus1243" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/one1zero1one"><img src="https://avatars.githubusercontent.com/u/724604?v=4?s=100" width="100px;" alt="Daniel Radu"/><br /><sub><b>Daniel Radu</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=one1zero1one" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/issues?q=author%3Aone1zero1one" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Etelis"><img src="https://avatars.githubusercontent.com/u/92247226?v=4?s=100" width="100px;" alt="Itay Etelis"/><br /><sub><b>Itay Etelis</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=Etelis" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.wavefunction.dev"><img src="https://avatars.githubusercontent.com/u/54407820?v=4?s=100" width="100px;" alt="Gennaro Schiano"/><br /><sub><b>Gennaro Schiano</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=gschian0" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://andreknoerig.de"><img src="https://avatars.githubusercontent.com/u/481350?v=4?s=100" width="100px;" alt="André Knörig"/><br /><sub><b>André Knörig</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=aknoerig" title="Documentation">📖</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

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


pkgId: 0222b524e77e9104695cc894185030875d235bf24f755bcf1339a8b2b17cf7bf
name: python-cog
arch: src
version: 0.9.21
epoch: 0
release: 1
summary: Containers for machine learning
url: https://pypi.org/project/cog/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cog-0.9.21-1.src.rpm
checksum_type: sha256
description:
  Cog is an open-source tool that lets you package machine learning models in a standard, production-ready container.

  You can deploy your packaged model to your own infrastructure, or to [Replicate](https://replicate.com/).



  - 📦 **Docker containers without the pain.** Writing your own `Dockerfile` can be a bewildering process. With Cog, you define your environment with a [simple configuration file](#how-it-works) and it generates a Docker image with all the best practices: Nvidia base images, efficient caching of dependencies, installing specific Python versions, sensible environment variable defaults, and so on.

  - 🤬️ **No more CUDA hell.** Cog knows which CUDA/cuDNN/PyTorch/Tensorflow/Python combos are compatible and will set it all up correctly for you.

  - ✅ **Define the inputs and outputs for your model with standard Python.** Then, Cog generates an OpenAPI schema and validates the inputs and outputs with Pydantic.

  - 🎁 **Automatic HTTP prediction server**: Your model's types are used to dynamically generate a RESTful HTTP API using [FastAPI](https://fastapi.tiangolo.com/).

  - 🥞 **Automatic queue worker.** Long-running deep learning models or batch processing is best architected with a queue. Cog models do this out of the box. Redis is currently supported, with more in the pipeline.

  - ☁️ **Cloud storage.** Files can be read and written directly to Amazon S3 and Google Cloud Storage. (Coming soon.)

  - 🚀 **Ready for production.** Deploy your model anywhere that Docker images run. Your own infrastructure, or [Replicate](https://replicate.com).



  Define the Docker environment your model runs in with `cog.yaml`:

  ```yaml
  build:
    gpu: true
    system_packages:
      - "libgl1-mesa-glx"
      - "libglib2.0-0"
    python_version: "3.12"
    python_packages:
      - "torch==2.3"
  predict: "predict.py:Predictor"
  ```

  Define how predictions are run on your model with `predict.py`:

  ```python
  from cog import BasePredictor, Input, Path
  import torch

  class Predictor(BasePredictor):
      def setup(self):
          """Load the model into memory to make running multiple predictions efficient"""
          self.model = torch.load("./weights.pth")

      
      def predict(self,
            image: Path = Input(description="Grayscale input image")
      ) -> Path:
          """Run a single prediction on the model"""
          processed_image = preprocess(image)
          output = self.model(processed_image)
          return postprocess(output)
  ```

  Now, you can run predictions on this model:

  ```console
  $ cog predict -i image=@input.jpg
  --> Building Docker image...
  --> Running Prediction...
  --> Output written to output.jpg
  ```

  Or, build a Docker image for deployment:

  ```console
  $ cog build -t my-colorization-model
  --> Building Docker image...
  --> Built my-colorization-model:latest

  $ docker run -d -p 5000:5000 --gpus all my-colorization-model

  $ curl http://localhost:5000/predictions -X POST \
      -H 'Content-Type: application/json' \
      -d '{"input": {"image": "https://.../input.jpg"}}'
  ```

  <!-- NOTE (bfirsh): Development environment instructions intentionally left out of readme for now, so as not to confuse the "ship a model to production" message.

  In development, you can also run arbitrary commands inside the Docker environment:

  ```console
  $ cog run python train.py
  ...
  ```

  Or, [spin up a Jupyter notebook](docs/notebooks.md):

  ```console
  $ cog run -p 8888 jupyter notebook --allow-root --ip=0.0.0.0
  ```
  -->



  It's really hard for researchers to ship machine learning models to production.

  Part of the solution is Docker, but it is so complex to get it to work: Dockerfiles, pre-/post-processing, Flask servers, CUDA versions. More often than not the researcher has to sit down with an engineer to get the damn thing deployed.

  [Andreas](https://github.com/andreasjansson) and [Ben](https://github.com/bfirsh) created Cog. Andreas used to work at Spotify, where he built tools for building and deploying ML models with Docker. Ben worked at Docker, where he created [Docker Compose](https://github.com/docker/compose).

  We realized that, in addition to Spotify, other companies were also using Docker to build and deploy machine learning models. [Uber](https://eng.uber.com/michelangelo-pyml/) and others have built similar systems. So, we're making an open source version so other people can do this too.

  Hit us up if you're interested in using it or want to collaborate with us. [We're on Discord](https://discord.gg/replicate) or email us at [team@replicate.com](mailto:team@replicate.com).



  - **macOS, Linux or Windows 11**. Cog works on macOS, Linux and Windows 11 with [WSL 2](docs/wsl2/wsl2.md)
  - **Docker**. Cog uses Docker to create a container for your model. You'll need to [install Docker](https://docs.docker.com/get-docker/) before you can run Cog. If you install Docker Engine instead of Docker Desktop, you will need to [install Buildx](https://docs.docker.com/build/architecture/#buildx) as well.



  If you're using macOS, you can install Cog using Homebrew:

  ```console
  brew install cog
  ```

  You can also download and install the latest release using our
  [install script](https://cog.run/install):

  ```sh

  sh (curl -fsSL https://cog.run/install.sh | psub)


  sh <(curl -fsSL https://cog.run/install.sh)


  wget -qO- https://cog.run/install.sh
  sh ./install.sh
  ```

  You can manually install the latest release of Cog directly from GitHub
  by running the following commands in a terminal:

  ```console
  sudo curl -o /usr/local/bin/cog -L "https://github.com/replicate/cog/releases/latest/download/cog_$(uname -s)_$(uname -m)"
  sudo chmod +x /usr/local/bin/cog
  ```

  Alternatively, you can build Cog from source and install it with these commands:

  ```console
  make
  sudo make install
  ```

  Or if you are on docker:

  ```
  RUN sh -c "INSTALL_DIR=\"/usr/local/bin\" SUDO=\"\" $(curl -fsSL https://cog.run/install.sh)"
  ```



  If you're using macOS and you previously installed Cog with Homebrew, run the following:

  ```console
  brew upgrade cog
  ```

  Otherwise, you can upgrade to the latest version by running the same commands you used to install it.



  - [Get started with an example model](docs/getting-started.md)
  - [Get started with your own model](docs/getting-started-own-model.md)
  - [Using Cog with notebooks](docs/notebooks.md)
  - [Using Cog with Windows 11](docs/wsl2/wsl2.md)
  - [Take a look at some examples of using Cog](https://github.com/replicate/cog-examples)
  - [Deploy models with Cog](docs/deploy.md)
  - [`cog.yaml` reference](docs/yaml.md) to learn how to define your model's environment
  - [Prediction interface reference](docs/python.md) to learn how the `Predictor` interface works
  - [Training interface reference](docs/training.md) to learn how to add a fine-tuning API to your model
  - [HTTP API reference](docs/http.md) to learn how to use the HTTP API that models serve



  [Join us in #cog on Discord.](https://discord.gg/replicate)



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://fir.sh/"><img src="https://avatars.githubusercontent.com/u/40906?v=4?s=100" width="100px;" alt="Ben Firshman"/><br /><sub><b>Ben Firshman</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=bfirsh" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=bfirsh" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://replicate.ai/"><img src="https://avatars.githubusercontent.com/u/713993?v=4?s=100" width="100px;" alt="Andreas Jansson"/><br /><sub><b>Andreas Jansson</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=andreasjansson" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=andreasjansson" title="Documentation">📖</a> <a href="#maintenance-andreasjansson" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://zeke.sikelianos.com/"><img src="https://avatars.githubusercontent.com/u/2289?v=4?s=100" width="100px;" alt="Zeke Sikelianos"/><br /><sub><b>Zeke Sikelianos</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=zeke" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=zeke" title="Documentation">📖</a> <a href="#tool-zeke" title="Tools">🔧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://rory.bio/"><img src="https://avatars.githubusercontent.com/u/9436784?v=4?s=100" width="100px;" alt="Rory Byrne"/><br /><sub><b>Rory Byrne</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=synek" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=synek" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/commits?author=synek" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/hangtwenty"><img src="https://avatars.githubusercontent.com/u/2420688?v=4?s=100" width="100px;" alt="Michael Floering"/><br /><sub><b>Michael Floering</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=hangtwenty" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=hangtwenty" title="Documentation">📖</a> <a href="#ideas-hangtwenty" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://bencevans.io/"><img src="https://avatars.githubusercontent.com/u/638535?v=4?s=100" width="100px;" alt="Ben Evans"/><br /><sub><b>Ben Evans</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=bencevans" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://shashank.pw/"><img src="https://avatars.githubusercontent.com/u/778870?v=4?s=100" width="100px;" alt="shashank agarwal"/><br /><sub><b>shashank agarwal</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=imshashank" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=imshashank" title="Documentation">📖</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://victorxlr.me/"><img src="https://avatars.githubusercontent.com/u/22397950?v=4?s=100" width="100px;" alt="VictorXLR"/><br /><sub><b>VictorXLR</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=VictorXLR" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=VictorXLR" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/commits?author=VictorXLR" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://annahung31.github.io/"><img src="https://avatars.githubusercontent.com/u/39179888?v=4?s=100" width="100px;" alt="hung anna"/><br /><sub><b>hung anna</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aannahung31" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://notes.variogr.am/"><img src="https://avatars.githubusercontent.com/u/76612?v=4?s=100" width="100px;" alt="Brian Whitman"/><br /><sub><b>Brian Whitman</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Abwhitman" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JimothyJohn"><img src="https://avatars.githubusercontent.com/u/24216724?v=4?s=100" width="100px;" alt="JimothyJohn"/><br /><sub><b>JimothyJohn</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3AJimothyJohn" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ericguizzo"><img src="https://avatars.githubusercontent.com/u/26746670?v=4?s=100" width="100px;" alt="ericguizzo"/><br /><sub><b>ericguizzo</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aericguizzo" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.dominicbaggott.com"><img src="https://avatars.githubusercontent.com/u/74812?v=4?s=100" width="100px;" alt="Dominic Baggott"/><br /><sub><b>Dominic Baggott</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=evilstreak" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=evilstreak" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dashstander"><img src="https://avatars.githubusercontent.com/u/7449128?v=4?s=100" width="100px;" alt="Dashiell Stander"/><br /><sub><b>Dashiell Stander</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Adashstander" title="Bug reports">🐛</a> <a href="https://github.com/replicate/cog/commits?author=dashstander" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=dashstander" title="Tests">⚠️</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Hurricane-eye"><img src="https://avatars.githubusercontent.com/u/31437546?v=4?s=100" width="100px;" alt="Shuwei Liang"/><br /><sub><b>Shuwei Liang</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3AHurricane-eye" title="Bug reports">🐛</a> <a href="#question-Hurricane-eye" title="Answering Questions">💬</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ericallam"><img src="https://avatars.githubusercontent.com/u/534?v=4?s=100" width="100px;" alt="Eric Allam"/><br /><sub><b>Eric Allam</b></sub></a><br /><a href="#ideas-ericallam" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://perdomo.me"><img src="https://avatars.githubusercontent.com/u/178474?v=4?s=100" width="100px;" alt="Iván Perdomo"/><br /><sub><b>Iván Perdomo</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aiperdomo" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://charlesfrye.github.io"><img src="https://avatars.githubusercontent.com/u/10442975?v=4?s=100" width="100px;" alt="Charles Frye"/><br /><sub><b>Charles Frye</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=charlesfrye" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/phamquiluan"><img src="https://avatars.githubusercontent.com/u/24642166?v=4?s=100" width="100px;" alt="Luan Pham"/><br /><sub><b>Luan Pham</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aphamquiluan" title="Bug reports">🐛</a> <a href="https://github.com/replicate/cog/commits?author=phamquiluan" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/TommyDew42"><img src="https://avatars.githubusercontent.com/u/46992350?v=4?s=100" width="100px;" alt="TommyDew"/><br /><sub><b>TommyDew</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=TommyDew42" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://m4ke.org"><img src="https://avatars.githubusercontent.com/u/27?v=4?s=100" width="100px;" alt="Jesse Andrews"/><br /><sub><b>Jesse Andrews</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=anotherjesse" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=anotherjesse" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/commits?author=anotherjesse" title="Tests">⚠️</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://whiteink.com"><img src="https://avatars.githubusercontent.com/u/3602?v=4?s=100" width="100px;" alt="Nick Stenning"/><br /><sub><b>Nick Stenning</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=nickstenning" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=nickstenning" title="Documentation">📖</a> <a href="#design-nickstenning" title="Design">🎨</a> <a href="#infra-nickstenning" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/replicate/cog/commits?author=nickstenning" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://merrell.io/"><img src="https://avatars.githubusercontent.com/u/14996837?v=4?s=100" width="100px;" alt="Justin Merrell"/><br /><sub><b>Justin Merrell</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=justinmerrell" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ruriky"><img src="https://avatars.githubusercontent.com/u/19946546?v=4?s=100" width="100px;" alt="Rurik Ylä-Onnenvuori"/><br /><sub><b>Rurik Ylä-Onnenvuori</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aruriky" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.youka.club/"><img src="https://avatars.githubusercontent.com/u/59315275?v=4?s=100" width="100px;" alt="Youka"/><br /><sub><b>Youka</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Ayoukaclub" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/afiaka87"><img src="https://avatars.githubusercontent.com/u/3994972?v=4?s=100" width="100px;" alt="Clay Mullis"/><br /><sub><b>Clay Mullis</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=afiaka87" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mattt"><img src="https://avatars.githubusercontent.com/u/7659?v=4?s=100" width="100px;" alt="Mattt"/><br /><sub><b>Mattt</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=mattt" title="Code">💻</a> <a href="https://github.com/replicate/cog/commits?author=mattt" title="Documentation">📖</a> <a href="#infra-mattt" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Juneezee"><img src="https://avatars.githubusercontent.com/u/20135478?v=4?s=100" width="100px;" alt="Eng Zer Jun"/><br /><sub><b>Eng Zer Jun</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=Juneezee" title="Tests">⚠️</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bbedward"><img src="https://avatars.githubusercontent.com/u/550752?v=4?s=100" width="100px;" alt="BB"/><br /><sub><b>BB</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=bbedward" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/williamluer"><img src="https://avatars.githubusercontent.com/u/85975676?v=4?s=100" width="100px;" alt="williamluer"/><br /><sub><b>williamluer</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=williamluer" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://sirupsen.com"><img src="https://avatars.githubusercontent.com/u/97400?v=4?s=100" width="100px;" alt="Simon Eskildsen"/><br /><sub><b>Simon Eskildsen</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=sirupsen" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://erbridge.co.uk"><img src="https://avatars.githubusercontent.com/u/1027364?v=4?s=100" width="100px;" alt="F"/><br /><sub><b>F</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aerbridge" title="Bug reports">🐛</a> <a href="https://github.com/replicate/cog/commits?author=erbridge" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/philandstuff"><img src="https://avatars.githubusercontent.com/u/581269?v=4?s=100" width="100px;" alt="Philip Potter"/><br /><sub><b>Philip Potter</b></sub></a><br /><a href="https://github.com/replicate/cog/issues?q=author%3Aphilandstuff" title="Bug reports">🐛</a> <a href="https://github.com/replicate/cog/commits?author=philandstuff" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/joannejchen"><img src="https://avatars.githubusercontent.com/u/33409024?v=4?s=100" width="100px;" alt="Joanne Chen"/><br /><sub><b>Joanne Chen</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=joannejchen" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://technillogue.github.io"><img src="https://avatars.githubusercontent.com/u/945691?v=4?s=100" width="100px;" alt="technillogue"/><br /><sub><b>technillogue</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=technillogue" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="http://aroncarroll.com"><img src="https://avatars.githubusercontent.com/u/47144?v=4?s=100" width="100px;" alt="Aron Carroll"/><br /><sub><b>Aron Carroll</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=aron" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/commits?author=aron" title="Code">💻</a> <a href="#ideas-aron" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Theodotus1243"><img src="https://avatars.githubusercontent.com/u/32220358?v=4?s=100" width="100px;" alt="Bohdan Mykhailenko"/><br /><sub><b>Bohdan Mykhailenko</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=Theodotus1243" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/issues?q=author%3ATheodotus1243" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/one1zero1one"><img src="https://avatars.githubusercontent.com/u/724604?v=4?s=100" width="100px;" alt="Daniel Radu"/><br /><sub><b>Daniel Radu</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=one1zero1one" title="Documentation">📖</a> <a href="https://github.com/replicate/cog/issues?q=author%3Aone1zero1one" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Etelis"><img src="https://avatars.githubusercontent.com/u/92247226?v=4?s=100" width="100px;" alt="Itay Etelis"/><br /><sub><b>Itay Etelis</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=Etelis" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.wavefunction.dev"><img src="https://avatars.githubusercontent.com/u/54407820?v=4?s=100" width="100px;" alt="Gennaro Schiano"/><br /><sub><b>Gennaro Schiano</b></sub></a><br /><a href="https://github.com/replicate/cog/commits?author=gschian0" title="Documentation">📖</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

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


pkgId: 959bac9f51d1dec382965b6173a2f4a6442d0bcc1e1ac763037753abfcbe867f
name: python-cog2
arch: src
version: 0.2.6
epoch: 0
release: 1
url: https://www.wizmodel.com/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cog2-0.2.6-1.src.rpm
checksum_type: sha256
summary:
  This is the sdk for build a production ready docker container, to learn more please visit WizModel.com

description:
  Use this command to start the virtual environment
  ```commandline
  poetry shell
  ```
  install to current the program virtual environment
  ```commandline
  peotry install
  ```

  build the whl
  ```commandline
  poetry build
  ```

  PyPi token config
  ```commandline
  poetry config pypi-token.pypi pypi-wubalubadubdub-deadbeef1234
  ```

  build and publish
  ```commandline
  poetry publish --build
  ```

  install from pip
  ```commandline
  pip install --user cog2
  ```


pkgId: 368c5d5de13ed99af97f060680ee26694f1ff47afc53c8b7b8530315fb5b5762
name: python-cogdl
arch: src
version: 0.6
epoch: 0
release: 1
summary: An Extensive Research Toolkit for Deep Learning on Graphs
url: https://github.com/THUDM/cogdl
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cogdl-0.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Latest Release](https://badge.fury.io/py/cogdl.svg)](https://pypi.org/project/cogdl/)
  [![Build Status](https://app.travis-ci.com/THUDM/cogdl.svg?branch=master)](https://app.travis-ci.com/THUDM/cogdl)
  [![Documentation Status](https://readthedocs.org/projects/cogdl/badge/?version=latest)](https://cogdl.readthedocs.io/en/latest/?badge=latest)
  [![Downloads](https://pepy.tech/badge/cogdl)](https://pepy.tech/project/cogdl)
  [![Coverage Status](https://coveralls.io/repos/github/THUDM/cogdl/badge.svg?branch=master)](https://coveralls.io/github/THUDM/cogdl?branch=master)
  [![License](https://img.shields.io/github/license/thudm/cogdl)](https://github.com/THUDM/cogdl/blob/master/LICENSE)
  [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  **[Homepage](https://cogdl.ai)** | **[Paper](https://arxiv.org/abs/2103.00959)** | **[Documentation](https://cogdl.readthedocs.io)** | **[Discussion Forum](https://discuss.cogdl.ai)** | **[Dataset](./cogdl/datasets/README.md)** | **[中文](./README_CN.md)**
  CogDL is a graph deep learning toolkit that allows researchers and developers to easily train and compare baseline or customized models for node classification, graph classification, and other important tasks in the graph domain.
  We summarize the contributions of CogDL as follows:
  - **Efficiency**: CogDL utilizes well-optimized operators to speed up training and save GPU memory of GNN models.
  - **Ease of Use**: CogDL provides easy-to-use APIs for running experiments with the given models and datasets using hyper-parameter search.
  - **Extensibility**: The design of CogDL makes it easy to apply GNN models to new scenarios based on our framework.

  - [The CogDL paper](https://arxiv.org/abs/2103.00959) was accepted by [WWW 2023](https://www2023.thewebconf.org/). Find us at WWW 2023! We also release the new **v0.6 release** which adds more examples of graph self-supervised learning, including [GraphMAE](https://github.com/THUDM/cogdl/tree/master/examples/graphmae), [GraphMAE2](https://github.com/THUDM/cogdl/tree/master/examples/graphmae2), and [BGRL](https://github.com/THUDM/cogdl/tree/master/examples/bgrl).
  - A free GNN course provided by CogDL Team is present at [this link](https://cogdl.ai/gnn2022/). We also provide a [discussion forum](https://discuss.cogdl.ai) for Chinese users.
  - The new **v0.5.3 release** supports mixed-precision training by setting \textit{fp16=True} and provides a basic [example](https://github.com/THUDM/cogdl/blob/master/examples/jittor/gcn.py) written by [Jittor](https://github.com/Jittor/jittor). It also updates the tutorial in the document, fixes downloading links of some datasets, and fixes potential bugs of operators.
  <details>
  <summary>
  News History
  </summary>
  <br/>
  - The new **v0.5.2 release** adds a GNN example for ogbn-products and updates geom datasets. It also fixes some potential bugs including setting devices, using cpu for inference, etc.
  - The new **v0.5.1 release** adds fast operators including SpMM (cpu version) and scatter_max (cuda version). It also adds lots of datasets for node classification which can be found in [this link](./cogdl/datasets/rd2cd_data.py). 🎉
  - The new **v0.5.0 release** designs and implements a unified training loop for GNN. It introduces `DataWrapper` to help prepare the training/validation/test data and `ModelWrapper` to define the training/validation/test steps. 🎉
  - The new **v0.4.1 release** adds the implementation of Deep GNNs and the recommendation task. It also supports new pipelines for generating embeddings and recommendation. Welcome to join our tutorial on KDD 2021 at 10:30 am - 12:00 am, Aug. 14th (Singapore Time). More details can be found in https://kdd2021graph.github.io/. 🎉
  - The new **v0.4.0 release** refactors the data storage (from `Data` to `Graph`) and provides more fast operators to speed up GNN training. It also includes many self-supervised learning methods on graphs. BTW, we are glad to announce that we will give a tutorial on KDD 2021 in August. Please see [this link](https://kdd2021graph.github.io/) for more details. 🎉
  - CogDL supports GNN models with Mixture of Experts (MoE). You can install [FastMoE](https://github.com/laekov/fastmoe) and try **[MoE GCN](./cogdl/models/nn/moe_gcn.py)** in CogDL now!
  - The new **v0.3.0 release** provides a fast spmm operator to speed up GNN training. We also release the first version of **[CogDL paper](https://arxiv.org/abs/2103.00959)** in arXiv. You can join [our slack](https://join.slack.com/t/cogdl/shared_invite/zt-b9b4a49j-2aMB035qZKxvjV4vqf0hEg) for discussion. 🎉🎉🎉
  - The new **v0.2.0 release** includes easy-to-use `experiment` and `pipeline` APIs for all experiments and applications. The `experiment` API supports automl features of searching hyper-parameters. This release also provides `OAGBert` API for model inference (`OAGBert` is trained on large-scale academic corpus by our lab). Some features and models are added by the open source community (thanks to all the contributors 🎉).
  - The new **v0.1.2 release** includes a pre-training task, many examples, OGB datasets, some knowledge graph embedding methods, and some graph neural network models. The coverage of CogDL is increased to 80%. Some new APIs, such as `Trainer` and `Sampler`, are developed and being tested.
  - The new **v0.1.1 release** includes the knowledge link prediction task, many state-of-the-art models, and `optuna` support. We also have a [Chinese WeChat post](https://mp.weixin.qq.com/s/IUh-ctQwtSXGvdTij5eDDg) about the CogDL release.
  </details>


  - Python version >= 3.7
  - PyTorch version >= 1.7.1
  Please follow the instructions here to install PyTorch (https://github.com/pytorch/pytorch#installation).
  When PyTorch has been installed, cogdl can be installed using pip as follows:
  ```bash
  pip install cogdl
  ```
  Install from source via:
  ```bash
  pip install git+https://github.com/thudm/cogdl.git
  ```
  Or clone the repository and install with the following commands:
  ```bash
  git clone git@github.com:THUDM/cogdl.git
  cd cogdl
  pip install -e .
  ```


  You can run all kinds of experiments through CogDL APIs, especially `experiment`. You can also use your own datasets and models for experiments.
  A quickstart example can be found in the [quick_start.py](https://github.com/THUDM/cogdl/tree/master/examples/quick_start.py). More examples are provided in the [examples/](https://github.com/THUDM/cogdl/tree/master/examples/).
  ```python
  from cogdl import experiment

  experiment(dataset="cora", model="gcn")

  experiment(dataset="cora", model="gcn", hidden_size=32, epochs=200)

  experiment(dataset="cora", model=["gcn", "gat"], seed=[1, 2])

  def search_space(trial):
      return {
          "lr": trial.suggest_categorical("lr", [1e-3, 5e-3, 1e-2]),
          "hidden_size": trial.suggest_categorical("hidden_size", [32, 64, 128]),
          "dropout": trial.suggest_uniform("dropout", 0.5, 0.8),
      }
  experiment(dataset="cora", model="gcn", seed=[1, 2], search_space=search_space)
  ```

  You can also use `python scripts/train.py --dataset example_dataset --model example_model` to run example_model on example_data.
  - --dataset, dataset name to run, can be a list of datasets with space like `cora citeseer`. Supported datasets include
  'cora', 'citeseer', 'pumbed', 'ppi', 'wikipedia', 'blogcatalog', 'flickr'. More datasets can be found in the [cogdl/datasets](https://github.com/THUDM/cogdl/tree/master/cogdl/datasets).
  - --model, model name to run, can be a list of models like `gcn gat`. Supported models include
  'gcn', 'gat', 'graphsage', 'deepwalk', 'node2vec', 'hope', 'grarep', 'netmf', 'netsmf', 'prone'. More models can be found in the [cogdl/models](https://github.com/THUDM/cogdl/tree/master/cogdl/models).
  For example, if you want to run GCN and GAT on the Cora dataset, with 5 different seeds:
  ```bash
  python scripts/train.py --dataset cora --model gcn gat --seed 0 1 2 3 4
  ```
  Expected output:
  | Variant          | test_acc       | val_acc        |
  |------------------|----------------|----------------|
  | ('cora', 'gcn')  | 0.8050±0.0047  | 0.7940±0.0063  |
  | ('cora', 'gat')  | 0.8234±0.0042  | 0.8088±0.0016  |
  If you have ANY difficulties to get things working in the above steps, feel free to open an issue. You can expect a reply within 24 hours.

  <details>
  <summary>
  How to contribute to CogDL?
  </summary>
  <br/>
  If you have a well-performed algorithm and are willing to implement it in our toolkit to help more people, you can first [open an issue](https://github.com/THUDM/cogdl/issues) and then create a pull request, detailed information can be found [here](https://help.github.com/en/articles/creating-a-pull-request).
  Before committing your modification, please first run `pre-commit install` to setup the git hook for checking code format and style using `black` and `flake8`. Then the `pre-commit` will run automatically on `git commit`! Detailed information of `pre-commit` can be found [here](https://pre-commit.com/).
  </details>
  <details>
  <summary>
  How to enable fast GNN training?
  </summary>
  <br/>
  CogDL provides a fast sparse matrix-matrix multiplication operator called [GE-SpMM](https://arxiv.org/abs/2007.03179) to speed up training of GNN models on the GPU.
  The feature will be automatically used if it is available.
  Note that this feature is still in testing and may not work under some versions of CUDA.
  </details>
  <details>
  <summary>
  How to run parallel experiments with GPUs on several models?
  </summary>
  <br/>
  If you want to run parallel experiments on your server with multiple GPUs on multiple models, GCN and GAT, on the Cora dataset:
  ```bash
  $ python scripts/train.py --dataset cora --model gcn gat --hidden-size 64 --devices 0 1 --seed 0 1 2 3 4
  ```
  Expected output:
  | Variant         | Acc           |
  | --------------- | ------------- |
  | ('cora', 'gcn') | 0.8236±0.0033 |
  | ('cora', 'gat') | 0.8262±0.0032 |
  </details>
  <details>
  <summary>
  How to use models from other libraries?
  </summary>
  <br/>
  If you are familiar with other popular graph libraries, you can implement your own model in CogDL using modules from PyTorch Geometric (PyG).
  For the installation of PyG, you can follow the instructions from PyG (https://github.com/rusty1s/pytorch_geometric/#installation).
  For the quick-start usage of how to use layers of PyG, you can find some examples in the [examples/pyg](https://github.com/THUDM/cogdl/tree/master/examples/pyg/).
  </details>
  <details>
  <summary>
  How to make a successful pull request with unit test
  </summary>
  <br/>
  To have a successful pull request, you need to have at least (1) your model implementation and (2) a unit test.
  You might be confused why your pull request was rejected because of 'Coverage decreased ...' issue even though your model is working fine locally. This is because you have not included a unit test, which essentially runs through the extra lines of code you added. The Travis CI service used by Github conducts all unit tests on the code you committed and checks how many lines of the code have been checked by the unit tests, and if a significant portion of your code has not been checked (insufficient coverage), the pull request is rejected.
  So how do you do a unit test?
  * Let's say you implement a GNN model in a script `models/nn/abcgnn.py` that does the task of node classification. Then, you need to add a unit test inside the script `tests/tasks/test_node_classification.py` (or whatever relevant task your model does).
  * To add the unit test, you simply add a function *test_abcgnn_cora()* (just follow the format of the other unit tests already in the script), fill it with required arguments and the last line in the function *'assert 0 <= ret["Acc"] <= 1'* is the very basic sanity check conducted by the unit test.
  * After modifying `tests/tasks/test_node_classification.py`, commit it together with your `models/nn/abcgnn.py` and your pull request should pass.
  </details>

  CogDL is developed and maintained by [Tsinghua, ZJU, DAMO Academy, and ZHIPU.AI](https://cogdl.ai/about/).
  The core development team can be reached at [cogdlteam@gmail.com](mailto:cogdlteam@gmail.com).

  Please cite [our paper](https://arxiv.org/abs/2103.00959) if you find our code or results useful for your research:
  ```
  @inproceedings{cen2023cogdl,
      title={CogDL: A Comprehensive Library for Graph Deep Learning},
      author={Yukuo Cen and Zhenyu Hou and Yan Wang and Qibin Chen and Yizhen Luo and Zhongming Yu and Hengrui Zhang and Xingcheng Yao and Aohan Zeng and Shiguang Guo and Yuxiao Dong and Yang Yang and Peng Zhang and Guohao Dai and Yu Wang and Chang Zhou and Hongxia Yang and Jie Tang},
      booktitle={Proceedings of the ACM Web Conference 2023 (WWW'23)},
      year={2023}
  }
  ```


pkgId: 1e706ba5ff697e7c18371435f1a4e1b9fbc49b4366b1eacea6f36130d7d5e645
name: python-cogent3-ete3
arch: src
version: 2024.8.22a6
epoch: 0
release: 1
summary: cogent3 plugin for ete3
url: https://pypi.org/project/cogent3-ete3/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cogent3-ete3-2024.8.22a6-1.src.rpm
checksum_type: sha256
description:
  [![Coverage Status](https://coveralls.io/repos/github/YapengLang/cogent3-ete3/badge.svg?branch=main)](https://coveralls.io/github/YapengLang/cogent3-ete3?branch=main)



  Developed an app that takes a cogent3 `PhyloNode` then returns an ete3 `PhyloTree`, plus an app for edge colouring.


  ```
  from cogent3 import load_tree, get_app
  from cogent3_ete3.style import show_legend

  tree = load_tree("data/tree_large_scale.newick")

  conv = get_app("cogent3_to_ete3")
  t = conv(tree)
  ```
  `t` is an ete3 `PhyloTree`.


  The `ete3_colour_edge` app allows you to colour information on selected edges. The app applies a colour to named edges. This means for colouring internal edges the node must have names.

  ```
  edge_to_cat = {"Vombatidae_Vombatus_ursinus": "A",
   "Dasyuridae_Sarcophilus_harrisii": "B",
   "Peramelidae_Echymipera_kalubu" : "C",
   "Pseudochiridae_Pseudochirulus_forbesi": "D"}

  cat_to_colour={"A":"blue",
   "B":"blue",
   "C":"red",
   "D":"orange"}

  cl = get_app("ete3_colour_edge", edge_to_cat=edge_to_cat, cat_to_colour=cat_to_colour)
  t = cl(t)
  ```

  You can use the convenient function to show a legend.

  ```
  show_legend(t, cat_to_colour, legend_title="Your Category")
  ```

  In the pop-up window, you can explore further and render the tree in a file as you progress:

  ![Tree Plot](data/coloured_tree.png)


