# packages

pkgId: 740a3f17058a9f6db18452d81beb87ae067f305b80b3aa9b8a887fbc30555c1f
name: python-cogflow
arch: src
version: 1.9.39
epoch: 0
release: 1
summary: COG modules
url: https://pypi.org/project/cogflow/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cogflow-1.9.39-1.src.rpm
checksum_type: sha256
description:
  By setting the environment variables correctly, you can fully utilize the features and functionalities of the CogFlow framework for your cognitive and machine learning tasks.


pkgId: 515005214bb9ca43736694fa9c276478163ce1fd08868bbdd9cf6b90e0906aa9
name: python-cognee
arch: src
version: 0.1.19
epoch: 0
release: 1
url: https://www.cognee.ai
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognee-0.1.19-1.src.rpm
checksum_type: sha256
summary:
  Cognee - is a library for enriching LLM context with a semantic layer for better understanding and reasoning.

description:
  [![GitHub forks](https://img.shields.io/github/forks/topoteretes/cognee.svg?style=social&label=Fork&maxAge=2592000)](https://GitHub.com/topoteretes/cognee/network/)
  [![GitHub stars](https://img.shields.io/github/stars/topoteretes/cognee.svg?style=social&label=Star&maxAge=2592000)](https://GitHub.com/topoteretes/cognee/stargazers/)
  [![GitHub commits](https://badgen.net/github/commits/topoteretes/cognee)](https://GitHub.com/topoteretes/cognee/commit/)
  [![Github tag](https://badgen.net/github/tag/topoteretes/cognee)](https://github.com/topoteretes/cognee/tags/)
  [![Downloads](https://static.pepy.tech/badge/cognee)](https://pepy.tech/project/cognee)
  [![GitHub license](https://badgen.net/github/license/topoteretes/cognee)](https://github.com/topoteretes/cognee/blob/master/LICENSE)


  We build for developers who need a reliable, production-ready data layer for AI applications




  Cognee implements scalable, modular ECL (Extract, Cognify, Load) pipelines that allow you to interconnect and retrieve past conversations, documents, and audio transcriptions while reducing hallucinations, developer effort, and cost.
  Try it in a Google Colab  <a href="https://colab.research.google.com/drive/1g-Qnx6l_ecHZi0IOw23rg0qC4TYvEvWZ?usp=sharing">notebook</a>  or have a look at our <a href="https://topoteretes.github.io/cognee">documentation</a>

  If you have questions, join our  <a href="https://discord.gg/NQPKmU5CCg">Discord</a> community









  ```bash
  pip install cognee
  ```



  ```bash
  pip install 'cognee[postgres]'
  ```



  ```bash
  poetry add cognee
  ```



  ```bash
  poetry add cognee -E postgres
  ```





  ```
  import os

  os.environ["LLM_API_KEY"] = "YOUR OPENAI_API_KEY"

  ```
  or
  ```
  import cognee
  cognee.config.set_llm_api_key("YOUR_OPENAI_API_KEY")
  ```
  You can also set the variables by creating .env file, here is our <a href="https://github.com/topoteretes/cognee/blob/main/.env.template">template.</a>
  To use different LLM providers, for more info check out our <a href="https://topoteretes.github.io/cognee">documentation</a>

  If you are using Network, create an account on Graphistry to visualize results:
  ```
  cognee.config.set_graphistry_config({
      "username": "YOUR_USERNAME",
      "password": "YOUR_PASSWORD"
  })
  ```

  (Optional) To run the UI, go to cognee-frontend directory and run:
  ```
  npm run dev
  ```
  or run everything in a docker container:
  ```
  docker-compose up
  ```
  Then navigate to localhost:3000

  If you want to use the UI with PostgreSQL through docker-compose make sure to set the following values in the .env file:
  ```
  DB_PROVIDER=postgres

  DB_HOST=postgres
  DB_PORT=5432

  DB_NAME=cognee_db
  DB_USERNAME=cognee
  DB_PASSWORD=cognee
  ```



  First, copy `.env.template` to `.env` and add your OpenAI API key to the LLM_API_KEY field.

  Optionally, set `VECTOR_DB_PROVIDER="lancedb"` in `.env` to simplify setup.

  This script will run the default pipeline:

  ```python
  import cognee
  import asyncio
  from cognee.api.v1.search import SearchType

  async def main():
      
      await cognee.prune.prune_data()
      
      await cognee.prune.prune_system(metadata=True)

      text = """
      Natural language processing (NLP) is an interdisciplinary
      subfield of computer science and information retrieval.
      """

      
      await cognee.add(text)

      
      await cognee.cognify()

      
      search_results = await cognee.search(
          SearchType.INSIGHTS,
          "Tell me about NLP",
      )

      
      for result_text in search_results:
          print(result_text)
          
          
          

  asyncio.run(main())
  ```
  A version of this example is here: `examples/pyton/simple_example.py`



  cognee framework consists of tasks that can be grouped into pipelines.
  Each task can be an independent part of business logic, that can be tied to other tasks to form a pipeline.
  These tasks persist data into your memory store enabling you to search for relevant context of past conversations, documents, or any other data you have stored.




  Here is an example of how it looks for a default cognify pipeline:

  1. To prepare the data for the pipeline run, first we need to add it to our metastore and normalize it:

  Start with:
  ```
  text = """Natural language processing (NLP) is an interdisciplinary
         subfield of computer science and information retrieval"""

  await cognee.add(text) # Add a new piece of information
  ```

  2. In the next step we make a task. The task can be any business logic we need, but the important part is that it should be encapsulated in one function.

  Here we show an example of creating a naive LLM classifier that takes a Pydantic model and then stores the data in both the graph and vector stores after analyzing each chunk.
  We provided just a snippet for reference, but feel free to check out the implementation in our repo.

  ```
  async def chunk_naive_llm_classifier(
      data_chunks: list[DocumentChunk],
      classification_model: Type[BaseModel]
  ):
      
      chunk_classifications = await asyncio.gather(
          *(extract_categories(chunk.text, classification_model) for chunk in data_chunks)
      )

      
      classification_data_points = {
          uuid5(NAMESPACE_OID, cls.label.type)
          for cls in chunk_classifications
      } | {
          uuid5(NAMESPACE_OID, subclass.value)
          for cls in chunk_classifications
          for subclass in cls.label.subclass
      }

      vector_engine = get_vector_engine()
      collection_name = "classification"

      
      class Keyword(BaseModel):
          uuid: str
          text: str
          chunk_id: str
          document_id: str

      
      if not await vector_engine.has_collection(collection_name):
          await vector_engine.create_collection(collection_name, payload_schema=Keyword)
          existing_points_map = {}
      else:
          existing_points_map = {}
      return data_chunks

  ...

  ```

  We have many tasks that can be used in your pipelines, and you can also create your  tasks to fit your business logic.


  3. Once we have our tasks, it is time to group them into a pipeline.
  This simplified snippet demonstrates how tasks can be added to a pipeline, and how they can pass the information forward from one to another.

  ```


  Task(
      chunk_naive_llm_classifier,
      classification_model = cognee_config.classification_model,
  )

  pipeline = run_tasks(tasks, documents)

  ```

  To see the working code, check cognee.api.v1.cognify default pipeline in our repo.




  Cognee supports a variety of tools and services for different operations:
  - **Modular**: Cognee is modular by nature, using tasks grouped into pipelines

  - **Local Setup**: By default, LanceDB runs locally with NetworkX and OpenAI.

  - **Vector Stores**: Cognee supports LanceDB, Qdrant, PGVector and Weaviate for vector storage.

  - **Language Models (LLMs)**: You can use either Anyscale or Ollama as your LLM provider.

  - **Graph Stores**: In addition to NetworkX, Neo4j is also supported for graph storage.

  - **User management**: Create individual user graphs and manage permissions



  Check out our demo notebook [here](https://github.com/topoteretes/cognee/blob/main/notebooks/cognee_demo.ipynb)



  [<img src="https://i3.ytimg.com/vi/-ARUfIzhzC4/maxresdefault.jpg" width="100%">](https://www.youtube.com/watch?v=BDFt4xVPmro "Learn about cognee: 55")






  Please see the [cognee Quick Start Guide](https://topoteretes.github.io/cognee/quickstart/) for important configuration information.

  ```bash
  docker compose up
  ```




  Please see the cognee [Development Guide](https://topoteretes.github.io/cognee/quickstart/) for important beta information and usage instructions.

  ```bash
  pip install cognee
  ```



  [![Star History Chart](https://api.star-history.com/svg?repos=topoteretes/cognee&type=Date)](https://star-history.com/#topoteretes/cognee&Date)




  <a href="https://github.com/topoteretes/cognee/graphs/contributors">
    <img alt="contributors" src="https://contrib.rocks/image?repo=topoteretes/cognee"/>
  </a>


pkgId: d2af47811d13c1d57daaad71b9d40e1c150f1cb7c740e239b2e8314de289afc7
name: python-cognicept-shell
arch: src
version: 1.7.6
epoch: 0
release: 1
summary: Shell utility to configure Cognicept tools.
url: https://kabam.ai
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognicept-shell-1.7.6-1.src.rpm
checksum_type: sha256
description:
  platform linux -- Python 3.8.19, pytest-6.1.1, py-1.9.0, pluggy-0.13.1
  rootdir: /
  plugins: mock-3.12.0, cov-2.10.1
  collected 165 items
  tests/functional/test_config.py .........s.....                                                         [  9%]
  tests/functional/test_disk_space.py .                                                                   [  9%]
  tests/functional/test_move.py ........                                                                  [ 14%]
  tests/functional/test_push.py ..........                                                                [ 20%]
  tests/functional/test_record.py ..........                                                              [ 26%]
  tests/unit/test_config.py ................                                                              [ 36%]
  tests/unit/test_get_disk_space.py .                                                                     [ 36%]
  tests/unit/test_get_robot_org_id.py ......                                                              [ 40%]
  tests/unit/test_keyrotate.py ...                                                                        [ 42%]
  tests/unit/test_lifecycle.py .............................                                              [ 60%]
  tests/unit/test_move.py ..................................................                              [ 90%]
  tests/unit/test_populate_config_files.py ....                                                           [ 92%]
  tests/unit/test_pull_config_templates.py ...                                                            [ 94%]
  tests/unit/test_update_event_log.py ......                                                              [ 98%]


pkgId: 512f87cf76e0d8034d92bd7f61a35021190321d84726bd46876ad03c1852fef9
name: python-cognidb
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: A tool for generating SQL queries
url: https://github.com/boxed-dev/cognidb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognidb-0.2.5-1.src.rpm
checksum_type: sha256
description:
  A utility that provides seamless database access to your agents with a single line of code.



  ```bash
  pip install cognidb
  ```





  ```bash

  HOST=localhost
  PORT=3306
  DATABASE=your_database
  USER=your_username
  PASSWORD=your_password


  OPENAI_API_KEY=your-openai-api-key
  ```



  ```python
  from cognidb import CogniDB

  db = CogniDB(
      db_type="mysql",  # or "postgresql"
      host="localhost",
      port=3306,
      dbname="your_database",
      user="your_username",
      password="your_password",
      api_key="your-openai-api-key"  # Optional if set in .env
  )
  ```



  ```python
  from cognidb import CogniDB


  db = CogniDB(db_type="mysql")


  result = db.query("Show me all customers")


  result = db.query("Show transactions from last month")
  ```



  ```python

  customers = db.query("List all premium customers")


  summary = db.query("Total sales by product category")


  analysis = db.query("Find customers who spent more than average")
  ```



  ```python
  try:
      db = CogniDB(db_type="mysql")
      result = db.query("Show customer accounts")
  except ValueError as e:
      print(f"Configuration error: {e}")
  except Exception as e:
      print(f"Query error: {e}")
  ```



  - openai
  - psycopg2
  - mysql-connector-python
  - sqlparse
  - psycopg2-binary



  MIT License © 2024



  1. Fork the repository
  2. Create a feature branch
  3. Submit a pull request



  For support or questions, contact:
  Rishabh Kumar
  [rishabh.vaaiv@gmail.com](mailto:rishabh.vaaiv@gmail.com)


pkgId: 69ff9ab5f270cac0bc413b299f66cc64fba4a09edd204487dff8801747cd6591
name: python-cognify-ai
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: The Automated Optimizer for GenAI Workflows
url: https://github.com/GenseeAI/cognify
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognify-ai-0.1.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://github.com/GenseeAI/cognify/blob/main/cognify.jpg?raw=true" alt="Cognify logo">
  </p>



  Building high-quality, cost-effective generative-AI (gen-AI) applications is challenging due to the absence of systematic methods for tuning, testing, and optimizing them.
  We introduce **Cognify**, a tool that automatically enhances generation quality and reduces costs for gen-AI workflows, including those written with LangChain, DSPy, and annotated Python.
  Built on a novel foundation of hierarchical, workflow-level optimization, **Cognify** improves gen-AI workflow generation quality by up to 48% and reduces their execution cost by up to 9 times.
  Read more about **Cognify** [here](https://mlsys.wuklab.io/posts/cognify/).



  Cognify is available as a Python package and can be installed as
  ```
  pip install cognify-ai
  ```

  Or install from the source:
  ```
  git clone https://github.com/GenseeAI/cognify
  cd cognify
  pip install -e .
  ```



  You can use Cognify with our simple CLI:
  ```bash
  cognify optimize /your/gen/ai/workflow.py
  ```
  where `workflow.py` is your workflow source code. Cognify currently supports unmodified [LangChain](https://github.com/langchain-ai/langchain) and [DSPy](https://github.com/stanfordnlp/dspy) workflow source code. You can also port your existing workflow written directly on Python or develop new Python-based workflows with our [simple workflow interface](https://cognify-ai.readthedocs.io/en/latest/user_guide/tutorials/interface/program.html).

  Cognify automatically searches for a `config.py` in the same folder as the workflow. You can also specify this file explicitly by:
  ```bash
  cognify optimize /your/gen/ai/workflow.py -c /your/gen/ai/custom_config.py
  ```

  Within the `config.py`, you should define the following:

  - **Sample Dataset**: Cognify relies on training data to evaluate and improve its workflow optimization. You should provide a data loader that loads your training dataset in the form of input-output pairs. Read more about how to [load your data](https://cognify-ai.readthedocs.io/en/latest/user_guide/tutorials/dataloader.html).
  - **Evaluator**: Cognify expects you to provide an evaluator for judging the final workflow generation's quality. To help you get started, Cognify provides several common evaluator implementations such as the F1 score. Find out more about [workflow evaluator](https://cognify-ai.readthedocs.io/en/latest/user_guide/tutorials/evaluator.html).
  - **Optimization Configurations and Model Set Selection**: Optionally, you can configure your optimization process in various ways. For example, you can choose between light, medium, or heavy search over the optimization space. We also provide a few domain-specific optimization configurations. You can also define the set of models you want Cognify to explore. If no configurations or models are provided, Cognify uses a default set of values. Read more about [optimization configurations and model selections](https://cognify-ai.readthedocs.io/en/latest/user_guide/tutorials/optimizer.html).

  With these parameters, Cognify optimizes your workflow by iteratively experimenting with various combinations of tuning methods (we call them “*cogs*”) applied across workflow components and assessing the effectiveness of these combinations based on the quality of the final output using the user-provided sample dataset and evaluator. This process continues until Cognify hits the user-specified maximum iteration numbers (in `cognify.py`).

  The result of this process is a set of optimized workflow versions with different quality-cost combinations on the [Pareto frontier](https://en.wikipedia.org/wiki/Pareto_front) among all the iterations.
  You can inspect the optimizations applied in these output files
  You can evaluate these optimized versions with a test dataset:

  ```bash
  cognify evaluate /your/gen/ai/workflow/optimization/output/path
  ```

  You can also continue running Cognify with more iterations from these outputs using the `-r` or `--resume` flag:

  ```bash
  cognify optimize /your/gen/ai/workflow.py -r
  ```

  Follow our [quickstart](https://cognify-ai.readthedocs.io/en/latest/user_guide/quickstart.html) or read our full [documentation](https://cognify-ai.readthedocs.io/en/latest/) to learn more.

  - [User Guide](https://cognify-ai.readthedocs.io/en/latest/user_guide/): A Cognify user guide consists of a quickstart and a step-by-step tutorial
  - [Fundamentals](https://cognify-ai.readthedocs.io/en/latest/fundamentals/): Fundamental concepts about Cognify internals
  - [API Reference](https://cognify-ai.readthedocs.io/en/latest/api_ref/modules.html)

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


pkgId: ba927978b46c768801eba732c1038146c7c7195f78132726105cc078d1894799
name: python-cognite-ai
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: A set of AI tools for working with Cognite Data Fusion in Python.
url: https://pypi.org/project/cognite-ai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-ai-0.6.1-1.src.rpm
checksum_type: sha256
description:
  With `cognite-ai`, you can enhance your data workflows by integrating LLMs for intuitive querying and manipulation of data frames. The module is built on top of [PandasAI](https://docs.pandas-ai.com/en/latest/) and adds Cognite-specific features.
  The Smart Data Tools come in three components:
  Pandas Smart DataFrame
  Pandas Smart DataLake
  Pandas AI Agent

  `SmartDataframe` enables you to chat with individual data frames, using LLMs to query, summarize, and analyze your data conversationally.

  ```python
  from cognite.ai import load_pandasai
  from cognite.client import CogniteClient
  import pandas as pd

  client = CogniteClient()
  SmartDataframe, SmartDatalake, Agent = await load_pandasai()

  workorders_df = pd.DataFrame({
      "workorder_id": ["WO001", "WO002", "WO003", "WO004", "WO005"],
      "description": [
          "Replace filter in compressor unit 3A",
          "Inspect and lubricate pump 5B",
          "Check pressure valve in unit 7C",
          "Repair leak in pipeline 4D",
          "Test emergency shutdown system"
      ],
      "priority": ["High", "Medium", "High", "Low", "Medium"]
  })

  s_workorders_df = SmartDataframe(workorders_df, cognite_client=client)

  s_workorders_df.chat('Which 5 work orders are the most critical based on priority?')
  ```

  You can configure the LLM parameters to control aspects like model selection and temperature.
  ```python
  params = {
      "model": "gpt-35-turbo",
      "temperature": 0.5
  }
  s_workorders_df = SmartDataframe(workorders_df, cognite_client=client, params=params)
  ```

  `SmartDatalake` allows you to combine and query multiple data frames simultaneously, treating them as a unified data lake.

  ```python
  from cognite.ai import load_pandasai
  from cognite.client import CogniteClient
  import pandas as pd

  client = CogniteClient()
  SmartDataframe, SmartDatalake, Agent = await load_pandasai()

  workorders_df = pd.DataFrame({
      "workorder_id": ["WO001", "WO002", "WO003"],
      "asset_id": ["A1", "A2", "A3"],
      "description": ["Replace filter", "Inspect pump", "Check valve"]
  })
  workitems_df = pd.DataFrame({
      "workitem_id": ["WI001", "WI002", "WI003"],
      "workorder_id": ["WO001", "WO002", "WO003"],
      "task": ["Filter replacement", "Pump inspection", "Valve check"]
  })
  assets_df = pd.DataFrame({
      "asset_id": ["A1", "A2", "A3"],
      "name": ["Compressor 3A", "Pump 5B", "Valve 7C"]
  })

  smart_lake_df = SmartDatalake([workorders_df, workitems_df, assets_df], cognite_client=client)

  smart_lake_df.chat("Which assets have the most work orders associated with them?")
  ```

  The `Agent` provides conversational querying capabilities across a single data frame, allowing you to have follow up questions.

  ```python
  from cognite.ai import load_pandasai
  from cognite.client import CogniteClient
  import pandas as pd

  client = CogniteClient()
  SmartDataframe, SmartDatalake, Agent = await load_pandasai()

  sensor_readings_df = pd.DataFrame({
      "sensor_id": ["A1", "A2", "A3", "A4", "A5"],
      "temperature": [75, 80, 72, 78, 69],
      "pressure": [30, 35, 33, 31, 29],
      "status": ["Normal", "Warning", "Normal", "Warning", "Normal"]
  })

  agent = Agent(sensor_readings_df, cognite_client=client)

  print(agent.chat("Which sensors are showing a warning status?"))
  ```

  This package exists mainly to provide a in memory vector store
  in addition to getting around the install problems
  a user gets in Pyodide when installing `pandasai` due to
  dependencies that are not pure Python 3 wheels.
  The current development cycle is not great, but consists of copying the contents
  of the source code in this package into e.g. a Jupyter notebook
  in Fusion to verify that everything works there.


pkgId: 08e39d31bf84d8dc27efba89ba8fc1236eac16b26b1146684428ae8976f75c00
name: python-cognite-extractor-manager
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A project manager for Python based extractors
url: https://pypi.org/project/cognite-extractor-manager/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-extractor-manager-1.1.1-1.src.rpm
checksum_type: sha256
description:
  `cogex` is a tool for managing extractors for Cognite Data Fusion written in Python. It provides
  utilities for initializing a new extractor project and building self-contained executables of Python
  based extractors.




  `pyenv` is a neat tool for managing Python installations.

  Since `cogex` uses PyInstaller to build executables, we need Python to be installed with a shared
  instance of `libpython`, which `pyenv` does not do by default. To fix this, make sure to add the
  `--enable-shared` flag when installing new Python versions with `pyenv`, like so:

  ```bash
  env PYTHON_CONFIGURE_OPTS="--enable-shared" pyenv install 3.9.0
  ```

  You can read more about it in the [PyInstaller documentation](https://pyinstaller.readthedocs.io/en/stable/development/venv.html#pyenv-and-pyinstaller)







  To start a new extractor project, move to the desired directory and run

  ```bash
  cogex init
  ```

  You will first be prompted for some information, before `cogex` will initialize a new project.




  Extractor projects initiated with `cogex` will use `poetry` for managing dependencies. Running
  `cogex init` will automatically install the Cognite SDK and extractor-utils framework, but if your
  extractor needs any other dependency, simply add them using `poetry`, like so:

  ```bash
  poetry add requests
  ```




  It is recommended that you run code checkers on your extractor, in particular:

   * `black` is an opinionated code style checker that will enforce a consistent code style throughout
     your project. This is useful to avoid unecessary changes and minimizing PR diffs.
   * `isort` is a tool that sorts your imports, also contributing to a consistent code style and
     minimal PR diffs.
   * `mypy` is a static type checker for Python which ensures that you are not making any type errors
     in your code that would go unnoticed before suddently breaking your extractor in production.

  `cogex` will install all of these, and automatically run them on every commit. If you for some
  reason need to perform a commit despite one of these failing, you can run `git commit --no-verify`,
  although this is not recommended.






  It is not always an option to rely on a Python installation at the machine your extractor will be
  deployed at. For those scenarios it is useful to package the extractor, including its dependencies
  and the Python runtime, into a single self-contained executable. To do this, run

  ```bash
  cogex build
  ```

  This will create a new executable (for the operating system you ran `cogex build` from) in the
  `dist` directory.



  To build a docker image, you first need to add a `[tools.cogex.docker]` section to your pyproject
  file. The required fields are

   * `tags`: A list of tags to tag the resulting image with. These support some simple templating, if
     you include `{version}` in your tag, it will be replaced with the current version of the
     extractor. `{major}` will be replaced with the current major version.
   * If your `[tool.poetry.scripts]` includes multiple entries, you need to specify which one to use
     in the docker image with the `entrypoint` field

  In addition, you have some additional fields:

   * `base-image`: Which base image to use. By default, the `debian-slim` based python image for the
     python version currently running with be chosen.
   * `install-dir` if you want to specify where in the image the extractor should be installed
   * `preamble` which can contain additional dockerimage statements to run in the beginning of the
     dockerfile.

  Minimal example:

  ``` toml
  [tool.cogex.docker]
  tags = ["cognite/my-extractor:{version}"]
  ```

  Larger example (from the DB Extractor):

  ``` toml
  [tool.cogex.docker]
  base-image = "python:3.10"
  preamble = """
  RUN apt-get update \
      && apt-get dist-upgrade -y dirmngr gnupg gnupg-l10n gnupg-utils gpg gpg-agent gpg-wks-client gpg-wks-server \
      && gpgconf gpgsm gpgv libssl-dev libssl1.1 openssl
  RUN apt-get install -y apt-utils build-essential
  RUN apt-get install -y unixodbc-dev unixodbc
  """
  tags = [
      "eu.gcr.io/cognite-registry/db-extractor-base:latest",
      "eu.gcr.io/cognite-registry/db-extractor-base:{version}",
      "cognite/db-extractor-base:{version}",
  ]
  ```

  You can now build and tag docker images with

  ``` commandline
  cogex build --dockerimage
  ```

  If you just want to see the generated dockerfile, instead run

  ``` commandline
  cogex build --dockerfile
  ```




  To keep track of which version of the code base is running at a given deployment it is very useful
  to version your extractor. When releasing a new version, run

  ```bash
  poetry version [patch/minor/major]
  ```

  To automatically bump the corresponding version number. Note that this only updates the version
  number in `pyproject.toml`. When running `cogex build` this new version number will be propagated
  through the rest of the code base.

  Any extractor project should follow semantic versioning, which means you should bump

   * `patch` for any minor bug fixes or improvements
   * `minor` for new features or bigger improvements that __doesn't__ break compatability
   * `major` for new feature or improvements that breaks compatability with previous versions, in
     other words for those scenarios where the new version is not a drop-in replacement for an old
     version. For example:
     - When adding a new required config field
     - When removing a config field
     - When changing defaults in a way that could break existing deployments


pkgId: 95a2c56c7a9d9b23c7c8ab75147cf80756d23d688de21a95e968caf224b4fbe4
name: python-cognite-extractor-utils
arch: src
version: 7.5.0
epoch: 0
release: 1
summary: Utilities for easier development of extractors for CDF
url: https://github.com/cognitedata/python-extractor-utils
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-extractor-utils-7.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/cognitedata/python-extractor-utils/workflows/release/badge.svg)](https://github.com/cognitedata/python-extractor-utils/actions)
  [![Documentation Status](https://readthedocs.com/projects/cognite-extractor-utils/badge/?version=latest&token=a9bab88214cbf624706005f6a71bbd77964efc910f8e527c7b3d75edc016397c)](https://cognite-extractor-utils.readthedocs-hosted.com/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/cognitedata/python-extractor-utils/branch/master/graph/badge.svg?token=7AmVCpAh7I)](https://codecov.io/gh/cognitedata/python-extractor-utils)
  [![PyPI version](https://badge.fury.io/py/cognite-extractor-utils.svg)](https://pypi.org/project/cognite-extractor-utils)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cognite-extractor-utils)
  [![License](https://img.shields.io/github/license/cognitedata/python-extractor-utils)](LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  The `extractor-utils` package is an extension of the Cognite Python SDK intended to simplify the development of data
  extractors or other integrations for Cognite Data Fusion.
  Documentation is hosted [here](https://cognite-extractor-utils.readthedocs-hosted.com/en/latest/), including a
  [quickstart tutorial](https://cognite-extractor-utils.readthedocs-hosted.com/en/latest/quickstart.html).
  The changelog is found [here](./CHANGELOG.md).

  The best way to start a new extractor project is to use the `cogex` CLI. You can install that from PyPI:
  ``` bash
  pip install cognite-extractor-manager
  ```
  To initialize a new extractor project, run
  ``` bash
  cogex init
  ```
  in the directory you want your extractor project in. The `cogex` CLI will prompt you for some information about your
  project, and then set up a poetry environment, git repository, commit hooks with type and style checks and load a
  template.

  Some source systems have a lot in common, such as RESTful APIs or systems exposing as MQTT. We therefore have extensions
  to `extractor-utils` tailroed to these protocols. These can be found in separate packages:
   * [REST extension](https://github.com/cognitedata/python-extractor-utils-rest)
   * [MQTT extension](https://github.com/cognitedata/python-extractor-utils-mqtt)

  The package is open source under the [Apache 2.0 license](./LICENSE), and contribtuions are welcome.
  This project adheres to the [Contributor Covenant v2.0](https://www.contributor-covenant.org/version/2/0/code_of_conduct/)
  as a code of conduct.

  We use [poetry](https://python-poetry.org) to manage dependencies and to administrate virtual environments. To develop
  `extractor-utils`, follow the following steps to set up your local environment:
   1. [Install poetry](https://python-poetry.org/docs/#installation) if you haven't already.
   2. Clone repository:
      ```
      $ git clone git@github.com:cognitedata/python-extractor-utils.git
      ```
   3. Move into the newly created local repository:
      ```
      $ cd python-extractor-utils
      ```
   4. Create virtual environment and install dependencies:
      ```
      $ poetry install
      ```

  All code must pass [black](https://github.com/ambv/black) and [isort](https://github.com/timothycrosley/isort) style
  checks to be merged. It is recommended to install pre-commit hooks to ensure this locally before commiting code:
  ```
  $ poetry run pre-commit install
  ```
  Each public method, class and module should have docstrings. Docstrings are written in the [Google
  style](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings). Please include unit and/or
  integration tests for submitted code, and remember to update the [changelog](./CHANGELOG.md).


pkgId: db5e3437c46d56c5eebad0133168c585dd6e0e80934da9e0f8cbf35ed4fd3f43
name: python-cognite-geospatial-sdk
arch: src
version: 0.10.4
epoch: 0
release: 1
summary: Cognite Geospatial SDK store and query spatial objects in 2D and 3D space
url: https://pypi.org/project/cognite-geospatial-sdk/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-geospatial-sdk-0.10.4-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cognite-geospatial-sdk.svg)](https://pypi.org/project/cognite-geospatial-sdk/)

  Cognite Geospatial SDK for developers and data scientists working with Cognite Data Fusion (CDF).

  A Python Geospatial SDK for the geospatial API.

  In order to start using the Python SDK, you need
  - Python3 (>= 3.5) and pip
  - An API key. Never include the API key directly in the code or upload the key to github. Instead, set the API key as an environment variable. See the usage example for how to authenticate with the API key.
  This is how you set the API key as an environment variable on Mac OS and Linux:
  ```bash
  $ export COGNITE_API_KEY=<your API key>
  ```

  To install this package:
  ```bash
  $ pip install cognite-geospatial-sdk
  ```


pkgId: fcdbc95e99078829257593f86ab4df4f37d49fe0ae6779c88c9522c2dfbf5a9b
name: python-cognite-gql-pygen
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Cognite GraphQL Python Generation SDK
url: https://pypi.org/project/cognite-gql-pygen/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-gql-pygen-0.8.1-1.src.rpm
checksum_type: sha256
description:
  **THIS PACKAGE HAS BEEN RENAMED** It is now called `cognite-pygen`
  * New pypy.org: [https://pypi.org/project/cognite-pygen/](https://pypi.org/project/cognite-pygen/).


pkgId: b41a82a228e9e5e947a1017bbb97c4000c1add54f1e6372fa5927ed6761e95d1
name: python-cognite-neat
arch: src
version: 0.100.0
epoch: 0
release: 1
summary: Knowledge graph transformation
url: https://cognite-neat.readthedocs-hosted.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-neat-0.100.0-1.src.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/neat/release.yaml?style=for-the-badge)](https://github.com/cognitedata/neat/actions/workflows/release.yaml)
  [![Documentation Status](https://readthedocs.com/projects/cognite-neat/badge/?version=latest&style=for-the-badge)](https://cognite-neat.readthedocs-hosted.com/en/latest/?badge=latest)
  [![Github](https://shields.io/badge/github-cognite/neat-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/neat)
  [![PyPI](https://img.shields.io/pypi/v/cognite-neat?style=for-the-badge)](https://pypi.org/project/cognite-neat/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-neat?style=for-the-badge)](https://pypistats.org/packages/cognite-neat)
  [![Docker Pulls](https://img.shields.io/docker/pulls/cognite/neat?style=for-the-badge)](https://hub.docker.com/r/cognite/neat)
  [![GitHub](https://img.shields.io/github/license/cognitedata/neat?style=for-the-badge)](https://github.com/cognitedata/neat/blob/master/LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)

  This is python package handles transformation of domain knowledge graphs (more detailed, overarching) to app specific knowledge graphs.
  Documenation available at [https://thisisneat.io](https://thisisneat.io).





  `neat` can be installed as a Python package, and a docker image for more robust execution and support such
  as `graphdb` for caching. This quickstart guide uses the Python package.



  Running NEAT as docker container :
  `docker run -p 8000:8000 --name neat cognite/neat:latest`

  Runnin NEAT as docker container with local data folder mounted :
  `docker run -p 8000:8000 --name neat -v $(shell pwd)/docker/vol_data:/app/data  cognite/neat:latest`



  Prerequisites:

  - `poetry` installed on your system, [see installation](https://python-poetry.org/docs/).
  - `npm` installed on your system, [see installation](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)
  - `react-scripts` installed on your system, [`npm i react-scripts`](https://www.npmjs.com/package/react-scripts)

  1. Clone this repo: `git clone git@github.com:cognitedata/neat.git`
  2. Create wheel: `make build-python`. This will create a wheel in the `dist` folder.
  3. Install wheel in your preferred environment, `pip install dist/neat-[NEAT_VERSTION]-py3-none-any.whl`



  Once installed you can run neat with the command

  ```bash
  neat
  ```

  This will open your browser and launch the neat application.

  Note this will automatically create a `data` folder in your current working directory, which is populated
  with default workflows, rule sheets, and source graphs. In addition, there is a `config.yaml` you can add
  your CDF credentials to allow `neat` access CDF.

  ![launch_neat](https://user-images.githubusercontent.com/60234212/228812422-c5e9519f-19e7-4f08-9617-66a790323c7e.gif)



  [Documentation](https://cognite-neat.readthedocs-hosted.com/en/latest/)

  ![](./docs/figs/high-level-io.png)



  `make build-docker`



  Run the command :

  ` make compose-up`

  The command starts NEAT container and GraphDB container and creates _vol_data_ and _vol_shared_ local folders that are mounted as volumes.

  _vol_data_ - is mounted only in NEAT container. It contains `config.yaml`, `workflows`, `rules`. You can set `load_examples` to `true` to populate it with examples.

  _vol_shared_ - is mounted to both containers and files placed here become automatically visible for GraphDB import process. Main intension is to write files from NEAT container and make them available for GraphDB for import.



  `http://localhost:8000`

  Open API docs :

  `http://localhost:8000/docs`




  All configurations are divided into 2 categories :

  - global configurations - global for entire service , loaded at startup (config.yaml)
  - workflow configurations - local to workflow , loaded from workflow manifest (.yaml)



  Global configurations loaded by the application during startup process, either from ENV variables or file.

  The application tries to load the configuration as follows.

  1. Try ENV variables. This is done by checking for the ENV variable `NEAT_CDF_PROJECT`, and if it exists load the rest
     as they are listed below.
  2. Try from file. This is done by checking the ENV variable `NEAT_CONFIG_PATH`, which defaults to `$(cwd)/config.yaml`,
     for a path. The config file es expected to have the structure as shown below.
  3. Exit. It the ENV variable `NEAT_CDF_PROJECT` and the config file does not exist, the applications exists.



  - NEAT_CDF_PROJECT
  - NEAT_CDF_CLIENT_NAME
  - NEAT_CDF_CLIENT_ID
  - NEAT_CDF_CLIENT_SECRET
  - NEAT_CDF_BASE_URL
  - NEAT_CDF_TOKEN_URL
  - NEAT_CDF_SCOPES
  - NEAT_WORKFLOW_DOWNLOADER_FILTER - list of workflows or tags that must be loaded from CDF automatically during startup
  - NEAT_DATA_PATH - local directory for workflow and rules storage
  - NEAT_CDF_DEFAULT_DATASET_ID - default dataset id that is used for sharing workflows, rules fies and execution traces
  - NEAT_LOG_LEVEL - supported logging levels `DEBUG` , `INFO` (default)



  ```yaml
  workflows_store_type: file
  data_store_path: /app/data

  cdf_client:
    project: get-power-grid
    client_id: "623c2450-cfc2-43d6-9036-10e14dad8ccf"
    client_secret: "my-super-secret"
    base_url: https://az-power-no-northeurope.cognitedata.com
    scopes: [https://az-power-no-northeurope.cognitedata.com/.default]
    token_url: https://login.microsoftonline.com/e55e1701-82f8-4c52-af10-28e4d942c589/oauth2/v2.0/token

  cdf_default_dataset_id: 2626756768281823
  workflow_downloader_filter:
    - tag:grid
  log_level: DEBUG
  ```



  If `workflow_downloader_filter` is set, the app will try to download workflows from CDF based on provided filtering conditions .
  Filtering format :

  - `name:<workflows_name>=<workflow_version>` - loading workflow by name and version or latest by name if version is not set.
  - `tag:<tag_name>`- loading all workflows that tagged with specific tag.


pkgId: adc88de346d5d59ed908c6a01fb984a78a8740f4b1280d878b7affbecdae1678
name: python-cognite-power-ops
arch: src
version: 0.101.1
epoch: 0
release: 1
summary: SDK for power markets operations on Cognite Data Fusion
url: https://cognite-power-ops-sdk.readthedocs-hosted.com/en/latest/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-power-ops-0.101.1-1.src.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/power-ops-sdk/release.yml?style=for-the-badge)](https://github.com/cognitedata/power-ops/actions/workflows/release.yml)
  [![Documentation Status](https://readthedocs.com/projects/cognite-power-ops-sdk/badge/?version=latest&style=for-the-badge)](https://cognite-power-ops-sdk.readthedocs-hosted.com/en/latest/?badge=latest)
  [![Github](https://shields.io/badge/github-cognite/power_ops_sdk-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/power-ops-sdk)
  [![PyPI](https://img.shields.io/pypi/v/cognite-power-ops?style=for-the-badge)](https://pypi.org/project/cognite-power-ops/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-power-ops?style=for-the-badge)](https://pypistats.org/packages/cognite-power-ops)
  [![GitHub](https://img.shields.io/github/license/cognitedata/power-ops-sdk?style=for-the-badge)](https://github.com/cognitedata/power-ops-sdk/blob/master/LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)


  The PowerOps SDK is a domain-specific SDK for interacting with Cognite Data Fusion (CDF) for the power operations' domain.



  * `cognite.powerops.client.PowerOpsClient` used to interact with CDF in a domain-specific language.
  * Resource Sync, `resync`, used to sync configuration files with CDF through the CLI tool `powerops`.



  ```bash
  pip install cognite-power-ops
  ```



  Configuration of the `PowerOpsClient` and `resync` is done through settings files.



  The settings file are in `.toml` format. By default, the SDK will look for two settings files:
    1. `settings.toml` in the current directory.
    2. `.secrets.toml` in the current directory.

  The motivation for splitting them is to avoid checking in secrets into Git.

  Example of settings files:

  `settings.toml`:
  ```toml
  [cognite]
    login_flow = "interactive"
    project = "<cdf-project>"
    tenant_id = "<tenant-id>"
    cdf_cluster = "<cdf-cluster>"
    client_id = "<client-id>"

  [powerops]
    read_dataset = "uc:000:powerops"
    write_dataset = "uc:000:powerops"
    monitor_dataset = "uc:po:monitoring"
  ```

  `.secrets.toml`
  ```toml
  [cognite]
    client_secret = "<client-secret>"
  ```

  **Note:** You can configure which settings files to use by setting the environment variable `SETTINGS__FILES` to a semicolon-separated list of file names.

  ```python
  import os

  os.environ["SETTINGS_FILES"] = ".my_settings.toml;.secrets.my_secrets.toml"
  ```





  See available commands:

  ```bash
  $ powerops --help
  ```

  Example of showing planned changes:

  ```bash
  $ powerops plan tests/data/demo Dayahead
  ```



  ```python
  from cognite.powerops.client import PowerOpsClient

  client = PowerOpsClient.from_settings()

  client.shop.runs.trigger()
  ```

  For more examples, see the examples section of the documentation.


pkgId: 9d1a4d04311527b7ecd9cf9b5ad016381cb6dd4e0e49cbc65c8f93254ba47bd4
name: python-cognite-power-ops
arch: src
version: 0.102.3
epoch: 0
release: 1
summary: SDK for power markets operations on Cognite Data Fusion
url: https://cognite-power-ops-sdk.readthedocs-hosted.com/en/latest/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-power-ops-0.102.3-1.src.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/power-ops-sdk/release.yml?style=for-the-badge)](https://github.com/cognitedata/power-ops/actions/workflows/release.yml)
  [![Documentation Status](https://readthedocs.com/projects/cognite-power-ops-sdk/badge/?version=latest&style=for-the-badge)](https://cognite-power-ops-sdk.readthedocs-hosted.com/en/latest/?badge=latest)
  [![Github](https://shields.io/badge/github-cognite/power_ops_sdk-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/power-ops-sdk)
  [![PyPI](https://img.shields.io/pypi/v/cognite-power-ops?style=for-the-badge)](https://pypi.org/project/cognite-power-ops/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-power-ops?style=for-the-badge)](https://pypistats.org/packages/cognite-power-ops)
  [![GitHub](https://img.shields.io/github/license/cognitedata/power-ops-sdk?style=for-the-badge)](https://github.com/cognitedata/power-ops-sdk/blob/master/LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)



  The PowerOps SDK is a domain-specific SDK for interacting with Cognite Data Fusion (CDF) for the power operations' domain.



  * `cognite.powerops.client.PowerOpsClient` used to interact with CDF in a domain-specific language.
  * Resource Sync, `resync`, used to sync configuration files with CDF through the CLI tool `powerops`.



  ```bash
  pip install cognite-power-ops
  ```



  Configuration of the `PowerOpsClient` and `resync` is done through a yaml file and environment variables.



  The configuration is in `.yaml` format and the path to the configuration file must be explicitly provided. Refer to the [example config file](power_ops_config.yaml) for the most up to date example of required fields.

  Secrets should not be written directly in this configuration file as the file is intended to be committed to git. Instead use the following syntax to refer to an environment variable as a value.

  ```yaml
  project: "${PROJECT}"
  base_url: "https://${CLUSTER}.cognitedata.com"
  ```

  If you are using a `.env` file etc. then you must handle loading the proper environment variables prior to instantiating `PowerOpsClient` or running `resync`.





  Refer to the [resync documentation](RESYNC.md).



  Using YAML configuration:

  ```python
  from dotenv import load_dotenv
  from cognite.powerops.client import PowerOpsClient

  load_dotenv()
  client = PowerOpsClient.from_config("power_ops_config.yaml")

  client.shop.runs.trigger()
  ```

  Using an existing CogniteClient:

  ```python
  from cognite.powerops.client import PowerOpsClient


  cognite_config = {} # dict with configuration
  cognite_client = CogniteClient.load(cognite_config)


  client = PowerOpsClient(client=cognite_client, read_dataset="xid_dataset", write_dataset="xid_dataset")

  ```

  For more examples on using the PowerOpsClient, see the examples section of the documentation.


pkgId: f788f8d1eda75a5a56ce067ef4c0afd4ebb55fa4b18f06281304b69827fa41de
name: python-cognite-power-ops
arch: src
version: 0.104.0
epoch: 0
release: 1
summary: SDK for power markets operations on Cognite Data Fusion
url: https://cognite-power-ops-sdk.readthedocs-hosted.com/en/latest/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-power-ops-0.104.0-1.src.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/power-ops-sdk/release.yml?style=for-the-badge)](https://github.com/cognitedata/power-ops/actions/workflows/release.yml)
  [![Documentation Status](https://readthedocs.com/projects/cognite-power-ops-sdk/badge/?version=latest&style=for-the-badge)](https://cognite-power-ops-sdk.readthedocs-hosted.com/en/latest/?badge=latest)
  [![Github](https://shields.io/badge/github-cognite/power_ops_sdk-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/power-ops-sdk)
  [![PyPI](https://img.shields.io/pypi/v/cognite-power-ops?style=for-the-badge)](https://pypi.org/project/cognite-power-ops/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-power-ops?style=for-the-badge)](https://pypistats.org/packages/cognite-power-ops)
  [![GitHub](https://img.shields.io/github/license/cognitedata/power-ops-sdk?style=for-the-badge)](https://github.com/cognitedata/power-ops-sdk/blob/master/LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)



  The PowerOps SDK is a domain-specific SDK for interacting with Cognite Data Fusion (CDF) for the power operations' domain.



  * `cognite.powerops.client.PowerOpsClient` used to interact with CDF in a domain-specific language.
  * Resource Sync, `resync`, used to sync configuration files with CDF through the CLI tool `powerops`.



  ```bash
  pip install cognite-power-ops
  ```



  Configuration of the `PowerOpsClient` and `resync` is done through a yaml file and environment variables.



  The configuration is in `.yaml` format and the path to the configuration file must be explicitly provided. Refer to the [example config file](power_ops_config.yaml) for the most up to date example of required fields.

  Secrets should not be written directly in this configuration file as the file is intended to be committed to git. Instead use the following syntax to refer to an environment variable as a value.

  ```yaml
  project: "${PROJECT}"
  base_url: "https://${CLUSTER}.cognitedata.com"
  ```

  If you are using a `.env` file etc. then you must handle loading the proper environment variables prior to instantiating `PowerOpsClient` or running `resync`.





  Refer to the [resync documentation](RESYNC.md).



  Using YAML configuration:

  ```python
  from dotenv import load_dotenv
  from cognite.powerops.client import PowerOpsClient

  load_dotenv()
  power_ops_client = PowerOpsClient.from_config("power_ops_config.yaml")

  ```

  Using an existing CogniteClient:

  ```python
  from cognite.powerops.client import PowerOpsClient


  cognite_config = {} # dict with configuration
  cognite_client = CogniteClient.load(cognite_config)


  power_ops_client = PowerOpsClient(client=cognite_client, read_dataset="xid_dataset", write_dataset="xid_dataset")

  ```

  For more examples on using the PowerOpsClient, see the examples section of the documentation.


pkgId: 9fb2e32a8079c5c5513559c929c97f2aeb1ec9912851b314c95ce928405d77f0
name: python-cognite-pygen
arch: src
version: 0.99.39
epoch: 0
release: 1
summary: Cognite Python SDK Generator
url: https://cognite-pygen.readthedocs-hosted.com/en/latest/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-pygen-0.99.39-1.src.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/pygen/release.yaml?style=for-the-badge)](https://github.com/cognitedata/pygen/actions/workflows/release.yaml)
  [![Documentation Status](https://readthedocs.com/projects/cognite-pygen/badge/?version=latest&style=for-the-badge)](https://cognite-pygen.readthedocs-hosted.com/en/latest/?badge=latest)
  [![Github](https://shields.io/badge/github-cognite/pygen-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/pygen)
  [![PyPI](https://img.shields.io/pypi/v/cognite-pygen?style=for-the-badge)](https://pypi.org/project/cognite-pygen/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-pygen?style=for-the-badge)](https://pypistats.org/packages/cognite-pygen)
  [![GitHub](https://img.shields.io/github/license/cognitedata/pygen?style=for-the-badge)](https://github.com/cognitedata/pygen/blob/master/LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/ambv/black)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)
  This is the Cognite Python SDK Generator, `pygen`. The purpose of this package is to help developers to
  work with Cognite Data Fusion's (CDF) Data Models (DM) in Python.
  **Beta Note** This package, `pygen`, is currently in beta, which is reflected in the version number `0.99.x`. Beta
  indicates that a product or functionality is in a mature testing phase, but is still subject to change or retirement.
  We will provide a deprecation notice a minimum of two months before retiring the product or functionality. We recommend
  not using the product or functionality in production systems.
  The core functionality is to provide a Python client that matches a data model. This enables the developer for the following
  benefits
  * Client-side validation of the data before writing it to CDF.
  * Autocompletion is matching the data model in the integrated developer environment (IDE). This is important as it enables:
    * Discoverability of a data model through Python.
    * Reduced typing errors in development.
  * Keeping the language domain specific for the developer. Instead of working with generic concepts such as instances,
    nodes and edges, the developer can work with the concepts in the data model.

  See the [documentation](https://cognite-pygen.readthedocs-hosted.com/en/latest/) for more information.


  To install this package without CLI support:
  ```bash
  pip install cognite-pygen
  ```

  * `cli` This includes CLI support such that you can run the package from the command line.
  ```bash
  pip install cognite-pygen[cli]
  ```
  If using zsh:
  ```bash
  pip install 'cognite-pygen[cli]'
  ```

  The goal of the package is to have representations of all the types in a given data model with API calls to *.list()*,
  *.apply()*, *.delete()*, and *.retrieve()* individuals for each type.
  ![image](https://github.com/cognitedata/pygen/assets/60234212/b9942595-424c-4c5e-8a9c-37a43e0a5a7c)
  ![image](https://github.com/cognitedata/pygen/assets/60234212/70a5f6b0-cec0-4178-93e1-4f9902658638)

  Given a Data Model with external id `Movie` in the space `movies` in CDF, the following command will generate a Python SDK
  ```bash
  pygen generate --space movies \
      --external-id Movie \
      --version 1 \
      --tenant-id <tenant-id> \
      --client-id <client-id> \
      --client-secret <client-secret> \
      --cdf-cluster <cdf-cluster> \
      --cdf-project <cdf-project>
  ```
  If you are not using Microsoft Entra ID (Azure AD) you need to specify the parameter --token-url, --scopes and --audience instead of --tenant-id.


  * [cognite-sdk](https://cognite-sdk-python.readthedocs-hosted.com/en/latest/) This is the basis for all requests to the Cognite Data Fusion API.
  * [pydantic](https://docs.pydantic.dev/latest/) This is used for all data classes in the generated SDK.
  * [pandas](https://pandas.pydata.org/docs/) This is used for `.to_pandas()` methods in the generated SDK.

  * [jinja2](https://jinja.palletsprojects.com/en/3.1.x/) This is used for the templating of the generated SDK.
  * [inflect](https://pypi.org/project/inflect/) This is used for the singularization/pluralization of words in the generated SDK.
  * [typer](https://typer.tiangolo.com/) (Optional) This is used for the CLI of the `pygen` package.
  * [black](https://pypi.org/project/black/) (Optional) This is used to format the code generated by the `pygen` package.

  Wondering about previous changes to the SDK? Take a look at the [CHANGELOG](https://github.com/cognitedata/pygen/blob/master/docs/CHANGELOG.md).

  Want to contribute? Check out [CONTRIBUTING](https://github.com/cognitedata/pygen/blob/master/CONTRIBUTING.md).


pkgId: ee28935e62b2a814db1259f5ca99c8a098af3b357b696e3e63e6b39ca1acb7fa
name: python-cognite-robotics-sdk
arch: src
version: 0.1.19
epoch: 0
release: 1
summary: Cognite Robotics SDK
url: https://pypi.org/project/cognite-robotics-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-robotics-sdk-0.1.19-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/cognite-robotics-sdk.svg)](https://pypi.org/project/cognite-robotics-sdk/)
  [![mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org)
  [![ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)

  This is the Cognite Robotics SDK for Python. It is a Python package that provides a client library for interacting with the Cognite Robotics APIs of Cognite Data Fusions.



  The SDK is available on PyPI and can be installed using `pip`:
  ```sh
  pip install cognite-robotics-sdk
  ```


  Set the following environment variables in a .env file:
  - `COGNITE_PROJECT`
  - `COGNITE_CLUSTER`
  - `COGNITE_TENANT_ID`
  - `COGNITE_CLIENT_ID`
  - `COGNITE_CLIENT_SECRET`


  The reference documentation will be added soon. Please reach out to the Cognite Robotics team for documentation and example code.



  Please reach out to the Cognite Robotics team for documentation and example code.



  Wondering about upcoming or previous changes to the SDK? Check out the [changelog](CHANGELOG.md).


pkgId: 232e12b394ecc82f4bcccb0217eab8e0afee374415ff6e9adb93eed4469cdd91
name: python-cognite-sdk
arch: src
version: 7.63.1
epoch: 0
release: 1
summary: Cognite Python SDK
url: https://pypi.org/project/cognite-sdk/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-sdk-7.63.1-1.src.rpm
checksum_type: sha256
description:
  [![build](https://github.com/cognitedata/cognite-sdk-python/workflows/release/badge.svg)](https://github.com/cognitedata/cognite-sdk-python/actions?query=workflow:release)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-sdk)](https://pypistats.org/packages/cognite-sdk)
  [![GitHub](https://img.shields.io/github/license/cognitedata/cognite-sdk-python)](https://github.com/cognitedata/cognite-sdk-python/blob/master/LICENSE)
  [![codecov](https://codecov.io/gh/cognitedata/cognite-sdk-python/branch/master/graph/badge.svg)](https://codecov.io/gh/cognitedata/cognite-sdk-python)
  [![Documentation Status](https://readthedocs.com/projects/cognite-sdk-python/badge/?version=latest)](https://cognite-sdk-python.readthedocs-hosted.com/en/latest/)
  [![PyPI version](https://badge.fury.io/py/cognite-sdk.svg)](https://pypi.org/project/cognite-sdk/)
  [![conda version](https://anaconda.org/conda-forge/cognite-sdk/badges/version.svg)](https://anaconda.org/conda-forge/cognite-sdk)
  [![mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  This is the Cognite Python SDK for developers and data scientists working with Cognite Data Fusion (CDF).
  The package is tightly integrated with pandas, and helps you work easily and efficiently with data in Cognite Data Fusion (CDF).

  * [SDK Documentation](https://cognite-sdk-python.readthedocs-hosted.com/en/latest/)
  * [CDF API Documentation](https://doc.cognitedata.com/)
  * [Cognite Developer Documentation](https://docs.cognite.com/dev/)


  To install the core version of this package:
  ```bash
  $ pip install cognite-sdk
  ```

  A number of optional dependencies may be specified in order to support a wider set of features.
  The available extras (along with the libraries they include) are:
  - numpy `[numpy]`
  - pandas `[pandas]`
  - geo `[geopandas, shapely]`
  - sympy `[sympy]`
  - functions `[pip]`
  - yaml `[PyYAML]`
  - all `[numpy, pandas, geopandas, shapely, sympy, pip, PyYAML]`
  To include optional dependencies, specify them like this with pip:
  ```bash
  $ pip install "cognite-sdk[pandas, geo]"
  ```
  or like this if you are using poetry:
  ```bash
  $ poetry add cognite-sdk -E pandas -E geo
  ```

  If you regularly need to fetch large amounts of datapoints, consider installing with `numpy`
  (or with `pandas`, as it depends on `numpy`) for best performance, then use the `retrieve_arrays` (or `retrieve_dataframe`) endpoint(s). This avoids building large pure Python data structures, and instead reads data directly into memory-efficient `numpy.ndarrays`.

  On Windows, it is recommended to install `geopandas` and its dependencies using `conda` package manager, see [geopandas installation page](https://geopandas.org/en/stable/getting_started/install.html#installation).
  The following commands create a new environment, install `geopandas` and `cognite-sdk`.
  ```bash
  conda create -n geo_env
  conda activate geo_env
  conda install --channel conda-forge geopandas
  pip install cognite-sdk
  ```

  Wondering about upcoming or previous changes to the SDK? Take a look at the [CHANGELOG](https://github.com/cognitedata/cognite-sdk-python/blob/master/CHANGELOG.md).

  To help you upgrade your code(base) quickly and safely to a newer major version of the SDK, check out our migration guide. It is a more focused guide based on the detailed change log. [MIGRATION GUIDE](https://github.com/cognitedata/cognite-sdk-python/blob/master/MIGRATION_GUIDE.md).

  Want to contribute? Check out [CONTRIBUTING](https://github.com/cognitedata/cognite-sdk-python/blob/master/CONTRIBUTING.md).


pkgId: 33a411c24172809d9c3fe8c98c6b14f05851070af1a26716a2c858b1ad94b73a
name: python-cognite-sdk-core
arch: src
version: 2.56.1
epoch: 0
release: 1
summary: Client library for Cognite Data Fusion (CDF)
url: https://cognite-sdk-python.readthedocs-hosted.com
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-sdk-core-2.56.1-1.src.rpm
checksum_type: sha256
description:
  [![build](https://github.com/cognitedata/cognite-sdk-python/workflows/release/badge.svg)](https://github.com/cognitedata/cognite-sdk-python/actions?query=workflow:release)
  [![codecov](https://codecov.io/gh/cognitedata/cognite-sdk-python/branch/master/graph/badge.svg)](https://codecov.io/gh/cognitedata/cognite-sdk-python)
  [![Documentation Status](https://readthedocs.com/projects/cognite-sdk-python/badge/?version=latest)](https://cognite-docs.readthedocs-hosted.com/en/latest/)
  [![PyPI version](https://badge.fury.io/py/cognite-sdk.svg)](https://pypi.org/project/cognite-sdk/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  This is the Cognite Python SDK for developers and data scientists working with Cognite Data Fusion (CDF).
  The package is tightly integrated with pandas, and helps you work easily and efficiently with data in Cognite Data
  Fusion (CDF).

  * [SDK Documentation](https://cognite-docs.readthedocs-hosted.com/en/latest/)
  * [API Documentation](https://doc.cognitedata.com/)
  * [Cognite Developer Documentation](https://docs.cognite.com/dev/)

  In order to start using the Python SDK, you need
  - Python3 (>= 3.5) and pip
  - An API key. Never include the API key directly in the code or upload the key to github. Instead, set the API key as an environment variable. See the usage example for how to authenticate with the API key.
  This is how you set the API key as an environment variable on Mac OS and Linux:
  ```bash
  $ export COGNITE_API_KEY=<your API key>
  ```
  On Windows, you can follows [these instructions](https://www.computerhope.com/issues/ch000549.htm) to set the API key as an environment variable.

  To install this package:
  ```bash
  $ pip install cognite-sdk
  ```
  To install this package without the pandas and NumPy support:
  ```bash
  $ pip install cognite-sdk-core
  ```
  To install with pandas, geopandas and shapely support (equivalent to installing `cognite-sdk`).
  However, this gives you the option to only have pandas (and NumPy) support without geopandas.
  ```bash
  $ pip install cognite-sdk-core[pandas, geo]
  ```
  On Windows, it is recommended to install `geopandas` and its dependencies using `conda` package manager, see [geopandas installation page](https://geopandas.org/en/stable/getting_started/install.html#installation).
  The following commands create a new environment, install `geopandas` and `cognite-sdk`.
  ```bash
  conda create -n geo_env
  conda activate geo_env
  conda install --channel conda-forge geopandas
  pip install cognite-sdk
  ```

  For a collection of scripts and Jupyter Notebooks that explain how to perform various tasks in Cognite Data Fusion (CDF)
  using Python, see the GitHub repository [here](https://github.com/cognitedata/cognite-python-docs)

  Wondering about upcoming or previous changes to the SDK? Take a look at the [CHANGELOG](https://github.com/cognitedata/cognite-sdk-python/blob/master/CHANGELOG.md).

  Want to contribute? Check out [CONTRIBUTING](https://github.com/cognitedata/cognite-sdk-python/blob/master/CONTRIBUTING.md).


pkgId: 6f473ce339bcc8fca036978fe4040edba1c659aa7d252b14e9e0825871e962bb
name: python-cognite-toolkit
arch: src
version: 0.3.10
epoch: 0
release: 1
summary: Official Cognite Data Fusion tool for project templates and configuration deployment
url: https://developer.cognite.com/sdks/toolkit/
rpm_license: Apache-2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-toolkit-0.3.10-1.src.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/toolkit/release.yaml?style=for-the-badge)](https://github.com/cognitedata/toolkit/actions/workflows/release.yaml)
  [![Github](https://shields.io/badge/github-cognite/toolkit-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/toolkit)
  [![PyPI](https://img.shields.io/pypi/v/cognite-toolkit?style=for-the-badge)](https://pypi.org/project/cognite-toolkit/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-toolkit?style=for-the-badge)](https://pypistats.org/packages/cognite-toolkit)
  [![GitHub](https://img.shields.io/github/license/cognitedata/toolkit?style=for-the-badge)](https://github.com/cognitedata/toolkit/blob/master/LICENSE)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)

  The CDF Toolkit is a command-line interface (`cdf`) used for configuring and administrating
  Cognite Data Fusion (CDF) projects. It ships with modularised `templates` that helps you
  configure Cognite Data Fusion according to best practices.

  It supports three different modes of operation:

  1. As an **interactive command-line tool** used alongside the Cognite Data Fusion web application to retrieve and
     push configuration of the different Cognite Data Fusion services like data sets, data models, transformations,
     and more. This mode also supports configuration of new Cognite Data Fusion projects to quickly get started.
  2. As tool to support the **project life-cyle by scripting and automating** configuration and management of Cognite Data
     Fusion projects where CDF configurations are kept as yaml-files that can be checked into version
     control. This mode also supports DevOps workflows with development, staging, and production projects.
  3. As a **tool to deploy official Cognite project templates** to your Cognite Data Fusion project. The tool comes
     bundled with templates useful for getting started with Cognite Data Fusion, as well as for specific use cases
     delivered by Cognite or its partners. You can also create your own templates and share them.



  Install the Toolkit by running:

  ```bash
  pip install cognite-toolkit
  ```

  Then run `cdf --help` to get started with the interactive command-line tool.



  More details about the tool can be found at
  [docs.cognite.com](https://docs.cognite.com/cdf/deploy/cdf_toolkit/).

  You can find an overview of the modules and packages in the
  [module and package documentation](https://docs.cognite.com/cdf/deploy/cdf_toolkit/references/module_reference).

  See [./CONTRIBUTING.md](./CONTRIBUTING.md) for information about how to contribute to the `cdf-tk` tool or
  templates.


pkgId: b1f0fe34987a038f5f20cd534ec8892152b269070b501ad37db5db20204e50bf
name: python-cognite-toolkit
arch: src
version: 0.3.11
epoch: 0
release: 1
summary: Official Cognite Data Fusion tool for project templates and configuration deployment
url: https://developer.cognite.com/sdks/toolkit/
rpm_license: Apache-2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-toolkit-0.3.11-1.src.rpm
checksum_type: sha256
description:
  [![release](https://img.shields.io/github/actions/workflow/status/cognitedata/toolkit/release.yaml?style=for-the-badge)](https://github.com/cognitedata/toolkit/actions/workflows/release.yaml)
  [![Github](https://shields.io/badge/github-cognite/toolkit-green?logo=github&style=for-the-badge)](https://github.com/cognitedata/toolkit)
  [![PyPI](https://img.shields.io/pypi/v/cognite-toolkit?style=for-the-badge)](https://pypi.org/project/cognite-toolkit/)
  [![Downloads](https://img.shields.io/pypi/dm/cognite-toolkit?style=for-the-badge)](https://pypistats.org/packages/cognite-toolkit)
  [![GitHub](https://img.shields.io/github/license/cognitedata/toolkit?style=for-the-badge)](https://github.com/cognitedata/toolkit/blob/master/LICENSE)
  [![Docker Pulls](https://img.shields.io/docker/pulls/cognite/toolkit?style=for-the-badge)](https://hub.docker.com/r/cognite/toolkit)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=for-the-badge)](https://github.com/astral-sh/ruff)
  [![mypy](https://img.shields.io/badge/mypy-checked-000000.svg?style=for-the-badge&color=blue)](http://mypy-lang.org)

  The CDF Toolkit is a command-line interface (`cdf`) used for configuring and administrating
  Cognite Data Fusion (CDF) projects. It ships with modularised `templates` that helps you
  configure Cognite Data Fusion according to best practices.

  It supports three different modes of operation:

  1. As an **interactive command-line tool** used alongside the Cognite Data Fusion web application to retrieve and
     push configuration of the different Cognite Data Fusion services like data sets, data models, transformations,
     and more. This mode also supports configuration of new Cognite Data Fusion projects to quickly get started.
  2. As tool to support the **project life-cyle by scripting and automating** configuration and management of Cognite Data
     Fusion projects where CDF configurations are kept as yaml-files that can be checked into version
     control. This mode also supports DevOps workflows with development, staging, and production projects.
  3. As a **tool to deploy official Cognite project templates** to your Cognite Data Fusion project. The tool comes
     bundled with templates useful for getting started with Cognite Data Fusion, as well as for specific use cases
     delivered by Cognite or its partners. You can also create your own templates and share them.



  Install the Toolkit by running:

  ```bash
  pip install cognite-toolkit
  ```

  Then run `cdf --help` to get started with the interactive command-line tool.



  More details about the tool can be found at
  [docs.cognite.com](https://docs.cognite.com/cdf/deploy/cdf_toolkit/).

  You can find an overview of the modules and packages in the
  [module and package documentation](https://docs.cognite.com/cdf/deploy/cdf_toolkit/references/module_reference).

  See [./CONTRIBUTING.md](./CONTRIBUTING.md) for information about how to contribute to the `cdf-tk` tool or
  templates.


pkgId: 5177b200a229db4ee92a05c1baa0c481977a6c2b37870705a0a023db67acc6f1
name: python-cognite-transformations-cli
arch: src
version: 2.3.11
epoch: 0
release: 1
summary: A CLI for the Transformations service in CDF
url: https://github.com/cognitedata/transformations-cli
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-transformations-cli-2.3.11-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/cognitedata/transformations-cli/workflows/release/badge.svg)](https://github.com/cognitedata/transformations-cli/actions)
  [![Documentation Status](https://readthedocs.com/projects/cognite-transformations-cli/badge/?version=latest)](https://cognite-transformations-cli.readthedocs-hosted.com/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/cognitedata/transformations-cli/branch/main/graph/badge.svg?token=PSkli74vvX)](https://codecov.io/gh/cognitedata/transformations-cli)
  [![PyPI version](https://badge.fury.io/py/cognite-transformations-cli.svg)](https://pypi.org/project/cognite-transformations-cli)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cognite-transformations-cli)
  [![License](https://img.shields.io/github/license/cognitedata/python-extractor-utils)](LICENSE)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  Use the Transformations command-line interface (**Transformations CLI**) to manage the lifecycle of your transformation jobs using the command line. With the Transformations CLI, you can process data from the CDF staging area (RAW) into the CDF data model. To learn more about how the Cognite Transformations CLI package works, see the **documentation** [here](https://cognite-transformations-cli.readthedocs-hosted.com/en/latest/)

  The **Transformations CLI** is based on Python and replaces the [Jetfire CLI](https://github.com/cognitedata/jetfire-cli).



  The **Transformations CLI** provides a GitHub Action to deploy transformations. You'll find the documentation [here](githubaction.md).

  We've also created a **CI/CD template** that uses GitHub Workflows. You'll find the documentation [here](https://github.com/cognitedata/transformations-action-template).



  We publish `transformations-cli` docker images in [dockerhub](https://hub.docker.com/r/cognite/transformations-cli/tags) for every version released. The images tagged as `cognite/transformations-cli:<version>-azure` can be used in Azure Pipelines (See an example tag [here](https://hub.docker.com/layers/transformations-cli/cognite/transformations-cli/2.1.1-azure/images/sha256-310aa01bcfc4f379c82076cc0386cc401ed1565d3ce4a2d8c3235d7061428145?context=explore)). We suggest you check [the example Azure Pipeline workflow configuration](azure_pipelines_example/azure-pipelines.yaml) and [the corresponding transformation manifest](azure_pipelines_example/transformations/manifest.yaml).



  **Transformations CLI** replaces the [Jetfire CLI](https://github.com/cognitedata/jetfire-cli). If you've already used the **Jetfire CLI** in a GitHub Action, we recommend migrating to the **Transformations CLI** GitHub Action. You'll find the migration guide [here](migrationguide.md).



  We use [poetry](https://python-poetry.org) to manage dependencies and to administrate virtual environments. To develop
  **Transformations CLI**, follow these steps to set up your local environment:

  1.  Install poetry: (add `--user` if desirable)
      ```
      $ pip install poetry
      ```
  2.  Clone repository:
      ```
      $ git clone git@github.com:cognitedata/transformations-cli.git
      ```
  3.  Move into the newly created local repository:
      ```
      $ cd transformations-cli
      ```
  4.  Create a virtual environment and install dependencies:

      ```
      $ poetry install
      ```

  5.  All the code must pass [black](https://github.com/ambv/black) and [isort](https://github.com/timothycrosley/isort) style
      checks before it can be merged. We recommend installing pre-commit hooks to ensure this locally before you commit your code:

  ```
  $ poetry run pre-commit install
  ```

  6. To run tests:
  ```
  $ poetry run pytest
  $ poetry run pytest <test file path>
  $ poetry run pytest <test file path>::<test function name>
  ```

  7. To publish a new version, change the version in `cognite/transformations_cli/__init__.py` and `pyproject.toml`. Make sure to update the `CHANGELOG`.

  This project adheres to the [Contributor Covenant v2.0](https://www.contributor-covenant.org/version/2/0/code_of_conduct/)
  as a code of conduct.


pkgId: e9d00cf293f03a8a59fecb0e0ea41b35dba50a1d1a1a7a2383302497e0864cf6
name: python-cognite-wells-sdk
arch: src
version: 0.18.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cognite-wells-sdk/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognite-wells-sdk-0.18.3-1.src.rpm
checksum_type: sha256
description:
  The well data layer service has been shut down.
  Please see the [Deprecated and retired features in Cognite Data Fusion (CDF)
  ][deprecated].

  [deprecated]: https://docs.cognite.com/cdf/deprecated/


pkgId: efb0585e5708c132e5c2e601e12384092ffd5bdc4682750a616dfa816c74e214
name: python-cognitive-complexity
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Library to calculate Python functions cognitive complexity via code
url: https://github.com/Melevir/cognitive_complexity
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognitive-complexity-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/Melevir/cognitive_complexity.svg?branch=master)](https://travis-ci.org/Melevir/cognitive_complexity)
  [![Maintainability](https://api.codeclimate.com/v1/badges/853d47d353e7becc9f09/maintainability)](https://codeclimate.com/github/Melevir/cognitive_complexity/maintainability)
  [![Test Coverage](https://api.codeclimate.com/v1/badges/853d47d353e7becc9f09/test_coverage)](https://codeclimate.com/github/Melevir/cognitive_complexity/test_coverage)
  [![PyPI version](https://badge.fury.io/py/cognitive-complexity.svg)](https://badge.fury.io/py/cognitive-complexity)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cognitive-complexity)

  Library to calculate Python functions cognitive complexity via code.



  ```bash
  pip install cognitive_complexity
  ```



  ```python
  >>> import ast

  >>> funcdef = ast.parse("""
  ... def f(a):
  ...     return a * f(a - 1)  # +1 for recursion
  ... """).body[0]

  >>> from cognitive_complexity.api import get_cognitive_complexity
  >>> get_cognitive_complexity(funcdef)
  1
  ```



  Perhaps the most common way to use this library (especially if you are
  already using the [Flake8 linter](https://flake8.pycqa.org/en/latest/))
  is to use the
  [flake8-cognitive-complexity extension](https://github.com/Melevir/flake8-cognitive-complexity).
  If you run Flake8 with this extension installed, Flake8 will let you know
  if your code is too complex. For more details and documentation, visit the
  [flake8-cognitive-complexity extension repository](https://github.com/Melevir/flake8-cognitive-complexity).



  Here are some readings about cognitive complexity:

  - [Cognitive Complexity, Because Testability != Understandability](https://blog.sonarsource.com/cognitive-complexity-because-testability-understandability);
  - [Cognitive Complexity: A new way of measuring understandability](https://www.sonarsource.com/docs/CognitiveComplexity.pdf),
    white paper by G. Ann Campbell;
  - [Cognitive Complexity: the New Guide to Refactoring for Maintainable Code](https://www.youtube.com/watch?v=5C6AGTlKSjY);
  - [Cognitive Complexity](https://docs.codeclimate.com/docs/cognitive-complexity)
    from CodeClimate docs;
  - [Is Your Code Readable By Humans? Cognitive Complexity Tells You](https://www.tomasvotruba.cz/blog/2018/05/21/is-your-code-readable-by-humans-cognitive-complexity-tells-you/).



  This is not precise realization of original algorithm
  proposed by [G. Ann Campbell](https://github.com/ganncamp),
  but it gives rather similar results.
  The algorithm gives complexity points for breaking control flow, nesting,
  recursion, stacks logic operation etc.



  We would love you to contribute to our project. It's simple:

  - Create an issue with bug you found or proposal you have. Wait for
    approve from maintainer.
  - Create a pull request. Make sure all checks are green.
  - Fix review comments if any.
  - Be awesome.

  Here are useful tips:

  - You can run all checks and tests with `make check`. Please do it
    before TravisCI does.
  - We use [BestDoctor python styleguide](https://github.com/best-doctor/guides/blob/master/guides/python_styleguide.md).
    Sorry, styleguide is available only in Russian for now.
  - We respect [Django CoC](https://www.djangoproject.com/conduct/).
    Make soft, not bullshit.


pkgId: 09650bcaecb539e873d9cf4b4ea7fd0ae822c75c21776493647f928b70ed2c7f
name: python-cognitive-face
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Python SDK for the Cognitive Face API
url: https://github.com/Microsoft/Cognitive-Face-Python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognitive-face-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Version](https://img.shields.io/pypi/v/cognitive_face.svg)](https://pypi.org/project/cognitive_face/)
  [![License](https://img.shields.io/pypi/l/cognitive_face.svg)](https://github.com/Microsoft/Cognitive-Face-Python/blob/master/LICENSE)

  This SDK has been deprecated and been replaced by [Microsoft.Azure.CognitiveServices.Vision.Face](https://github.com/Azure/azure-sdk-for-python/tree/master/azure-cognitiveservices-vision-face) which is a part of Azure SDK.

  This repo contains the Python SDK for the Microsoft Face API, an offering within [Microsoft Cognitive Services](https://azure.microsoft.com/en-us/services/cognitive-services/), formerly known as Project Oxford.

  * [Learn about the Face API](https://azure.microsoft.com/en-us/services/cognitive-services/face/)
  * [Documentation & API Reference & SDKs](https://docs.microsoft.com/en-us/azure/cognitive-services/face/)



  Install the module using [pip](https://pypi.python.org/pypi/pip/):

  ```bash
  pip install cognitive_face
  ```

  Use it:

  ```python
  import cognitive_face as CF

  KEY = 'subscription key'  # Replace with a valid Subscription Key here.
  CF.Key.set(KEY)

  BASE_URL = 'https://westus.api.cognitive.microsoft.com/face/v1.0/'  # Replace with your regional Base URL
  CF.BaseUrl.set(BASE_URL)

  img_url = 'https://raw.githubusercontent.com/Microsoft/Cognitive-Face-Windows/master/Data/detection1.jpg'
  result = CF.face.detect(img_url)
  print result
  ```



  ```bash
  python setup.py install
  ```



  To run the tests you will need a valid subscription. You can get one [here](https://azure.microsoft.com/en-us/try/cognitive-services/?api=face-api).

  1. Copy `cognitive_face/tests/config.sample.py`  into `cognitive_face/tests/config.py`.
  1. Change the `KEY` and `BASE_URL` parameters to your own subscription's API key and endpoint.
  1. Run the following:

  ```bash
  python setup.py test
  ```



  A sample desktop application is also provided.

  Currently it support the following combination of prerequisites:

  1. [Python 3](https://www.python.org/downloads/) + [wxPython 4](https://pypi.python.org/pypi/wxPython) **[Recommended]**
  1. [Python 2](https://www.python.org/downloads/) + [wxPython 4](https://pypi.python.org/pypi/wxPython)
  1. [Python 2](https://www.python.org/downloads/) + [wxPython 3](https://sourceforge.net/projects/wxpython/files/wxPython/3.0.2.0/)

  P.S. WxPython 3 does not support Python 3 by design.

  Then run the following:

  ```bash
  git clone https://github.com/Microsoft/Cognitive-Face-Python.git
  cd Cognitive-Face-Python
  pip install -r requirements.txt
  python sample
  ```

  ![Sample app](./Assets/sample_screenshot.png)




  We welcome contributions. Feel free to file issues and pull requests on the repo and we'll address them as we can. Learn more about how you can help on our [Contribution Rules & Guidelines](/CONTRIBUTING.md).

  You can reach out to us anytime with questions and suggestions using our communities below:
   - **Support questions:** [StackOverflow](https://stackoverflow.com/questions/tagged/microsoft-cognitive)
   - **Feedback & feature requests:** [Cognitive Services UserVoice Forum](https://cognitive.uservoice.com)

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.


  * [Face API Release Notes](https://docs.microsoft.com/en-us/azure/cognitive-services/face/releasenotes)


  All Microsoft Cognitive Services SDKs and samples are licensed with the MIT License. For more details, see
  [LICENSE](/LICENSE.md).

  Sample images are licensed separately, please refer to [LICENSE-IMAGE](/LICENSE-IMAGE.md).


  Developers using Cognitive Services, including this sample, are expected to follow the “Developer Code of Conduct for Microsoft Cognitive Services”, found at [http://go.microsoft.com/fwlink/?LinkId=698895](http://go.microsoft.com/fwlink/?LinkId=698895).


pkgId: 2812bbf345e669cc518d0874b2c5373a6f5d3b1c96daec4b3d66f974c4474447
name: python-cognito-code-grant
arch: src
version: 1.0.30
epoch: 0
release: 1
summary: A middleware and a set of handlers to handle Code Grant authentication with Cognito
url: https://pypi.org/project/cognito-code-grant/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognito-code-grant-1.0.30-1.src.rpm
checksum_type: sha256
description:
  This package implements an authentication backend and a set of handlers that enable your application to use
  code grant authentication with AWS Cognito.

  The package has been developed by STITCH (https://www.stitchdesignlab.com/)

  The documentation for this project is a work-in-progress and is pretty much bare bones. Do not hesitate to
  contact us, or open an issue or PR for contribution.


   - [AWS Cognito](https://aws.amazon.com/cognito/)
   - [Django Rest Framework](https://www.django-rest-framework.org/)
   - [Grant types of Cognito explained by AWS](https://aws.amazon.com/blogs/mobile/understanding-amazon-cognito-user-pool-oauth-2-0-grants/)


  Code grant is an OAuth 2.0 flow that allows one to use Cognito as a data store and authentication backend
  for users, while maintaining an updating replica of User and Group information in your applications database.
  This way, the application gains the possibility to add custom business logic for users, while the user data is
  still stored and managed centrally through Cognito.


  This is especially useful when you are implementing multiple API backends for a platform that consist of multiple
  applications that need to operate on a shared userbase.

  See the link above for a detailed explanation of the standard.


  You can install this package from pip: `pip install cognito_code_grant`


  The implementation consists of an [authentication backend](https://www.django-rest-framework.org/api-guide/authentication/), a login handler, and a logout handler.
  To use the backend, simply specify it in your Django Settings:
  ```
  REST_FRAMEWORK = {
      'DEFAULT_AUTHENTICATION_CLASSES': (
          'cognito_code_grant.authentication.CognitoAuthentication',
          'rest_framework.authentication.BasicAuthentication',
          ...
      )
  ```
  To use the handlers, include them in your URLs using a helper function:
  ```
  from cognito_code_grant.views import include_auth_urls

  urlpatterns = [
      path('auth/', include_auth_urls()),
      ...
  ]
  ```
  Additionally, you will need to set the following settings to point to your instance of Cognito:
  ```
  AUTH_COGNITO_CLIENT_ID = # your client ID
  AUTH_COGNITO_CODE_GRANT_URL = # your token endpoint (https://AUTH_DOMAIN/oauth2/token)
  AUTH_COGNITO_JWKS_URL = # the url for your JWKs (https://cognito-idp.{region}.amazonaws.com/{userPoolId}/.well-known/jwks.json.)
  ```


  To run tests, you need to point Django to local test settings, and run the migrations (it will use an sqllite db in a temp folder).
  ```python
  export DJANGO_SETTINGS_MODULE=tests.settings
  python -m django migrate
  python -m django test
  ```

  On a merge to master, CICD will automatically create a `patch` version bump, and deploy to pypi. Minor/Major realeases need to be handled manually by the maintainers.


pkgId: 9fddf85ac641f18ad22e5c3932b1bb83505099d882330f1bc42399d16d030d93
name: python-cognitoctl
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: CLI to use aws cognito in a simple way
url: https://github.com/DaniMG95/cognitoctl
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognitoctl-1.0.0-1.src.rpm
checksum_type: sha256
description:
  This CLI enables easy management of **users and groups in AWS Cognito**. Features include:
  - Group creation and management.
  - User registration, authentication, and management.
  - Password recovery and token updates.
  It’s designed for developers needing quick integration with AWS Cognito from the command line.

  Before using this CLI, ensure the following prerequisites are met:
  - **Python 3.10+**
  - **AWS CLI configured** with the necessary credentials to access Cognito.
  - Sufficient AWS permissions to manage Cognito.

  1. Install package:
  ```bash
     pip install cognitoctl
  ```


  To use the CLI, you must initialize it with at least one **Cognito project**. Use the init command to set up a project. You can either input configuration details interactively or provide them via a configuration file.
  You can use the --help option to get help on parameters and commands.

  ```bash
     cognitoctl init
  ```
  You will be prompted to enter the necessary configuration values such as:
  - Project Name (e.g., "development", "production").
  - AWS Access Key ID
  - AWS Secret Access Key
  - Cognito User Pool ID.
  - Cognito App Client ID
  - Cognito Client Secret
  - Need use Secret Hash (Y/N)

  Alternatively, you can provide the details through a TOML file:
  ```bash
     cognitoctl init -f config.toml
  ```
  Example of config.toml:
  ```
  [project1]
  key_id = "your-aws-access-key-id"
  access_key = "your-aws-secret-access-key"
  userpool_id = "your-userpool-id"
  app_client_id = "your-client-id"
  app_client_secret = "your-client-secret"
  secret_hash = true
  ```

  The CLI allows you to manage multiple Cognito environments as separate projects. Each project is stored in the CLI's configuration, and you can switch between them as needed.

  To add another project, simply run init again with a different name:
  ```bash
     cognitoctl init -f proyect2.toml
  ```

  You can select project using:
  ```bash
     cognitoctl config select project1
  ```

  | Command                     | Description                                      | Actions                                                              |
  |-----------------------------|--------------------------------------------------|----------------------------------------------------------------------|
  | `init`                      | Initializes the CLI with required configuration. |                                                                      |
  | `config`                    | Apply CLI configuration level actions.           | list, current, set, get, select, edit                                |
  | `group`                     | Apply group level actions.                       | create, delete, delete-user, add-user, list, get, edit               |
  | `user`                      | Apply user level actions.                        | create, confirm, delete, change-password, enable, disable, get, list |

  Contributions are welcome! To improve this tool, follow these steps:
  Fork the repository.
  Create a new branch:
  ```bash
  git checkout -b feature/new-feature
  ```
  Submit a Pull Request to the main repository, in the branch dev.


pkgId: 8bfca2128ba581bc89a3f64cb81530fb4aa659552b2571a4de0624e22cb4c96b
name: python-cognitohashcalculator
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://pypi.org/project/cognitohashcalculator/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognitohashcalculator-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  A small python library for calculating the secret hash required for the amazon cognito's user and password authentication

description:
  This function creates a secret hash by combining the username and client ID, secured with a client secret key.

  - **`client_id`** *(str)*:
    The unique identifier for the client.
  - **`client_secret`** *(str)*:
    The secret key associated with the client ID, used for hashing.
  - **`username`** *(str)*:
    The username or user identifier to include in the hash computation.


pkgId: e3ab52e48de68575b80cb2dec91c3d5e353302d1f7c0437b0c0abeaab4b8eb9b
name: python-cognitojwt
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Decode and verify Amazon Cognito JWT tokens
url: http://github.com/borisrozumnuk/cognitojwt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognitojwt-1.4.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/borisrozumnuk/cognitojwt.svg?branch=master)](https://travis-ci.org/borisrozumnuk/cognitojwt)







  Package works in two modes: synchronous - [requests](https://github.com/requests/requests) as http-client and asynchronous - [aiohttp](https://github.com/aio-libs/aiohttp) as http-client.
  In order to avoid installing unnecessary dependencies I separated installation flow into two modes:

  * Async mode - `pip install cognitojwt[async]`
  * Sync mode - `pip install cognitojwt[sync]`



  ```python
  import cognitojwt

  id_token = '<YOUR_TOKEN_HERE>'
  REGION = '**-****-*'
  USERPOOL_ID = 'eu-west-1_*******'
  APP_CLIENT_ID = '1p3*********'


  verified_claims: dict = cognitojwt.decode(
      id_token,
      REGION,
      USERPOOL_ID,
      app_client_id=APP_CLIENT_ID,  # Optional
      testmode=True  # Disable token expiration check for testing purposes
  )


  verified_claims: dict = await cognitojwt.decode_async(
      id_token,
      REGION,
      USERPOOL_ID,
      app_client_id=APP_CLIENT_ID,  # Optional
      testmode=True  # Disable token expiration check for testing purposes
  )

  ```

  Note: if the application is deployed inside a private vpc without internet gateway, the application will not be able to download the JWKS file.
  In this case set the `AWS_COGNITO_JWKS_PATH` environment variable referencing the absolute or relative path of the jwks.json file.

  It is possible to allow multiple app client ids by passing the value as a Container instance such as a list or tuple:
  ```python
  ALLOWED_CLIENT_IDS = ('client_one', 'client_two')

  verified_claims: dict = cognitojwt.decode(
      id_token,
      REGION,
      USERPOOL_ID,
      app_client_id=ALLOWED_CLIENT_IDS,
      testmode=True  # Disable token expiration check for testing purposes
  )
  ```


pkgId: cfc27e4e60793e8f82114950a803a42401c6925d001c39b7eeeed679309181d1
name: python-cognitopy
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: Python package to use aws cognito in a simple way
url: https://github.com/DaniMG95/cognitopy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cognitopy-1.1.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/cognitopy.svg?style=plastic)](https://pypi.org/project/cognitopy/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/cognitopy?style=plastic)


  This is a package that will allow you to use the aws Cognito technology, so for now we are going to allow the management of users, authentication and creation of groups by Roles.
  The potential of this package is the ease of management of all these functionalities and only creating an object with 3 parameters.


  ```bash
  pip install cognitopy
  ```



  The cognito admin functions require that we have the aws, access key and secret access key credentials defined as system environment variables.

  ```python
  import os

  os.environ["AWS_ACCESS_KEY_ID"] = 'XXXXXXXXXXXXXXXXXXXXXXXX'
  os.environ["AWS_SECRET_ACCESS_KEY"] = 'XXXXXXXXXXXXXXXXXXXXXXXX'
  ```


  To define the cognitopy object it is necessary to give it the userpool_id, the client_id and the client_secret information.
  The secret_hash parameter is set to False by default and indicates that for requests it is necessary to provide the secret_hash.
  ```python
  from cognitopy import CognitoPy

  COGNITO_USERPOOL_ID = 'XXX-XXX-XXXXXX'
  COGNITO_APP_CLIENT_ID = 'XXXXXXXXXXXXXXXXXXXXXXXX'
  COGNITO_APP_CLIENTE_SECRET = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'

  cognitopy = CognitoPy(
      userpool_id=COGNITO_USERPOOL_ID, client_id=COGNITO_APP_CLIENT_ID, client_secret=COGNITO_APP_CLIENTE_SECRET,
      secret_hash=True
  )
  ```

  Now I will explain the different functions that we can use in this version, with an example.
  All these examples are in the directory example.


  It will allow us to use the cognitopy object in a context manager, so that we do not have to worry about closing the connection.
  ```python
  with CognitoPy(userpool_id=COGNITO_USERPOOL_ID, client_id=COGNITO_APP_CLIENT_ID,
                 client_secret=COGNITO_APP_CLIENTE_SECRET) as cognito:
      cognito.register(username="XXXXX@mail.to", password="XXXXXXX8", user_attributes={})
  ```


  It will register a user in our cognito service and send us a confirmation message.
  ```python
  id_user = cognito.register(username='XXXXX@mail.to', password='XXXXXXX8', user_attributes={})
  print(id_user)
  ```


  It is responsible for confirming the user from the number received by mail.
  ```python
  cognito.confirm_register(username='XXXXX@mail.to', confirmation_code='820850')
  ```


  It allows us to receive a confirmation code again, when we have previously requested to change password or register.
  ```python
  cognito.resend_confirmation_code(username='XXXXX@mail.to')
  ```


  It will return the access token and refresh token of a confirmed user.
  ```python
  tokens = cognito.login(username='XXXXX@mail.to', password='XXXXXXX')
  print(tokens['access_token'], tokens['refresh_token'])
  ```


  It will renew the user's access token.
  ```python
  access_token = cognito.renew_access_token(access_token='XXXXXXXXX', refresh_token='XXXXXXXXX')
  print(access_token)
  ```


  Check if the access token has expired.
  ```python
  is_expired = cognito.check_expired_token(access_token='XXXXXXXXX')
  print(is_expired)
  ```


  Allows us to change our password by sending us a confirmation code.
  ```python
  cognito.initiate_forgot_password(username='XXXXX@mail.to')
  ```


  Change the password of a user from the confirmation code received.
  ```python
  cognito.confirm_forgot_password(username='XXXXX@mail.to', confirmation_code='YYYYY', password='XXXXXXX')
  ```


  Delete the user from his access token.
  ```python
  cognito.delete_user(access_token='XXXXXXXXX')
  ```


  Change the password from your access token.
  ```python
  cognito.change_password(access_token='XXXXXXXXX', previous_password='XXXXXXX', proposed_password="XXXXXXX")
  ```


  We obtain basic user information from the user's access token.
  ```python
  data_user = cognito.get_info_user_by_token(access_token='XXXXXXXXX')
  print(data_user['username'], data_user['groups'])
  ```


  We remove a user from our service from the administrator credentials.
  ```python
  cognito.admin_delete_user(username='XXXXX@mail.to')
  ```


  We create a group from our service from the administrator credentials.
  precedence: A non-negative integer value that specifies the precedence of this group relative to the other groups that a user can belong to in the user pool. Zero is the highest precedence value. Groups with lower Precedence values take precedence over groups with higher or null Precedence values.
  role_arn: The role Amazon Resource Name (ARN) for the group.
  ```python
  cognito.admin_create_group(group_name='test_group', description='test group', precedence=1)
  ```


  We remove a group from our service from the administrator credentials.
  ```python
  cognito.admin_delete_group(group_name='test_group')
  ```


  We add a user to group from our service from the administrator credentials.
  ```python
  cognito.admin_add_user_to_group(username='XXXXX@mail.to', group_name='test_group')
  ```


  We remove a user to group from our service from the administrator credentials.
  ```python
  cognito.admin_remove_user_from_group(username='XXXXX@mail.to', group_name='test_group')
  ```



  We confirm a user register from the administrator credentials.
  ```python
  cognito.admin_confirm_register(username="XXXXX@mail.to")
  ```



  We create a user from the administrator credentials.
  message_action = MessageAction.SUPPRESS | MessageAction.RESEND
  Set to RESEND to resend the invitation message to a user that already exists and reset the expiration limit on the user’s account. Set to SUPPRESS to suppress sending the message.
  desired_delivery = [DesiredDelivery.EMAIL | DesiredDelivery.SMS] or [DesiredDelivery.EMAIL, DesiredDelivery.SMS]
  Specify EMAIL if email will be used to send the welcome message. Specify SMS if the phone number will be used.
  optional temporary_password
  ```python
  cognito.admin_create_user(username="XXXXX@mail.to", force_alias=True, user_attributes={},
                            message_action=MessageAction.SUPPRESS, desired_delivery=[DesiredDelivery.EMAIL],
                            temporary_password="XXXXXXX")
  ```


  We disable a user from the administrator credentials.
  ```python
  cognito.admin_disable_user(username="XXXXX@mail.to")
  ```



  We enabled a user from the administrator credentials.
  ```python
  cognito.admin_enable_user(username="XXXXX@mail.to")
  ```


  We get info about a user from the administrator credentials.
  ```python
  data_user = cognito.admin_get_user(username="XXXXX@mail.to")
  print(data_user)
  ```



  We login a user from the administrator credentials.
  ```python
  tokens = cognito.admin_login(username="XXXXX@mail.to", password="XXXXXXX")
  print(tokens)
  ```



  We renew access token a user from the administrator credentials.
  ```python
  token = cognito.admin_renew_access_token(access_token="XXXXX", refresh_token="XXXXXXX")
  print(token)
  ```



  We list groups for user from the administrator credentials.
  ```python
  groups = cognito.admin_list_groups_for_user(username="XXXXX@mail.to", limit=10)
  print(groups)
  groups = cognito.admin_list_groups_for_user(username="XXXXX@mail.to", limit=10, next_token=groups["NextToken"])
  print(groups)
  ```



  We reset password from the administrator credentials.
  After applying this function it will be necessary to launch the initiate_forgot_password function, since the user's password will be disabled.
  ```python
  cognito.admin_reset_password(username="XXXXX@mail.to")
  ```



  We resolve challenge sms mfa.
  ```python
  tokens = cognito.resolve_challenge_challenge_sms_mfa(username="XXXXX@mail.to", session="XXXXXX", sms_mfa_code="XXXXXX")
  print(tokens)
  ```



  We resolve challenge new password required.
  ```python
  tokens = cognito.resolve_challenge_new_password(username="XXXXX@mail.to", session="XXXXXX", new_password="XXXXXX")
  print(tokens)
  ```


pkgId: 63a583d2c36e207bae382e0ed5d60511fbdbdb134ba21e487eaf3e8914b31120
name: python-cogsol
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A Python SDK for interacting with an Cognitive API provided by Cognitive Solutions.
url: https://github.com/Pyxis-Cognitive-Solutions/cognitive-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cogsol-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A Python SDK for interacting with the Cognitive API from Cognitive Solutions. This SDK allows you to create and manage conversations with an already defined assistant, send messages, and retrieve conversation history. The package provides a user-friendly interface for integrating assistant chat functionalities into your applications.



  - **Assistant Instantiation**: Instantiate and interact with an assistant.
  - **Chat Creation**: Create a chat with an initial message to start a conversation.
  - **Message Handling**: Send messages to the assistant and receive responses.
  - **Chat History**: Retrieve the full history of a conversation.
  - **References Management**: Retrieve additional reference information associated with messages.



  To install the SDK, you can clone the repository and install it locally:

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





  ```python
  from cogsol import Assistant
  ```



  ```python
  assistant = Assistant(assistant_id=7, tenant="your_tenant_id", environment="develop")
  ```



  ```python
  chat, initial_response = assistant.create_chat(initial_message="Hello, who are you?")
  print("Initial Assistant Response:", initial_response)
  ```



  ```python
  response = chat.send_message("Can you tell me more?")
  print("Assistant Response:", response)
  ```



  ```python
  history = chat.history
  print("Chat History:", history)
  ```



  The `Message` class contains an attribute called `references`, which provides additional information related to the message. A `Reference` object includes:

  - **reference_num**: An integer indicating the reference number.
  - **source**: A string representing the source of the reference (e.g., a document or URL).
  - **showed_num**: An optional integer that represents the number displayed for the reference.

  This attribute is particularly useful when the assistant provides responses that include citations or links to supporting information. You can access these references as follows:

  ```python
  for ref in initial_response.references:
      print(f"Reference Number: {ref.reference_num}, Source: {ref.source}, Showed Number: {ref.showed_num}")
  ```



  The base URLs for the assistant API can be customized via environment variables. You can set the following environment variables to specify URLs for different environments:

  - `COGSOL_PRODUCTION_URL`
  - `COGSOL_DEVELOP_URL`
  - `COGSOL_IMPLANTATION_URL`
  - `COGSOL_TEST_URL`

  If not set, the SDK defaults to `http://localhost:8000/cognitive` for all environments.



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



  Feel free to contribute to this project by opening issues or submitting pull requests. Make sure to follow the standard coding guidelines and include tests for new features or bug fixes.



  - Python 3.6+
  - Requests library (>=2.20.0)

  Install requirements using:

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



  Below is a complete example showing how to use the SDK to create a chat, send a message, get the response, and get the history:

  ```python
  from cogsol import Assistant


  assistant = Assistant(assistant_id=7, tenant="your_tenant_id", environment="develop")


  chat, initial_response = assistant.create_chat(initial_message="Hello, who are you?")
  print("Initial Assistant Response:", initial_response)


  for ref in initial_response.references:
      print(f"Reference Number: {ref.reference_num}, Source: {ref.source}, Showed Number: {ref.showed_num}")


  response = chat.send_message("Can you tell me more?")
  print("Assistant Response:", response)


  history = chat.history
  print("Chat History:", history)
  ```



  For any questions or support, please open an issue on [GitHub](https://github.com/Pyxis-Cognitive-Solutions/cogsol-python-sdk/).


pkgId: c93200b1626ecd39d40246e2aba3eb7e25da74d63edc5ef730c102f0ebea1042
name: python-cogsworth
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A framework for performing self-consistent population synthesis and orbital integration
url: https://github.com/TomWagg/cogsworth
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cogsworth-2.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img width=500 src="docs/_static/cogsworth_invite.png">
  </p>
  <p align="center">cogsworth is a Python package for performing self-consistent population synthesis and galactic dynamics simulations</p>
  <p align="center">
    <a href='https://cogsworth.readthedocs.io/en/latest/?badge=latest'>
      <img src='https://readthedocs.org/projects/cogsworth/badge/?version=latest' alt='Documentation Status' />
  </a>
  </p>


pkgId: c9b89251a07d4dd90e4699d578edd4b80d1e686b91718ea757b9cfa71f396bb4
name: python-coguard-cli
arch: src
version: 0.2.44
epoch: 0
release: 1
summary: A command line interface for scanning configuration files with CoGuard
url: https://github.com/coguardio/coguard-cli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coguard-cli-0.2.44-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/coguardio/coguard-cli/raw/master/logo.png" alt="Light mode logo" width="500">



  CoGuard is a comprehensive static analysis tool for IT infrastructure
  configurations (cloud and on-premise).

  Finding and
  fixing misconfigurations and security vulnerabilities for IaC, devices,
  containers, cloud settings, and applications. Reduce the noise of CVE
  notifications and focus on small improvements for big wins.



  - [Why CoGuard](#why-coguard)
  - [Introduction to the CLI](#introduction)
  - [Installation](#installation-instructions)
      - [Pre-Requisites](#pre-requisites)
      - [Install from repository or PIP](#installation)
      - [Installation Tips](#installation-remarks)
  - [Usage](#how-to-use-it)
      - [Scan local Docker images](#docker-scan)
      - [Scan local project repositories](#repo-scan)
      - [Extract &amp; scan cloud configurations](#cloud-scan)
      - [General Scan](#general-scan)
      - [Add to CI/CD Pipeline](#add-to-cicd-pipeline)
  - [Screenshots](#screenshots)
  - [Supported Technologies &amp; Roadmap](#supported-technologies)
  - [Learn More](#learn-more)



  Infrastructure as Code (IaC) is here to stay. The versioning and
  continuous scanning of every layer of your IT (on premise and cloud)
  infrastructure is crucial.

  CoGuard's team observed that there are a lot of policy checks on the layers
  communicating to the cloud, but the configurations inside specific
  compute devices such as physical servers, virtual machines or
  containers are mostly neglected, or have silo-ed solutions at best.

  In order to have static analysis practices for IaC that go as deep as
  the available tools for code, every layer needs to be equally addressed.

  In our practice, we observed that, at times, even an awareness of
  locations of configuration files is lacking. This is why we created a
  command line tool helping with discovering those configurations, and
  scanning them.

  CoGuard's CLI combines multiple ways to extract and scan your configuration
  files.

  1. Docker images: Modern
     container scanners check for versions of software and libraries
     installed on those containers, and establish if there are common known
     vulnerabilities and exposures (CVEs). The
     CoGuard CLI is trying to find known configuration files for e.g. web
     servers or databases, and scans these for security and best practice.
     Additionally, the last Docker file used to create an image is analyzed
     as well.
  2. Project Repositories: Modern projects store their infrastructure
     information inside code repositories for better visibility and
     traceability. CoGuard can extract Infrastructure as Code (IaC)
     files and other supported configurations. It also searches for
     external container references and scans these as well.
  3. Cloud configurations not represented as IaC: Many organizations
     have either not yet started using IaC tools, or have a hybrid model
     of part IaC, part manual management. For these cases, we can
     extract cloud configurations for AWS, Azure or GCP, and scan them
     as well.



  This project is the command line interface to CoGuard, with additional
  functionality for the auto-discovery of configuration files.

  The current release scans for:
  1. Docker images and its contents,
  2. project folders (such as GitHub Repositories) and
  3. will automatically extracted cloud configurations from the AWS, Azure and GCP

  It searches for known [configuration files](#supported-technologies) of different
  software packages (like webservers, databases, etc.), and scans these
  configurations for configuration errors and security best practices.





  You need to have `python3`, `pip3` and `docker` installed on your system.
  Instructions for different operating systems and commands to be used for Python and Pip are provided below.

  <details>
  <summary>Ubuntu/Debian</summary>

  ```shell
  sudo apt install -y python3 python3-pip
  ```
  </details>

  <details>
  <summary>Alpine</summary>

  ```shell
  apk add python3 py3-pip
  ```
  </details>

  <details>
  <summary>CentOS/Fedora</summary>

  ```shell
  sudo yum install -y python3 python3-pip
  ```
  </details>

  <details>
  <summary>Arch Linux</summary>

  ```shell
  sudo pacman -S python python-pip
  ```
  </details>

  <details>
  <summary>Mac OS</summary>
  Assuming you are using [Homebrew](https://brew.sh), you have to run

  ```shell
  brew install python3
  ```
  </details>

  <details>
  <summary>Windows</summary>

  Download Python3 for Windows using [this link](https://www.python.org/downloads/windows/), and
  install it.

  </details>



  CoGuard CLI can either be pulled from this repository and used
  directly, or installed via `pip`:

  ```shell
  pip3 install coguard-cli
  ```

  This is a reminder that it is a requirement to have [Docker](https://docker.com) installed locally.




  **Remark 1**: It may happen that the folder where `pip` is installing packages is not
  in included in `PATH`. We have observed it on some Ubuntu installations, and on
  Homebrew Mac installs. For the Linux case, such as Ubuntu,
  you can find the binary usually under `$HOME/.local/bin/coguard`, i.e. you run
  ```shell
  $HOME/.local/bin/coguard docker-image [<YOUR-IMAGE-NAME-OR-ID>]
  ```
  For the Mac case, it is often installed under `~/Library/Python/<YOUR_PYTHON_VERSION>/bin/coguard`, i.e. you would run
  ```shell
  ~/Library/Python/<YOUR_PYTHON_VERSION>/bin/coguard docker-image [<YOUR-IMAGE-NAME-OR-ID>]
  ```

  If you omit the image ID parameter, CoGuard will scan all the images currently
  stored on your device.

  **Remark 2**: Windows users need to be allowed to create and read symbolic links.
  This can be achieved using three options:
  <details>
  <summary>Option 1</summary>
  1. Run the CoGuard execution as admin temporarily. This can be achieved by opening the
     PowerShell or command prompt as administrative user (right click on the icon),
     or by issuing the command
     ```shell
     Start-Process powershell -Verb runAs
     ```
     inside an already open command/Powershell window.
  </details>
  <details>
  <summary>Option 2</summary>
  2. Run Windows in Developer Mode (instructions on how to run Windows as a developer can
     be found [here](https://docs.microsoft.com/en-us/gaming/game-bar/guide/developer-mode)).
  </details>
  <details>
  <summary>Option 3</summary>
  3. Run CoGuard on a Linux virtual machine, e.g. using the Windows subsystem for Linux.
     This is commonly installed with Docker Desktop for Windows. If you do not have it installed,
     then installation instructions can be found
     [here](https://docs.microsoft.com/en-us/windows/wsl/install).
     The installation steps for CoGuard using WSL are equivalent to the pre-requisites
     and installation steps described for Linux (dependent on the distribution you choose).
  </details>




  Any of the following options requires you to create a CoGuard account.
  After completion, this image check will return the findings of CoGuard
  on this particular image. You can view the latest historical scan results
  when logging in to [https://portal.coguard.io](https://portal.coguard.io).



  Using the CoGuard CLI, you can run a scan on your local Docker images
  using

  ```shell
  coguard docker-image [scan] [<YOUR-IMAGE-NAME-OR-ID>]
  ```



  Using the CoGuard CLI, you can run a scan on your local
  file repositories using

  ```shell
  coguard folder [scan] [<PATH-TO-FOLDER>]
  ```



  Using the CoGuard CLI, you can run a scan a current snapshot of your
  cloud configurations. This requires you to have the respective
  cloud CLI tools (`aws-cli` for AWS, `gcloud` for GCP or `az` for
  Azure) installed and authenticated on your device.

  ```shell
  coguard cloud [scan] {aws, azure, gcp}
  ```

  The extraction may take a couple of minutes, depending on your
  internet speed.



  To get a general scan, which includes all locally installed Docker
  images, anything in the current-working directory (recursive) and any
  installed cloud provider authentication, simply run

  ```shell
  coguard scan
  ```



  CoGuard can be included as a step in your CI/CD pipeline. CoGuard generates the
  necessary templates and scripts.

  GitHub Actions is available in the current release. To generate e.g. a GitHub Actions
  YAML which automatically scans your repository on
  pull request/push, simply type

  ```shell
  coguard pipeline github add <PATH_TO_YOUR_REPOSITORY>
  ```
  [Future support is planned](#support-roadmap) for GitLab CI/CD, Jenkins, Bamboo, CircleCI, etc.



  Here is a screenshot of a sample scan:

  ![](./screenshot.png)

  As you can see, CoGuard also analyzes the last Dockerfile used.

  The checks are gathered from different security controls, but also
  directly from the user manuals of these software projects. At times, known issues for
  certain versions and security remediations specific to a certain version are being taken
  into account as well.




  CoGuard currently supports the the auto-discovery of configuration files inside
  Docker containers, folders and cloud configuration exports. The full list of configurations files
  can be found
  [in this folder](https://github.com/coguardio/coguard-cli/tree/master/src/coguard_cli/discovery/config_file_finders).

  - Supported Applications &amp; Infrastructure as Code
      - Apache Kafka
      - Apache Tomcat
      - Apache WebServer
      - CloudFormation
      - Dockerfile
      - ElasticSearch
      - Helm
      - Kerberos
      - Kubernetes
      - MongoDB
      - MySQL
      - Netlify
      - NGINX
      - OpenTelemetry Collector
      - PostgreSQL
      - Redis
      - TerraForm
  - Supported Cloud Hosts
      - AWS
      - Azure
      - GCP
      - OVH Cloud
  - <a id="supported-roadmap"></a>Roadmap (Future Support Planned)
      - Ansible
      - Jenkins
      - Bamboo
      - CircleCI
      - OpenAPI
      - Puppet
      - BitBucket Pipelines
      - [Contact us](https://coguard.io/contact) for full list or to add a specific request or custom rules

  This list
  will expand in the future. In addition, we are scanning the
  Dockerfile used to create the images, and will add some Linux
  configuration files in the near future.



  - [CoGuard](https://www.coguard.io)
  - [Blog](https://www.coguard.io/blog)
  - [Contact Us](https://coguard.io/contact)


pkgId: 174392696cee0871e1410df63146e4a1f0c2e7a5e02daa8a41bc1339b4bc7a0b
name: python-cogwatch
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Automatic hot-reloading for your discord.py (or other supported libaries) command files.
url: https://github.com/robertwayne/cogwatch
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cogwatch-3.3.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Cog Watch</h1>

  <div align="center">
    <strong><i>Automatic hot-reloading for your discord.py command files.</i></strong>
    <br />
    <br />

    <a href="https://pypi.org/project/cogwatch">
      <img
        src="https://img.shields.io/pypi/v/cogwatch?color=0073B7&label=Latest&style=for-the-badge"
        alt="Version" />
    </a>

    <a href="https://python.org">
      <img
        src="https://img.shields.io/pypi/pyversions/cogwatch?color=0073B7&style=for-the-badge"
        alt="Python Version" />
    </a>
  </div>
  <br />

  `cogwatch` is a utility that you can plug into your `discord.py` bot *(or
  various supported bot libraries)* that will watch your command files directory
  *(cogs)* and automatically reload them as you modify or move them around in
  real-time.

  No more reloading your commands manually every time you edit an embed just to
  make sure it looks perfect!

  <img align="center" src="assets/example.png" alt=""> <br />



  - Automatically reloads commands in real-time as you edit them *(no !reload
    <command_name> needed)*.
  - Optionally handles the loading of all your commands on start-up *(removes
    boilerplate)*.



  `cogwatch` *should* work with any library that forked from `discord.py`.
  However, these libraries have been explicitly tested to work:

  - [discord.py](https://discordpy.readthedocs.io/en/stable/)
  - [nextcord](https://docs.nextcord.dev/en/stable/)
  - [discord4py](https://docs.discord4py.dev/en/developer/)
  - [disnake](https://disnake.readthedocs.io/en/latest/)
  - [pycord](https://docs.pycord.dev/en/stable/)



  You can install the library with `pip install cogwatch`.

  Import the `watch` decorator and apply it to your `on_ready` method and let the
  magic take effect.

  See the [examples](/examples) directory for more details.

  ```python
  import asyncio
  from discord.ext import commands
  from cogwatch import watch


  class ExampleBot(commands.Bot):
      def __init__(self):
          super().__init__(command_prefix='!')

      @watch(path='commands', preload=True) # This is all you need to add.
      async def on_ready(self):
          print('Bot ready.')

      async def on_message(self, message):
          if message.author.bot:
              return

          await self.process_commands(message)


  async def main():
      client = ExampleBot()
      await client.start('YOUR_TOKEN_GOES_HERE')

  if __name__ == '__main__':
      asyncio.run(main())
  ```



  These options can be passed to the decorator *(or the class if manually
  initializing)*:

  `path`: Path of the directory where your command files exist; cogwatch will
  watch recursively within this directory. **Defaults to 'commands'**.

  `preload`: Whether to detect and load all cogs on start. **Defaults to False.**

  `colors`: Whether to use colorized terminal outputs or not. **Defaults to
  True.**

  `default_logger`: Whether to use the default logger *(to sys.stdout)* or not.
  **Defaults to True.**

  `loop`: Custom event loop. **Defaults to the current running event loop.**

  `debug`: Whether to run the bot only when the Python **\_\_debug\_\_** flag is
  True. **Defaults to True.**

  **NOTE:** `cogwatch` will only run if the **\_\_debug\_\_** flag is set on
  Python. You can read more about that
  [here](https://docs.python.org/3/library/constants.html). In short, unless you
  run Python with the *-O* flag from your command line, **\_\_debug\_\_** will be
  **True**. If you just want to bypass this feature, pass in `debug=False` and it
  won't matter if the flag is enabled or not.



  By default, the utility has a logger configured so users can get output to the
  console. You can disable this by passing in `default_logger=False`. If you want
  to hook into the logger -- for example, to pipe your output to another terminal
  or `tail` a file -- you can set up a custom logger like so:

  ```python
  import logging
  import sys

  watch_log = logging.getLogger('cogwatch')
  watch_log.setLevel(logging.INFO)
  watch_handler = logging.StreamHandler(sys.stdout)
  watch_handler.setFormatter(logging.Formatter('[s] s'))
  watch_log.addHandler(watch_handler)
  ```



  cogwatch is available under the **[MIT License](/LICENSE)**.


pkgId: 50d4233b431a939e984779636268c0e7efc19363745d201ac6345cbad24772e1
name: python-cohere
arch: src
version: 5.11.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cohere/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cohere-5.11.0-1.src.rpm
checksum_type: sha256
description:
  ![](banner.png)

  [![version badge](https://img.shields.io/pypi/v/cohere)](https://pypi.org/project/cohere/)
  ![license badge](https://img.shields.io/github/license/cohere-ai/cohere-python)
  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-SDK%20generated%20by%20Fern-brightgreen)](https://github.com/fern-api/fern)

  The Cohere Python SDK allows access to Cohere models across many different platforms: the cohere platform, AWS (Bedrock, Sagemaker), Azure, GCP and Oracle OCI. For a full list of support and snippets, please take a look at the [SDK support docs page](https://docs.cohere.com/docs/cohere-works-everywhere).



  Cohere documentation and API reference is available [here](https://docs.cohere.com/).



  ```
  pip install cohere
  ```



  ```Python
  import cohere

  co = cohere.Client(
      api_key="YOUR_API_KEY",
  )

  chat = co.chat(
      message="hello world!",
      model="command"
  )

  print(chat)
  ```

  > [!TIP]
  > You can set a system environment variable `CO_API_KEY` to avoid writing your api key within your code, e.g. add `export CO_API_KEY=theapikeyforyouraccount`
  > in your ~/.zshrc or ~/.bashrc, open a new terminal, then code calling `cohere.Client()` will read this key.




  The SDK supports streaming endpoints. To take advantage of this feature for chat,
  use `chat_stream`.

  ```Python
  import cohere

  co = cohere.Client(
      api_key="YOUR_API_KEY",
  )

  stream = co.chat_stream(
      message="Tell me a short story"
  )

  for event in stream:
      if event.event_type == "text-generation":
          print(event.text, end='')
  ```



  While we value open-source contributions to this SDK, the code is generated programmatically. Additions made directly would have to be moved over to our generation code, otherwise they would be overwritten upon the next generated release. Feel free to open a PR as a proof of concept, but know that we will not be able to merge it as-is. We suggest opening an issue first to discuss with us!

  On the other hand, contributions to the README are always very welcome!


pkgId: 1cf14526e2ff7b583c66f621013a76b4f2e18d39d39e4770f56e06775a12590f
name: python-cohere-haystack
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cohere-haystack/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cohere-haystack-2.0.0-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [cohere-haystack](#cohere-haystack)
    - [Installation](#installation)
    - [Contributing](#contributing)
    - [License](#license)

  ```console
  pip install cohere-haystack
  ```

  `hatch` is the best way to interact with this project, to install it:
  ```sh
  pip install hatch
  ```
  With `hatch` installed, to run all the tests:
  ```
  hatch run test
  ```
  > Note: integration tests will be skipped unless the env var COHERE_API_KEY is set. The api key needs to be valid
  > in order to pass the tests.
  To only run unit tests:
  ```
  hatch run test -m"not integration"
  ```
  To only run embedders tests:
  ```
  hatch run test -m"embedders"
  ```
  To only run generators tests:
  ```
  hatch run test -m"generators"
  ```
  To only run ranker tests:
  ```
  hatch run test -m"ranker"
  ```
  Markers can be combined, for example you can run only integration tests for embedders with:
  ```
  hatch run test -m"integrations and embedders"
  ```
  To run the linters `ruff` and `mypy`:
  ```
  hatch run lint:all
  ```

  `cohere-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.


pkgId: 766705a44ae87aae6779bc0d508df2b340b2d67a6c38ea45c86f325ef04c970d
name: python-cohesion
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A tool for measuring Python class cohesion.
url: https://github.com/mschwager/cohesion
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cohesion-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Python Versions](https://img.shields.io/pypi/pyversions/cohesion.svg)](https://img.shields.io/pypi/pyversions/cohesion.svg)
  [![PyPI Version](https://img.shields.io/pypi/v/cohesion.svg)](https://img.shields.io/pypi/v/cohesion.svg)

  Cohesion is a tool for measuring Python class cohesion.

  > In computer programming, cohesion refers to the degree to which the elements
  > of a module belong together. Thus, cohesion measures the strength of
  > relationship between pieces of functionality within a given module. For
  > example, in highly cohesive systems functionality is strongly related.
  > - [Wikipedia](https://en.wikipedia.org/wiki/Cohesion_(computer_science))

  > When cohesion is high, it means that the methods and variables of the class
  > are co-dependent and hang together as a logical whole.
  > - Clean Code pg. 140

  Some of the advantages of high cohesion, also by Wikipedia:

  * Reduced module complexity (they are simpler, having fewer operations).
  * Increased system maintainability, because logical changes in the domain
    affect fewer modules, and because changes in one module require fewer
    changes in other modules.
  * Increased module reusability, because application developers will find
    the component they need more easily among the cohesive set of operations
    provided by the module.



  ```
  $ python -m pip install cohesion
  $ cohesion -h
  ```

  OR

  ```
  $ git clone https://github.com/mschwager/cohesion.git
  $ cd cohesion
  $ PYTHONPATH=lib/ python -m cohesion -h
  ```



  Cohesion measures class and instance variable usage across the methods
  of that class.

  ```
  $ cat example.py
  class ExampleClass1(object):
      class_variable1 = 5
      class_variable2 = 6

      def func1(self):
          self.instance_variable = 6

          def inner_func(b):
              return b + 5

          local_variable = self.class_variable1

          return local_variable

      def func2(self):
          print(self.class_variable2)

      @staticmethod
      def func3(variable):
          return variable + 7

  class ExampleClass2(object):
      def func1(self):
          self.instance_variable1 = 7
  ```

  ```
  $ cohesion --files example.py --verbose
  File: example.py
    Class: ExampleClass1 (1:0)
      Function: func1 2/3 66.67%
        Variable: class_variable1 True
        Variable: class_variable2 False
        Variable: instance_variable True
      Function: func2 1/3 33.33%
        Variable: class_variable1 False
        Variable: class_variable2 True
        Variable: instance_variable False
      Function: func3 0/3 0.00%
        Variable: class_variable1 False
        Variable: class_variable2 False
        Variable: instance_variable False
      Total: 33.33%
    Class: ExampleClass2 (23:0)
      Function: func1 1/1 100.00%
        Variable: instance_variable1 True
      Total: 100.00%
  ```

  The `--below` and `--above` flags can be specified to only show classes with
  a cohesion value below or above the specified percentage, respectively.



  Cohesion supports being run by `flake8`. First, ensure your installation has
  registered `cohesion`:

  ```
  $ flake8 --version
  3.2.1 (pyflakes: 1.0.0, cohesion: 0.8.0, pycodestyle: 2.2.0, mccabe: 0.5.3) CPython 2.7.12 on Linux
  ```

  And now use `flake8` to lint your file:

  ```
  $ flake8 example.py
  example.py:1:1: H601 class has low cohesion
  ```



  If you would like to simultaneously run Cohesion on Python 2 and Python 3
  code then you will have to install it for both versions. I.e.

  ```
  $ python2 -m pip install cohesion
  $ python3 -m pip install cohesion
  ```

  Then use the corresponding version to run the module:

  ```
  $ python2 -m cohesion --files python2_file.py
  $ python3 -m cohesion --files python3_file.py
  ```



  First, install development packages:

  ```
  $ python -m pip install -r requirements-dev.txt
  ```



  ```
  $ pytest
  ```



  ```
  $ flake8
  ```



  ```
  $ pytest --cov
  ```


pkgId: e8b0ac954e1fd2228ec342fc67bc49a9c3efe89cf6b74bb8a4ea00fd272f936e
name: python-cohesity-management-sdk
arch: src
version: 1.10.1
epoch: 0
release: 1
summary: This SDK provides operations for interfacing with the Cohesity Cluster.
url: https://github.com/cohesity/management-sdk-python
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cohesity-management-sdk-1.10.1-1.src.rpm
checksum_type: sha256
description:
  [![License: Apache2](https://img.shields.io/hexpm/l/plug.svg)](https://github.com/cohesity/management-sdk-python/blob/master/LICENSE)
  ![GitHub release (latest by date including pre-releases)](https://img.shields.io/github/v/release/cohesity/management-sdk-python?include_prereleases)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/cohesity_management_sdk)
  ![Maintenance](https://img.shields.io/maintenance/yes/2023)

  The *Cohesity Management SDK*  provides an easy-to-use language binding to
  harness the power of *Cohesity REST APIs* in your python applications.

   - [Getting Started](#get-started)
   - [Cluster Version and Compatibility Matrix](#compatibility-matrix)
   - [Documentation](#documentation)
   - [How to use](#howto)
   - [More samples](#sample)
   - [How can you contribute](#contribute)
   - [Suggestions and Feedback](#suggest)


  Install via pip:
  ```
  pip install cohesity-management-sdk
  ```
  Install from source:
  The generated code uses Python packages named requests, jsonpickle and dateutil.
  You can resolve these dependencies using [pip](https://pip.pypa.io/en/stable/).
  This SDK uses the Requests library and will work for Python *2 >=2.7.9*
  and Python *3 >=3.4*.
  ```
  git clone https://github.com/cohesity/management-sdk-python.git
  cd management-sdk-python
  pip install -r requirements.txt
  python setup.py install
  ```

  To upgrade the package:
  ```
   pip install cohesity-management-sdk --upgrade
  ```
  To upgade the package to specific release:
  ```
  pip install cohesity-management-sdk==1.5.1
  ```

  |Cluster Version| SDK Version|
  |---|--|
  |7.0|1.10.1|
  |6.8.1_u1|1.9.2|
  |6.8.1_u1|1.9.1|
  |6.8.1_u1|1.9.0|
  |6.6.0x|1.8.1|
  |6.6x| 1.6.0|
  |6.5.1x|1.5.0|
  |6.5.0x|1.4.0|
  |6.4.1x|1.2.0|
  |6.3.1x|1.1.3|
  |6.4x|1.1.1|
  |6.3x|1.1.0|

  <a href="https://developer.cohesity.com/versions.html">Refer Python docs for your cluster version. </a>

  This SDK exposes all the functionality provided by *Cohesity REST API*.
  Initializing the Client using `username` and `password`:
  ```
  username = 'Username'
  password = 'Password'
  domain = 'Domain' #optional
  cluster_vip = 'prod-cluster.eng.cohesity.com'
  client = CohesityClient(cluster_vip, username, password, domain)
  cluster_controller = client.cluster
  result = cluster_controller.get_basic_cluster_info()
  result_dict =  result.__dict__
  print(result_dict['cluster_software_version'])

  6.4.1_release-20191219_aafe3274


pkgId: d4beac04ebd55fdd311ada19e12093f3b88fe1069e9d9a641eef762bb688b577
name: python-cohost
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Unofficial Python API wrapper for Cohost.org - the fourth website!
url: https://pypi.org/project/cohost/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cohost-0.5.1-1.src.rpm
checksum_type: sha256
description:
  ![Edit of Eggbug into the python logo](pybug_small.png)

  A python library for Cohost!



  > `pip install cohost`



  > `pip install cohost`

  ```python3
  from cohost.models.user import User
  from cohost.models.block import AttachmentBlock, MarkdownBlock

  cookie = 'yourCookie'
  user = User.loginWithCookie(cookie)




  for project in user.editedProjects:
      print(project) # Print all pages you have edit permissions for
  project = user.getProject('vallerie') # will retrieve the page I have edit writes for with handle @vallerie

  blocks = [
      AttachmentBlock('pybug.png'), # References image file pybug.png
      MarkdownBlock('**Hello from Python!**') # Example of markdown / text block
  ]
  newPost = project.post('Title of python post!', blocks, tags=['cohost.py', 'python'])
  print('Check out your post at {}'.format(newPost.url))
  ```



  1. Have an activated Cohost.org account. This entire library will probably explode if you use it with an unactivated account, and it defo isn't some bypass.
  2. Install library with `pip install cohost`
  3. Log in with a cookie or a username/password
  4. Import data models you require, and go from there!



  Some things are different on the API, and on the UI, and for the most part this library will match the API's terminology. Some key concepts:

  - A user is minimal - it will contain authentication, email, and some other key details but not much else
  - All the pages you can edit are referred to as "projects"
  - Each post is made up content "Blocks"



  One way to login is to use an authentication token for Cohost. This can be retrieved by:

  1. Open Developer Tools in your browser
  1. Go to "Storage"
  1. Find the "Cookies" entry
  1. Copy the data for "`connect.sid`".
  1. Use this in the library



  - Logging in as a user (using either a cookie or a username/password)
  - Retrieving projects of a user (and of other people when you got a post to go with it)
  - Retrieving posts of a page
  - Posting to a page
  - Attaching images to a post (with alt-text support!)
  - Editing posts
  - Retrieving notifications with pagination



  - Retrieving single posts - currently have to read entire projects
  - Retrieving a project's drafts
  - Retrieving a projects of others without a post inbetween
  - Sharing posts (with comment)
  - Editing profiles
  - Deleting posts
  - Likely a whole bunch of other things I haven't thought about
  - Better docs



  Some features I intend not to add. These features aren't impossible to build, but, they could be detrimental to the Cohost experience for other users, send mass notifications without an account being activated, or pose security issues. This is designed to deter low effort malicious bots, to reduce the workload on Cohost's staff.

  These include:

  - Editing a user's password
  - Accepting follow requests
  - Sharing a post without a comment
  - Creating new projects

  If you implement these features, please keep them **private** for your projects.
  If you think one of these should be implemented, please file a GitHub issue with your case as to why.



  [Buy Cohost PLUS](https://cohost.org/rc/user/settings)



  [hello is me](https://cohost.org/vallerie)



  - [cohost.js](https://github.com/mogery/cohost.js/) - provided a good point to start looking at how to go about this, and how cohost works in fundamental aspects. also has a working login thing which i need to properly understand at some point
  - [cohost.org](https://cohost.org) - home of eggbug
  - [requests](https://requests.readthedocs.io/en/latest/) - i would be lost in python if it weren't for requests, my beloved
  - the random tumblr anon who sent me an activation link - thanks

rpm_license:
  MIT License  Copyright (c) 2022 Vallerie Knight  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: fd0e470692e5f93d2dd169b27b0d66d4d81db7353fe7d46a4982e243546195a1
name: python-coiled
arch: src
version: 1.60.0
epoch: 0
release: 1
summary: Python client for coiled.io dask clusters
url: https://coiled.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coiled-1.60.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="https://raw.githubusercontent.com/coiled/logos/master/Coiled-Logo_Horizontal_Black-RGB.png" width="200" style="max-width: 200px;" alt="Coiled">
  </p>

  <p align="center">
    <a href="https://coiled.io">Coiled.io</a> •
    <a href="https://docs.coiled.io/user_guide/index.html">Documentation</a> •
    <a href="https://join.slack.com/t/coiled-users/shared_invite/zt-hx1fnr7k-In~Q8ui3XkQfvQon0yN5WQ">Community</a> •
    <a href="https://docs.coiled.io/user_guide/support.html">Support</a>
  </p>

  Coiled is a deployment-as-a-service library for scaling Python with Dask, a popular open source library for parallel analytics. Coiled manages cloud resources, networking, software environments, and everything you need to scale Python in the cloud robustly and easily.

  Go to https://cloud.coiled.io to get started with Coiled.


pkgId: 71b41e64ba37bd9fb176024a743713afae55247d678e1492dd32c292c15d6bc8
name: python-coinaddrvalidator
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: A crypto-currency address inspection/validation library.
url: https://github.com/nobitex/coinaddrvalid
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinaddrvalidator-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Github Repo](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/nobitex/coinaddrvalidator) [![Pypi Version](https://img.shields.io/pypi/v/coinaddrvalidator.svg)](https://pypi.python.org/pypi/coinaddrvalidator) [![Pypi License](https://img.shields.io/pypi/l/coinaddrvalidator.svg)](https://pypi.python.org/pypi/coinaddrvalidator) [![Pypi Wheel](https://img.shields.io/pypi/wheel/coinaddrvalidator.svg)](https://pypi.python.org/pypi/coinaddrvalidator) [![Pypi Versions](https://img.shields.io/pypi/pyversions/coinaddrvalidator.svg)](https://pypi.python.org/pypi/coinaddrvalidator)


  Mohammad Aghamir - *Maintainer of this repository* - [coinaddrvalidator](https://github.com/nobitex/coinaddrvalidator)


  Devmons s.r.o. - *Maintainer of this fork* - [coinaddrng](https://github.com/crypkit/coinaddrng)

  See also the list of [contributors](https://github.com/crypkit/coinaddrng/contributors) who participated in this project.


  Joe Black | <me@joeblack.nyc> | [github](https://github.com/joeblackwaslike)



  A cryptocurrency address inspection/validation library for python.


  * binancecoin
  * bitcoin
  * bitcoin-sv
  * bitcoin-cash
  * boscoin
  * cardano
  * cosmos
  * dashcoin
  * decred
  * dogecoin
  * eos
  * ethereum
  * ethereum-classic
  * ether-zero
  * groestlcoin
  * horizen
  * kusama
  * litecoin
  * neocoin
  * ontology
  * polkadot
  * ravencoin
  * ripple
  * stellar
  * tezos
  * tronix
  * vechain
  * zcash


  ```shell
  pip3 install coinaddrvalidator
  ```


  ```python
  >>> import coinaddrvalidator
  >>> coinaddrvalidator.validate('btc', b'1BoatSLRHtKNngkdXEeobR76b53LETtpyT')
  ValidationResult(name='bitcoin', ticker='btc', address=b'1BoatSLRHtKNngkdXEeobR76b53LETtpyT', valid=True, network='main', is_extended=False, address_type='address')
  ```

  ValidationResult returns coin name and ticker, address, if the address is valid or not. In case network prefix bytes are defined for the checked currency, then the network
  is returned, too. If the coin supports that and the address is an extended key, it returns if it is valid or not.  For some coins the address type can be guessed based on its
  format, which is returned as address_type. If there's none, 'address' is being returned as a default.



  To add a new currency, simply instantiate a new `coinaddr.currency.Currency` class.  It will be automatically registered.
  ```python
  from coinaddrvalidator import Currency
  Currency('decred', ticker='dcr', validator='DecredCheck',
          networks=dict(
              main=(0x073f,0x071a,0x02fda926), test=(0x0f21,0x0efc,0x043587d1)),
          address_types=dict(
              address=(0x073f,0x0f21), ticket=(0x071a,0x0efc),
              xpubkey=(0x02fda926,0x043587d1)))
  ```

  To override a default currency, simply instantiate a new currency with that name.



  To add a new validator, simply create a subclass of `coinaddr.validation.ValidatorBase` with your own implementation that implements the `coinaddr.interfaces.IValidator` interface.  It will be automatically registered.
  ```python
  from zope.interface import implementer
  from coinaddr.interfaces import IValidator
  from coinaddr import ValidatorBase


  @implementer(IValidator)
  class NewValidator(ValidatorBase):
      name = 'New'

      @property
      def networks(self):
          return 'testing'

      def validate(self):
          return True
  ```

  To override a default validator, simply create a new validator with that name.



  * [CHANGELOG](CHANGELOG.md)


pkgId: 116897b57c1a7d2bdd381e63e5cef06ff022414e5f2c147def774269854c35d6
name: python-coinbase-advancedtrade-python
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: The unofficial Python client for the Coinbase Advanced Trade API
url: https://github.com/rhettre/coinbase-advancedtrade-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinbase-advancedtrade-python-0.3.2-1.src.rpm
checksum_type: sha256
description:
  This is the unofficial Python client for the Coinbase Advanced Trade API. It allows users to interact with the API to manage their cryptocurrency trading activities on the Coinbase platform.



  - Easy-to-use Python wrapper for the Coinbase Advanced Trade API
  - Supports the new Coinbase Cloud authentication method
  - Built on top of the official [Coinbase Python SDK](https://github.com/coinbase/coinbase-advanced-py) for improved stability
  - Supports all endpoints and methods provided by the official API
  - Added support for trading strategies covered on the [YouTube channel](https://rhett.blog/youtube)



  1. Install the package using pip:
     ```bash
     pip install coinbase-advancedtrade-python
     ```

  2. Obtain your API key and secret from the Coinbase Developer Platform. The new API key format looks like this:
     ```
     API Key: organizations/{org_id}/apiKeys/{key_id}
     API Secret: -----BEGIN EC PRIVATE KEY-----\n...\n-----END EC PRIVATE KEY-----\n
     ```



  Here's an example of how to authenticate using the new method:

  ```python
  from coinbase_advanced_trader.enhanced_rest_client import EnhancedRESTClient

  api_key = "organizations/{org_id}/apiKeys/{key_id}"
  api_secret = "-----BEGIN EC PRIVATE KEY-----\n...\n-----END EC PRIVATE KEY-----\n"

  client = EnhancedRESTClient(api_key=api_key, api_secret=api_secret)
  ```



  The `EnhancedRESTClient` inherits from the Coinbase SDK's `RESTClient`, which means you can use all the functions provided by the official SDK. Here's an example of how to use the `get_product` function:

  ```python
  product_info = client.get_product(product_id="BTC-USDC")

  print(product_info)
  ```



  Here's an example of how to use the strategies package to buy $10 worth of Bitcoin. By making assumptions about limit price in [trading_config.py](coinbase_advanced_trader/trading_config.py) we are able to simplify the syntax for making orders:

  ```python

  client.fiat_market_buy("BTC-USDC", "10")


  client.fiat_limit_buy("BTC-USDC", "10")


  client.fiat_limit_buy("BTC-USDC", "10", "10000")


  client.fiat_limit_buy("BTC-USDC", "10", price_multiplier=".90")


  client.fiat_limit_sell("BTC-USDC", "10", "100000")


  client.fiat_limit_sell("BTC-USDC", "5")


  client.fiat_limit_sell("BTC-USDC", "5", price_multiplier="1.1")
  ```



  The `EnhancedRESTClient` provides methods to retrieve account balances for cryptocurrencies. These methods are particularly useful for managing and monitoring your cryptocurrency holdings on Coinbase.



  To get a dictionary of all cryptocurrencies with non-zero balances in your account:

  ```python
  balances = client.list_held_crypto_balances()
  print(balances)
  ```



  To get the available balance of a specific cryptocurrency in your account (returns 0 if the specified cryptocurrency is not found in the account):

  ```python
  balance = client.get_crypto_balance("BTC")
  print(balance)
  ```

  Note: Both methods use a caching mechanism to reduce API calls. The account data is cached for one hour before a fresh fetch is made from Coinbase.



  ```python

  client.trade_based_on_fgi("BTC-USDC", "10")
  ```

  You can also update and retrieve the Fear and Greed Index schedule:

  ```python

  current_schedule = client.get_fgi_schedule()


  new_schedule = [
      {'threshold': 15, 'factor': 1.2, 'action': 'buy'},
      {'threshold': 37, 'factor': 1.0, 'action': 'buy'},
      {'threshold': 35, 'factor': 0.8, 'action': 'sell'},
      {'threshold': 45, 'factor': 0.6, 'action': 'sell'}
  ]
  client.update_fgi_schedule(new_schedule)
  ```



  This client now includes integration with AlphaSquared, allowing you to execute trading strategies based on AlphaSquared's risk analysis.



  1. Obtain your AlphaSquared API key from [AlphaSquared](https://alphasquared.io/).

  2. Initialize the AlphaSquared client along with the Coinbase client:

  ```python
  from coinbase_advanced_trader import EnhancedRESTClient, AlphaSquaredTrader
  from alphasquared import AlphaSquared


  coinbase_api_key = "YOUR_COINBASE_API_KEY"

  coinbase_api_secret = "YOUR_COINBASE_API_SECRET"

  coinbase_client = EnhancedRESTClient(api_key=coinbase_api_key, api_secret=coinbase_api_secret)


  alphasquared_api_key = "YOUR_ALPHASQUARED_API_KEY"

  alphasquared_client = AlphaSquared(alphasquared_api_key, cache_ttl=60)


  trader = AlphaSquaredTrader(coinbase_client, alphasquared_client)
  ```



  To execute a trading strategy based on AlphaSquared's risk analysis:

  ```python

  product_id = "BTC-USDC"


  strategy_name = "My Custom Strategy"


  trader.execute_strategy(product_id, strategy_name)
  ```

  This will:
  1. Fetch the current risk level for the specified asset from AlphaSquared.
  2. Determine the appropriate action (buy/sell) and value based on the custom strategy defined in AlphaSquared and the current risk.
  3. Execute the appropriate trade on Coinbase if the conditions are met.

  > **Note:** Make sure to handle exceptions and implement proper logging in your production code. This integration only works with custom strategies; it does not work with the default strategies provided by AlphaSquared.



  You can create custom strategies by modifying the `execute_strategy` method in the `AlphaSquaredTrader` class. This allows you to define specific trading logic based on the risk levels provided by AlphaSquared.



  The legacy authentication method is still supported but moved to a separate module. It will not receive the latest updates from the Coinbase SDK. To use the legacy method:

  ```python
  from coinbase_advanced_trader.legacy.legacy_config import set_api_credentials
  from coinbase_advanced_trader.legacy.strategies.limit_order_strategies import fiat_limit_buy

  legacy_key = "your_legacy_key"
  legacy_secret = "your_legacy_secret"

  set_api_credentials(legacy_key, legacy_secret)


  limit_buy_order = fiat_limit_buy("BTC-USDC", 10)
  ```



  For more information about the Coinbase Advanced Trader API, consult the [official API documentation](https://docs.cloud.coinbase.com/advanced-trade-api/docs/rest-api-overview/).



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



  Rhett Reisman

  Email: rhett@rhett.blog

  GitHub: https://github.com/rhettre/coinbase-advancedtrade-python



  This project is not affiliated with, maintained, or endorsed by Coinbase. Use this software at your own risk. Trading cryptocurrencies carries a risk of financial loss. The developers of this software are not responsible for any financial losses or damages incurred while using this software. Nothing in this software should be seen as an inducement to trade with a particular strategy or as financial advice.


pkgId: 0ccb9a9cdb76dee75e78b64ea928279db5320cafb952dda69d68a0b7f4351d98
name: python-coinbase-advancedtrade-python
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: The unofficial Python client for the Coinbase Advanced Trade API
url: https://github.com/rhettre/coinbase-advancedtrade-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinbase-advancedtrade-python-0.3.3-1.src.rpm
checksum_type: sha256
description:
  This is the unofficial Python client for the Coinbase Advanced Trade API. It allows users to interact with the API to manage their cryptocurrency trading activities on the Coinbase platform.



  - Easy-to-use Python wrapper for the Coinbase Advanced Trade API
  - Supports the new Coinbase Cloud authentication method
  - Built on top of the official [Coinbase Python SDK](https://github.com/coinbase/coinbase-advanced-py) for improved stability
  - Supports all endpoints and methods provided by the official API
  - Added support for trading strategies covered on the [YouTube channel](https://rhett.blog/youtube)



  1. Install the package using pip:
     ```bash
     pip install coinbase-advancedtrade-python
     ```

  2. Obtain your API key and secret from the Coinbase Developer Platform. The new API key format looks like this:
     ```
     API Key: organizations/{org_id}/apiKeys/{key_id}
     API Secret: -----BEGIN EC PRIVATE KEY-----\n...\n-----END EC PRIVATE KEY-----\n
     ```



  Here's an example of how to authenticate using the new method:

  ```python
  from coinbase_advanced_trader.enhanced_rest_client import EnhancedRESTClient

  api_key = "organizations/{org_id}/apiKeys/{key_id}"
  api_secret = "-----BEGIN EC PRIVATE KEY-----\n...\n-----END EC PRIVATE KEY-----\n"

  client = EnhancedRESTClient(api_key=api_key, api_secret=api_secret)
  ```



  The `EnhancedRESTClient` inherits from the Coinbase SDK's `RESTClient`, which means you can use all the functions provided by the official SDK. Here's an example of how to use the `get_product` function:

  ```python
  product_info = client.get_product(product_id="BTC-USDC")

  print(product_info)
  ```



  Here's an example of how to use the strategies package to buy $10 worth of Bitcoin. By making assumptions about limit price in [trading_config.py](coinbase_advanced_trader/trading_config.py) we are able to simplify the syntax for making orders:

  ```python

  client.fiat_market_buy("BTC-USDC", "10")


  client.fiat_limit_buy("BTC-USDC", "10")


  client.fiat_limit_buy("BTC-USDC", "10", "10000")


  client.fiat_limit_buy("BTC-USDC", "10", price_multiplier=".90")


  client.fiat_limit_sell("BTC-USDC", "10", "100000")


  client.fiat_limit_sell("BTC-USDC", "5")


  client.fiat_limit_sell("BTC-USDC", "5", price_multiplier="1.1")
  ```



  The `EnhancedRESTClient` provides methods to retrieve account balances for cryptocurrencies. These methods are particularly useful for managing and monitoring your cryptocurrency holdings on Coinbase.



  To get a dictionary of all cryptocurrencies with non-zero balances in your account:

  ```python
  balances = client.list_held_crypto_balances()
  print(balances)
  ```



  To get the available balance of a specific cryptocurrency in your account (returns 0 if the specified cryptocurrency is not found in the account):

  ```python
  balance = client.get_crypto_balance("BTC")
  print(balance)
  ```

  Note: Both methods use a caching mechanism to reduce API calls. The account data is cached for one hour before a fresh fetch is made from Coinbase.



  ```python

  client.trade_based_on_fgi("BTC-USDC", "10")
  ```

  You can also update and retrieve the Fear and Greed Index schedule:

  ```python

  current_schedule = client.get_fgi_schedule()


  new_schedule = [
      {'threshold': 15, 'factor': 1.2, 'action': 'buy'},
      {'threshold': 37, 'factor': 1.0, 'action': 'buy'},
      {'threshold': 35, 'factor': 0.8, 'action': 'sell'},
      {'threshold': 45, 'factor': 0.6, 'action': 'sell'}
  ]
  client.update_fgi_schedule(new_schedule)
  ```



  This client now includes integration with AlphaSquared, allowing you to execute trading strategies based on AlphaSquared's risk analysis.



  1. Obtain your AlphaSquared API key from [AlphaSquared](https://alphasquared.io/).

  2. Initialize the AlphaSquared client along with the Coinbase client:

  ```python
  from coinbase_advanced_trader import EnhancedRESTClient, AlphaSquaredTrader
  from alphasquared import AlphaSquared


  coinbase_api_key = "YOUR_COINBASE_API_KEY"

  coinbase_api_secret = "YOUR_COINBASE_API_SECRET"

  coinbase_client = EnhancedRESTClient(api_key=coinbase_api_key, api_secret=coinbase_api_secret)


  alphasquared_api_key = "YOUR_ALPHASQUARED_API_KEY"

  alphasquared_client = AlphaSquared(alphasquared_api_key, cache_ttl=60)


  trader = AlphaSquaredTrader(coinbase_client, alphasquared_client)
  ```



  To execute a trading strategy based on AlphaSquared's risk analysis:

  ```python

  product_id = "BTC-USDC"


  strategy_name = "My Custom Strategy"


  trader.execute_strategy(product_id, strategy_name)
  ```

  This will:
  1. Fetch the current risk level for the specified asset from AlphaSquared.
  2. Determine the appropriate action (buy/sell) and value based on the custom strategy defined in AlphaSquared and the current risk.
  3. Execute the appropriate trade on Coinbase if the conditions are met.

  > **Note:** Make sure to handle exceptions and implement proper logging in your production code. This integration only works with custom strategies; it does not work with the default strategies provided by AlphaSquared.



  You can create custom strategies by modifying the `execute_strategy` method in the `AlphaSquaredTrader` class. This allows you to define specific trading logic based on the risk levels provided by AlphaSquared.



  The legacy authentication method is still supported but moved to a separate module. It will not receive the latest updates from the Coinbase SDK. To use the legacy method:

  ```python
  from coinbase_advanced_trader.legacy.legacy_config import set_api_credentials
  from coinbase_advanced_trader.legacy.strategies.limit_order_strategies import fiat_limit_buy

  legacy_key = "your_legacy_key"
  legacy_secret = "your_legacy_secret"

  set_api_credentials(legacy_key, legacy_secret)


  limit_buy_order = fiat_limit_buy("BTC-USDC", 10)
  ```



  For more information about the Coinbase Advanced Trader API, consult the [official API documentation](https://docs.cdp.coinbase.com/advanced-trade/docs/welcome).



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



  Rhett Reisman

  Email: rhett@rhett.blog

  GitHub: https://github.com/rhettre/coinbase-advancedtrade-python



  This project is not affiliated with, maintained, or endorsed by Coinbase. Use this software at your own risk. Trading cryptocurrencies carries a risk of financial loss. The developers of this software are not responsible for any financial losses or damages incurred while using this software. Nothing in this software should be seen as an inducement to trade with a particular strategy or as financial advice.


pkgId: 9756621146c444cb097b462e22b4cebd98fa8d6a4d0937197988ec733069efce
name: python-coinbase-commerce
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Coinbase Commerce API client library
url: https://github.com/coinbase/coinbase-commerce-python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinbase-commerce-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/coinbase/coinbase-commerce-python/tree/master.svg?style=svg)](https://circleci.com/gh/coinbase/coinbase-commerce-python/tree/master)


  Coinbase Commerce Python



  <!--ts-->
     * [Python Versions](#python-version)
     * [Third Party Libraries and Dependencies](#third-party-libraries-and-dependencies)
     * [Documentation](#documentation)
     * [Installation](#installation)
     * [Usage](#usage)
        * [Checkouts](#checkouts)
        * [Charges](#charges)
        * [Events](#events)
     * [Validating webhook signatures](#validating-webhook-signatures)
     * [Testing and Contributing](#testing-and-contributing)
  <!--te-->


  Python 2.7+ and 3.4+ are supported and tested.



  The following libraries will be installed when you install the client library:
  * [requests](https://github.com/requests/requests)



  For more details visit [Coinbase API docs](https://commerce.coinbase.com/docs/api/).

  To start using library, you need to register on [Commerce SignUp](https://commerce.coinbase.com/signup).
  And get your ``API_KEY`` from user settings.

  Next create a ``Client`` object for interacting with the API:
  ```python
  from coinbase_commerce.client import Client

  API_KEY = "API KEY"
  client = Client(api_key=API_KEY)
  ```

  ``Client`` contains links to an every Python Class representations of the API resources
  ``Checkout, Charge, Event``

  You can call ``list, list_paging_iter, create, retrieve, modify`` methods from an API resource classes

  ```python
  client.charge.create
  client.checkout.list_paging_iter
  client.event.list
  client.charge.retrieve
  client.checkout.modify
  ```
  as well as ``save, delete, refresh`` methods from API resource class instances.
  ```python
  checkout = client.checkout.retrieve(<id>)
  checkout.refresh()
  checkout.save()
  checkout.delete()
  ```

  Each API method returns an ``APIObject`` (a subclass of ``dict``) representing the JSON response from the API, all of the models are dumpable with JSON.\
  Also when the response data is parsed into Python objects, the appropriate ``APIObject`` subclasses will be used automatically.
  All subclasses of ``APIResource`` class support ``refresh`` method. This will update their attributes and all nested data by making a fresh ``GET`` request to the relevant API endpoint.

  Client support Common API Errors and Warnings handling.
  All errors occuring during interaction with the API will be raised as exceptions.


  | Error                    | Status Code |
  |--------------------------|-------------|
  | APIError                 |      *      |
  | InvalidRequestError      |     400     |
  | ParamRequiredError       |     400     |
  | ValidationError          |     400     |
  | AuthenticationError      |     401     |
  | ResourceNotFoundError    |     404     |
  | RateLimitExceededError   |     429     |
  | InternalServerError      |     500     |
  | ServiceUnavailableError  |     503     |



  Install with ``pip``:

      pip install --upgrade coinbase-commerce

  or with ``easy_install``:

      easy_install --upgrade coinbase-commerce



  ```python
  from coinbase_commerce.client import Client

  client = Client(api_key=API_KEY)
  ```

  [Checkouts API docs](https://commerce.coinbase.com/docs/api/#checkouts)

  ```python
  checkout = client.checkout.retrieve(<checkout_id>)
  ```

  ```python
  checkout_info = {
      "name": 'The Sovereign Individual',
      "description": 'Mastering the Transition to the Information Age',
      "pricing_type": 'fixed_price',
      "local_price": {
          "amount": "100.00",
          "currency": "USD"
      },
      "requested_info": ["name", "email"]
  }
  checkout = client.checkout.create(**checkout_info)



  checkout = client.checkout.create(name='The Sovereign Individual',
                                    description='Mastering the Transition to the Information Age',
                                    pricing_type='fixed_price',
                                    local_price={
                                            "amount": "100.00",
                                            "currency": "USD"
                                            },
                                    requested_info=["name", "email"])
  ```

  ```python
  checkout = client.checkout.retrieve(<checkout_id>)
  checkout.name = 'new name'
  checkout.save()



  checkout = client.checkout.modify('<checkout_id>',
                                    name='new name')
  ```

  ```python
  checkout.delete()
  ```

  ```python
  checkouts = client.checkout.list()
  ```

  ```python
  for checkout in client.checkout.list_paging_iter():
      print("{!r}".format(checkout))

  ```

  [Charges API docs](https://commerce.coinbase.com/docs/api/#charges)

  ```python
  charge = client.charge.retrieve(<charge_id>)
  ```

  ```python
  charge_info = {
      "name": "The Sovereign Individual",
      "description": "Mastering the Transition to the Information Age",
      "local_price": {
          "amount": "100.00",
          "currency": "USD"
      },
      "pricing_type": "fixed_price"

  }
  charge = client.charge.create(**charge_info)



  charge = client.charge.create(name='The Sovereign Individual',
                                description='Mastering the Transition to the Information Age',
                                pricing_type='fixed_price',
                                local_price={
                                    "amount": "100.00",
                                    "currency": "USD"
                                })
  ```

  ```python
  checkouts = client.charge.list()
  ```

  ```python
  for charge in client.charge.list_paging_iter():
      print("{!r}".format(charge))
  ```

  [Events API Docs](https://commerce.coinbase.com/docs/api/#events)

  ```python
  event = client.event.retrieve(<event_id>)
  ```

  ```python
  events = client.event.list()
  ```

  ```python
  for event in client.event.list_paging_iter():
      print("{!r}".format(event))
  ```


  You could verify webhook signatures using our library.
  To perform the verification you'll need to provide the event data, a webhook signature from request header, and the endpoint’s secret.
  In case of invalid request signature or request payload, you will receive appropriate error message.
  ```python
  WEBHOOK_SECRET = 'your_webhook_secret'


  @app.route('/webhooks', methods=['POST'])
  def webhooks():
      
      request_data = request.data.decode('utf-8')
      
      request_sig = request.headers.get('X-CC-Webhook-Signature', None)

      try:
          
          event = Webhook.construct_event(request_data, request_sig, WEBHOOK_SECRET)
      except (WebhookInvalidPayload, SignatureVerificationError) as e:
          return str(e), 400

      print("Received event: id={id}, type={type}".format(id=event.id, type=event.type))
      return 'success', 200
  ```


  Any and all contributions are welcome! The process is simple: fork this repo, make your changes, run the test suite, and submit a pull request. Tests are run via nosetest. To run the tests, clone the repository and then:


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


  Use tox to run the test suite against multiple versions of Python. You can install tox with pip or easy_install:
  ```
  pip install tox
  easy_install tox
  ```
  Tox requires the appropriate Python interpreters to run the tests in different environments. We recommend using pyenv for this. Once you've installed the appropriate interpreters, running the tests in every environment is simple:
  ```
  tox
  ```


pkgId: d5c34a59bb956fa6ebee3a3c5db2ea6fbe317e053c732ba3c65535eee1f0a357
name: python-coincident
arch: src
version: 0.1
epoch: 0
release: 1
summary: Search and analysis of STV Precursor Coincident Datasets
url: https://github.com/uw-cryo/coincident
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coincident-0.1-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status][actions-badge]][actions-link]
  [![Documentation Status][rtd-badge]][rtd-link]

  [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/uw-cryo/coincident)

  <!-- SPHINX-START -->

  <!-- prettier-ignore-start -->
  [actions-badge]:            https://github.com/uw-cryo/coincident/workflows/CI/badge.svg
  [actions-link]:             https://github.com/uw-cryo/coincident/actions
  [conda-badge]:              https://img.shields.io/conda/vn/conda-forge/coincident
  [conda-link]:               https://github.com/conda-forge/coincident-feedstock
  [github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
  [github-discussions-link]:  https://github.com/uw-cryo/coincident/discussions
  [pypi-link]:                https://pypi.org/project/coincident/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/coincident
  [pypi-version]:             https://img.shields.io/pypi/v/coincident
  [rtd-badge]:                https://readthedocs.org/projects/coincident/badge/?version=latest
  [rtd-link]:                 https://coincident.readthedocs.io/en/latest/?badge=latest

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

  Identify, curate, process and distribute coincident datasets contained within
  select archives across a range of representative terrain and landcover types.
  Such datasets are intended to be used by the NASA STV community for
  calibration/validation, fusion algorithm development, and discipline-specific
  scientific analysis.

  See here for more information:
  <https://science.nasa.gov/earth-science/decadal-surveys/decadal-stv/coincident-datasets>

  **This tool is under active development, there are no stable releases yet!**



  - Python packaging template provided by
    <https://github.com/scientific-python/cookie>

  - Funding for this effort was provided by NASA Grant 80NSSC22K1094

rpm_license:
  Copyright 2024 Scott Henderson  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: eed2c9d92418591f4b2166f1a45e55fa663d905a6c7cc65916bcac27b703a548
name: python-coinmetrics-api-client
arch: src
version: 2024.10.31.17
epoch: 0
release: 1
summary: Python client for Coin Metrics API v4.
url: https://coinmetrics.github.io/api-client-python/site/index.html
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinmetrics-api-client-2024.10.31.17-1.src.rpm
checksum_type: sha256
description:
   0   asset             1 non-null      object
   1   time              1 non-null      datetime64[ns]
   2   ReferenceRateUSD  1 non-null      float64
  dtypes: datetime64[ns](1), float64(1), object(1)
  memory usage: 152.0+ bytes
  ```
  Note that in order to pass a custom datetime object, setting a dtype_mapper is mandatory.
  Pandas type conversion tends to be more performant. But if there are custom operations that must be done using numpy datatypes, this option will let you perform them.

  You can also easily export timeseries data to csv and json files with builtin functions on the `DataCollection` type.
  For example this script will export Coinbase btc and eth trades for a date to csv and json files respectively:
  ```python
      start_date = datetime.date(year=2022, month=1, day=1)
      end_date = datetime.datetime(year=2022, month=1, day=1)
      market_trades_btc = client.get_market_trades(page_size=1000, markets="coinbase-btc-usd-spot", start_time=start_date, end_time=end_date)
      market_trades_btc.export_to_csv("jan_1_2022_coinbase_btc_trades.csv")
      market_trades_eth = client.get_market_trades(page_size=1000, markets="coinbase-eth-usd-spot", start_time=start_date, end_time=end_date)
      market_trades_eth.export_to_json("jan_1_2022_coinbase_eth.json")
  ```

  You can make the datapoints to iterate from start (default) or from end.
  for that you should use a paging_from argument like the following:
  ```
  from coinmetrics.api_client import CoinMetricsClient
  from coinmetrics.constants import PagingFrom
  client = CoinMetricsClient()
  for metric_data in client.get_asset_metrics(assets='btc', metrics=['ReferenceRateUSD'],
                                              paging_from=PagingFrom.START):
      print(metric_data)
  ```
  PagingFrom.END: is available but by default it will page from the start.

  There are two additional options for the API Client - `debug_mode` and `verbose`. These two options log network calls
  to the console, and in the case of `debug_mode` it will generate a log file of all the network requests and the time
  it takes to call them. These tools can be used to diagnose issues in your code and also to get a better understanding
  of request times so that users can write more performant code. For example, running the below code:
  ```python
  import os
  from coinmetrics.api_client import CoinMetricsClient
  api_key = os.environ['CM_API_KEY']
  if __name__ == '__main__':
      client = CoinMetricsClient(api_key=api_key, debug_mode=True)
      reference_rates_example = client.get_asset_metrics(assets=['btc', 'algo', 'eth'], metrics=['ReferenceRateUSD'])
      for data in reference_rates_example:
          continue
  ```
  The console output will look like:
  ```commandline
  [DEBUG] 2023-01-09 11:01:02,044 - Starting API Client debugging session. logging to stdout and cm_api_client_debug_2023_01_09_11_01_02.txt
  [DEBUG] 2023-01-09 11:01:02,044 - Using coinmetrics version 2022.11.14.16
  [DEBUG] 2023-01-09 11:01:02,044 - Current state of API Client, excluding API KEY: {'_verify_ssl_certs': True, '_api_base_url': 'https://api.coinmetrics.io/v4', '_ws_api_base_url': 'wss://api.coinmetrics.io/v4', '_http_header': {'Api-Client-Version': '2022.11.14.16'}, '_proxies': {'http': None, 'https': None}, 'debug_mode': True, 'verbose': False}
  [DEBUG] 2023-01-09 11:01:02,044 - Attempting to call url: timeseries/asset-metrics with params: {'assets': ['btc', 'algo', 'eth'], 'metrics': ['ReferenceRateUSD'], 'frequency': None, 'page_size': None, 'paging_from': 'start', 'start_time': None, 'end_time': None, 'start_height': None, 'end_height': None, 'start_inclusive': None, 'end_inclusive': None, 'timezone': None, 'sort': None, 'limit_per_asset': None}
  [DEBUG] 2023-01-09 11:01:02,387 - Response status code: 200 for url: https://api.coinmetrics.io/v4/timeseries/asset-metrics?api_key=[REDACTED]&assets=btc%2Calgo%2Ceth&metrics=ReferenceRateUSD&paging_from=start took: 0:00:00.342874 response body size (bytes): 9832
  [DEBUG] 2023-01-09 11:01:02,388 - Attempting to call url: timeseries/asset-metrics with params: {'assets': ['btc', 'algo', 'eth'], 'metrics': ['ReferenceRateUSD'], 'frequency': None, 'page_size': None, 'paging_from': 'start', 'start_time': None, 'end_time': None, 'start_height': None, 'end_height': None, 'start_inclusive': None, 'end_inclusive': None, 'timezone': None, 'sort': None, 'limit_per_asset': None, 'next_page_token': '0.MjAxOS0wOS0zMFQwMDowMDowMFo'}
  [DEBUG] 2023-01-09 11:01:02,559 - Response status code: 200 for url: https://api.coinmetrics.io/v4/timeseries/asset-metrics?api_key=[REDACTED]&assets=btc%2Calgo%2Ceth&metrics=ReferenceRateUSD&paging_from=start&next_page_token=0.MjAxOS0wOS0zMFQwMDowMDowMFo took: 0:00:00.171487 response body size (bytes): 9857
  ```
  Then it can be easier to understand what network calls the API Client is making, and where any issues may exist. If you
  wish to dig even deeper, you may consider modifying the `_send_request()` method of the API Client to log additional
  data about the state of your environment, or anything else that would help diagnose issues. You will notice a log file
  generated in the format `cm_api_client_debug_2023_01_09_11_01_02.txt`. This log file might be helpful for your own use
  or to give more context if you are working with Coin Metrics customer success.

  Sometimes your organization network have special rules on SSL certs verification and in this case you might face the
  following error when running the script:
  ```text
  SSLError: HTTPSConnectionPool(host='api.coinmetrics.io', port=443): Max retries exceeded with url: <some_url_path> (Caused by SSLError(SSLCertVerificationError(1, '[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: self signed certificate in certificate chain (_ssl.c:1123)')))
  ```
  In this case, you can pass an option during client initialization to disable ssl verification for requests like this:
  ```python
  client = CoinMetricsClient(verify_ssl_certs=False)
  ```
  We don't recommend setting it to False by default and you should make sure you understand the security risks of disabling SSL certs verification.
  Additionally, you may choose to specify the path to the SSL certificates on your machine. This may cause errors where
  Python is unable to locate the certificates on your machine, particularly when using Python virtual environments.
  ```python
  from coinmetrics.api_client import CoinMetricsClient
  SSL_CERT_LOCATION = '/Users/<USER_NAME>/Library/Python/3.8/lib/python/site-packages/certifi/cacert.pem'
  client = CoinMetricsClient(verify_ssl_certs=SSL_CERT_LOCATION)
  ```
  A quick way to find the certs on your machine is:
  `python3 -c "import requests; print(requests.certs.where())"`
  And note that this will change based on whether or not you are using a [Python virtual environment or not](https://realpython.com/python-virtual-environments-a-primer/)

  Related to SSL Certs verification, you may have trouble installing and updating PyPi packages to your local environment.
  So you may need to choose the best solution for your company and environment - either using package managers or
  installing offline.

  Full instructions for setting up your environment to use conda, pip, yarn, npm, etc. can be [found here](https://medium.com/@iffi33/dealing-with-ssl-authentication-on-a-secure-corporate-network-pip-conda-git-npm-yarn-bower-73e5b93fd4b2).
  Additionally, a workaround to disable SSL verification when installing a trusted Python package is this:
  ```commandline
  pip install --trusted-host pypi.python.org <packagename>
  ```
  Although it is important to make sure you understand the risks associated with disabling SSL verification and ensure
  compliance with company policies.

  It may be easier to download and install the package locally. Steps:
  1. Download the files for the [Coin Metrics API Client from PyPi](https://pypi.org/project/coinmetrics-api-client/#files)
  2. [Install it locally](https://packaging.python.org/en/latest/tutorials/installing-packages/#installing-from-local-archives)

  Sometimes your organization has special rules on making requests to third parties and you have to use proxies in order to comply with the rules.
  For proxies that don't require auth you can specify them similar to this example:
  ```python
  client = CoinMetricsClient(proxy_url=f'http://<hostname>:<port>')
  ```
  For proxies that require auth, you should be able to specify username and password similar to this example:
  ```python
  client = CoinMetricsClient(proxy_url=f'http://<username>:<password>@<hostname>:<port>')
  ```

  For more information about the available methods in the client please reference [API Client Spec](https://coinmetrics.github.io/api-client-python/site/api_client.html)


pkgId: 89208892d440b902b366ff55401056186d7574472a89f954b30867db78f8b8ad
name: python-coinor.gimpy
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Graph Methods in Python
url: https://github.com/coin-or/GiMPy/
rpm_license: Eclipse Public License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinor.gimpy-2.1.1-1.src.rpm
checksum_type: sha256
description:
  GiMPy is yet another graph class in Python. It is part of the COIN-OR software repository (www.coin-or.org). The class includes implementations of a range of standard graph algorithms. The goal of the implementations is clarity and the package includes visualizations for most of the methods. It is intended for educational/research purposes. The implementations are as efficient as possible, but where tradeoffs have to be made, clarity and ability to visualize are emphasized above efficiency. For this reason, the package is pure Python (and thus will not be as fast as other graph classes with C extensions). Visualization is done using Graphviz, which should be installed in order to do any visualization. Graphs can be displayed using either pygame (live), PIL (static), xdot (live), gexf (static display in browser), or dot2tex (set in LaTex).

  Documentation for the API is here:

  https://coin-or.github.io/GiMPy


pkgId: add044011ffdf62d4706257d2e9c2da617434e99a3b24fb8f5fdfb926d35a118
name: python-coinor.grumpy
arch: src
version: 0.95.1
epoch: 0
release: 1
summary: Graphics for Understanding Mathematical Programming (GrUMPy)
url: https://github.com/tkralphs/GrUMPy/
rpm_license: Eclipse Public License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinor.grumpy-0.95.1-1.src.rpm
checksum_type: sha256
description:
  GrUMPy is a class for visualizing various algorithm used in solving discrete optimization problem. It has a class for dynamically generating and visualizing branch-and-bound trees that is derived from the GiMPy graph class. Using the branch-and-bound class, a user can visualize the branch-and-bound process in a number of different ways either by building the tree dynamically through direct calls to Python from the solver or by piping the output of an instrumented solver to GrUMPy for parsing. The branch-and-bound class also includes a pure Python implementation of branch and bound that is targeted at educational use.

  In addition, GrUMPy includes a class for visualizing 2-dimensional polyhedra that can be used in combination with a pure Python implementation of the Gomory cutting plane algorithm to geometrically visualize the process of solving an integer program by a cutting plane algorithm. In future releases, the cutting plane visualization will be joined together with the branch-and-bound implementation to yield a full-blown visualization of the branch-and-cut algorithm.

  A quick introduction with examples is available on Github:

  https://github.com/coin-or/GrUMPy

  Documentation for the API is here:

  https://tkralphs.github.io/GrUMPy


pkgId: e5838922cd4920af11a198465e1b12499262081b9a628bc54feb9e9571a41db7
name: python-coinoxr
arch: src
version: 0.0.1a0
epoch: 0
release: 1
summary: Python client for Open Exchange Rates
url: https://pypi.org/project/coinoxr/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinoxr-0.0.1a0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/luisfmcalado/coinoxr.svg?branch=master)](https://travis-ci.org/luisfmcalado/coinoxr)
  [![Coverage Status](https://coveralls.io/repos/github/luisfmcalado/coinoxr/badge.svg?branch=master)](https://coveralls.io/github/luisfmcalado/coinoxr?branch=master)

  Python library for Open Exchange Rates API.



  Install dependency
  ```bash
  $ pip install coinoxr
  ```

  Install dependency from source code
  ```bash
  $ python setup.py install
  ```


  - Python 3.7+




  ```python
  import coinoxr
  coinoxr.app_id = "c01ed21da6424fd3b0ac68f9e63a3d29"

  coinoxr.Latest().get(base="EUR")
  ```



  Run all the tests for every environment:

  ```bash
  $ make test
  ```

  The code can be formatted with black:

  ```bash
  $ make fmt
  ```


pkgId: 765f5f96413cb0bdf931a5b949829f44acb186d2a4ae133737cf5f0c1cedbb6e
name: python-coinprice
arch: src
version: 2024.11
epoch: 0
release: 1
summary: Coinprice is a command-line tool for tracking cryptocurrency prices across multiple exchanges.
url: https://github.com/bohd4nx/coinprice
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coinprice-2024.11-1.src.rpm
checksum_type: sha256
description:
  - Track the prices of various cryptocurrencies in real-time with updates.
  - Display price changes in color depending on rise or decline.
  - Flexible command-line interface for easy usage and control.
  - Set custom intervals for price updates according to your needs.
  - Prices are sorted from highest to lowest for clear comparison.
  - Fully customizable and adaptable to your preferences.
  - Open-source project for transparency and community input.


pkgId: 09743c3803c27bad632f07a4993560adb4b98196241023c206ede305a0520279
name: python-coki
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Coki: un paquete para revisar los precios de Cocos
url: https://pypi.org/project/coki/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coki-0.4.2-1.src.rpm
checksum_type: sha256
description:
  - Python >= 3.9
  - Cuenta en app.cocos.capital (la versión nueva, no la vieja)


  - Asegurarse que sea en una terminal con permisos de Administrador (así los scripts quedan en el PATH)

  ```
  $ pip install coki
  ```



  - Una vez instalado, hay que generar el archivo `coki_credentials.txt`, que contiene el usuario y la clave de tu cuenta encriptados
    - La encriptación es con una clave default estática (es decir, todos encriptan con la misma).
    - Esto evita tener archivos guardados con la clave escrita (y encontrarlos directamente por su contenido), pero se puede hacer el proceso inverso para obtenerla
    - Se puede generar una clave de encriptación particular para mayor seguridad (todavía no está implementado)

  ```
  $ coki-gen-credentials <user> <password> [--key <encryption_key>]
  ```
  - Con este script se genera `coki_credentials.txt`, para luego obtener la token de JWT que utiliza la api de cocos.



  ```
  $ coki --help















  $ coki GOGLD
           GOGLD - Cedear Google inc. - USD
           Last: 2.53 - High: 2.7 - Low: 2.5 - Volume: 5,203
  ╭────────────────┬─────────────────┬────┬────────────────┬───────────────╮
  │   Cant. compra │   Precio compra │    │   Precio venta │   Cant. venta │
  ├────────────────┼─────────────────┼────┼────────────────┼───────────────┤
  │            193 │            2.53 │    │           2.59 │           129 │
  │            776 │            2.52 │    │           2.61 │          1221 │
  │              8 │            2.48 │    │           2.63 │          1097 │
  │             60 │            2.47 │    │           2.66 │            27 │
  │              2 │            2.46 │    │           2.67 │           100 │
  ╰────────────────┴─────────────────┴────┴────────────────┴───────────────╯

  $ coki AMD -C ARS
           AMD - Cedear Advanced Micro Devices, Inc. - ARS
           Last: 9,960 - High: 10,180 - Low: 9,901 - Volume: 8,699
  ╭────────────────┬─────────────────┬────┬────────────────┬───────────────╮
  │   Cant. compra │   Precio compra │    │   Precio venta │   Cant. venta │
  ├────────────────┼─────────────────┼────┼────────────────┼───────────────┤
  │              5 │            9960 │    │       10004.50 │          4000 │
  │             29 │            9959 │    │       10005.00 │             4 │
  │              1 │            9958 │    │       10008.00 │           850 │
  │           2500 │            9957 │    │       10013.00 │          2500 │
  │             12 │            9935 │    │       10100.00 │           137 │
  ╰────────────────┴─────────────────┴────┴────────────────┴───────────────╯
  ```


pkgId: 956b745fa23facd9e22e738f0b36fea3e7797fedf2d07b24216b3f85cc0cf7d7
name: python-cola-ml
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/wilson-labs/cola
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cola-ml-0.0.6-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
   <img src="https://user-images.githubusercontent.com/6753639/251633368-1ec42732-1759-45d7-b949-51df6429a90a.svg"  width="300" height="150">
  </p>

  <!--
  <p align="center">
    <img src="https://github.com/wilson-labs/cola/assets/6753639/28630ef8-5dcb-41c2-9f36-3cbba52f3d88.svg" width="300" height="139.29">
  </p> -->
  <!--
  <p align = "center">
    <img src="https://github.com/wilson-labs/cola/assets/6753639/8b02c51e-0e1e-44f5-a52a-47ad428688e4.svg" width="300" height="139.29">
  </p>-->




  [![Documentation](https://readthedocs.org/projects/cola/badge/)](https://cola.readthedocs.io/en/stable/)
  [![tests](https://github.com/wilson-labs/cola/actions/workflows/python-package.yml/badge.svg)](https://github.com/wilson-labs/cola/actions/workflows/python-package.yml)
  [![codecov](https://codecov.io/gh/wilson-labs/cola/branch/main/graph/badge.svg?token=bBnkfHv30C)](https://codecov.io/gh/wilson-labs/cola)
  [![PyPI version](https://img.shields.io/pypi/v/cola-ml)](https://pypi.org/project/cola-ml/)
  [![Paper](https://img.shields.io/badge/arXiv-2309.03060-red)](https://arxiv.org/abs/2309.03060)
  [![Downloads](https://static.pepy.tech/badge/cola-ml)](https://pepy.tech/project/cola-ml)
  <!-- [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/wilson-labs/cola/blob/master/docs/notebooks/colabs/all.ipynb) -->

  CoLA is a framework for scalable linear algebra, automatically exploiting the structure often found in machine learning problems and beyond.
  CoLA natively supports PyTorch, JAX, as well as (limited) NumPy if JAX is not installed.


  ```shell
  pip install cola-ml
  ```


  * Large scale linear algebra routines for `solve(A,b)`, `eig(A)`, `logdet(A)`, `exp(A)`, `trace(A)`, `diag(A)`, `sqrt(A)`.
  * Provides (user extendible) compositional rules to exploit structure through multiple dispatch.
  * Has memory-efficient autodiff rules for iterative algorithms.
  * Works with PyTorch or JAX, supporting GPU hardware acceleration.
  * Supports operators with complex numbers and low precision.
  * Provides linear algebra operations for both symmetric and non-symmetric matrices.

  See https://cola.readthedocs.io/en/latest/ for our full documentation and many examples.



  1. **LinearOperators**. The core object in CoLA is the LinearOperator. You can add and subtract them `+, -`,
  multiply by constants `*, /`, matrix multiply them `@` and combine them in other ways:
  `kron, kronsum, block_diag` etc.
  ```python
  import jax.numpy as jnp
  import cola

  A = cola.ops.Diagonal(jnp.arange(5) + .1)
  B = cola.ops.Dense(jnp.array([[2., 1.], [-2., 1.1], [.01, .2]]))
  C = B.T @ B
  D = C + 0.01 * cola.ops.I_like(C)
  E = cola.ops.Kronecker(A, cola.ops.Dense(jnp.ones((2, 2))))
  F = cola.ops.BlockDiag(E, D)

  v = jnp.ones(F.shape[-1])
  print(F @ v)
  ```
  ```
  [0.2       0.2       2.2       2.2       4.2       4.2       6.2
   6.2       8.2       8.2       7.8       2.1    ]
  ```

  2. **Performing Linear Algebra**. With these objects we can perform linear algebra operations even when they are very big.
  ```python
  print(cola.linalg.trace(F))
  Q = F.T @ F + 1e-3 * cola.ops.I_like(F)
  b = cola.linalg.inv(Q) @ v
  print(jnp.linalg.norm(Q @ b - v))
  print(cola.linalg.eig(F, k=F.shape[0])[0][:5])
  print(cola.linalg.sqrt(A))
  ```

  ```
  31.2701
  0.0010193728
  [ 2.0000000e-01+0.j  0.0000000e+00+0.j  2.1999998e+00+0.j
   -1.1920929e-07+0.j  4.1999998e+00+0.j]
  diag([0.31622776 1.0488088  1.4491377  1.7606816  2.0248456 ])
  ```

  For many of these functions, if we know additional information about the matrices we can annotate them
  to enable the algorithms to run faster.

  ```python
  Qs = cola.SelfAdjoint(Q)
  %timeit cola.linalg.inv(Q) @ v
  %timeit cola.linalg.inv(Qs) @ v
  ```

  3. **JAX and PyTorch**. We support both ML frameworks.
  ```python
  import torch
  A = cola.ops.Dense(torch.Tensor([[1., 2.], [3., 4.]]))
  print(cola.linalg.trace(cola.kron(A, A)))

  import jax.numpy as jnp
  A = cola.ops.Dense(jnp.array([[1., 2.], [3., 4.]]))
  print(cola.linalg.trace(cola.kron(A, A)))
  ```

  ```
  tensor(25.)
  25.0
  ```

  CoLA also supports autograd (and jit):
  ```python
  from jax import grad, jit, vmap


  def myloss(x):
      A = cola.ops.Dense(jnp.array([[1., 2.], [3., x]]))
      return jnp.ones(2) @ cola.linalg.inv(A) @ jnp.ones(2)


  g = jit(vmap(grad(myloss)))(jnp.array([.5, 10.]))
  print(g)
  ```

  ```
  [-0.06611571 -0.12499995]
  ```


  If you use CoLA, please cite the following paper:

  [Andres Potapczynski, Marc Finzi, Geoff Pleiss, and Andrew Gordon Wilson. "CoLA: Exploiting Compositional Structure for Automatic and Efficient Numerical Linear Algebra." 2023.](https://arxiv.org/abs/2309.03060)
  ```
  @article{potapczynski2023cola,
    title={{CoLA: Exploiting Compositional Structure for Automatic and Efficient Numerical Linear Algebra}},
    author={Andres Potapczynski and Marc Finzi and Geoff Pleiss and Andrew Gordon Wilson},
    journal={arXiv preprint arXiv:2309.03060},
    year={2023}
  }
  ```



  | Linear Algebra    | inverse | eig | diag | trace | logdet | exp | sqrt | f(A) | SVD | pseudoinverse |
  |:-----------------:|:-------:|:---:|:----:|:-----:|:------:|:---:|:----:|:--------:|:---:|:-------------:|
  | **Implementation**|    ✓    |  ✓  |   ✓  |   ✓  |    ✓   |  ✓  |   ✓  |    ✓     |     |               |

  | LinearOperators   | Diag | BlockDiag | Kronecker | KronSum | Sparse | Jacobian | Hessian | Fisher | Concatenated | Triangular | FFT | Tridiagonal |
  |:-----------------:|:----:|:---------:|:---------:|:-------:|:------:|:--------:|:-------:|:------:|:------------:|:----------:|:---:|:-----------:|
  | **Implementation**|   ✓  |     ✓     |     ✓     |    ✓    |      |    ✓     |    ✓    |   ✓    |      ✓       |     ✓      |   ✓  |      ✓      |

  | Annotations      | SelfAdjoint | PSD | Unitary |
  |:----------------:|:-----------:|:---:|:-------:|
  | **Implementation**|      ✓      |  ✓  |    ✓   |


  | Backends      | PyTorch | JAX | NumPy |
  |:----------------:|:-----------:|:---:|:-------:|
  | **Implementation**|      ✓      |  ✓  |Most operations|


  See the contributing guidelines [docs/CONTRIBUTING.md](https://cola.readthedocs.io/en/latest/contributing.html) for information on submitting issues
  and pull requests.

  CoLA is Apache 2.0 licensed.


  Please raise an issue if you find a bug or slow performance when using CoLA.


pkgId: f94cd15093177119060f3090621b45bdd7363b3fdf14ef3b169de44ee6f8e184
name: python-colab-env
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Handles environment variables in Google Colab notebooks
url: https://pypi.org/project/colab-env/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colab-env-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)


pkgId: 220354ef366b23faca5c6d4f6853fc459bcf66264697e2d55ca24f4e018ab351
name: python-colab-load
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Library to download .ipynb from google colab.
url: https://github.com/Filin153/colab_load.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colab-load-0.0.4-1.src.rpm
checksum_type: sha256
description:
  Library to download .ipynb from google colab


  	pip install colab-load
  One url:

      from colab_load.load import StartLoad

      s = StartLoad(logs=True)
      s.load_file_single("https://colab.research.google.com/drive/1QD1TM2TroOEqqtTURpk5sVOmGLQeREv_?usp=sharing", save_dir="file")

  Lots of url:

  	from colab_load.load import StartLoad

  	urls=["https://colab.research.google.com/drive/1QD1TM2TroOEqqtTURpk5sVOmGLQeREv_?usp=sharing", "https://colab.research.google.com/drive/1QD1TM2TroOEqqtTURpk5sVOmGLQeREv_?usp=sharing"]
  	s = StartLoad(logs=True)
  	s.load_file_all(urls, save_dir="file", count=2)


pkgId: ab9e150f0eaff59871c498e2cb5ee64abf283d2909a221d82767322a55f5347f
name: python-colab-ssh
arch: src
version: 0.3.27
epoch: 0
release: 1
summary: Google colab SSH connector
url: https://github.com/WassimBenzarti/colab-ssh-connector.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colab-ssh-0.3.27-1.src.rpm
checksum_type: sha256
description:
  ![Cover photo of Colab-ssh](docs/assets/cover.png)

  > A new version of colab-ssh is coming soon, stay tuned.

  > 🎉 Happy to announce that we now have:
  >  - Youtube demo video
  >  - Support for Gitlab repositories
  >  - VSCode integration with which you can open your VSCode right from the notebook.


  Connect to Google colab via ssh easily

  [![Downloads](https://pepy.tech/badge/colab-ssh/week)](https://pepy.tech/project/colab-ssh)
  [![Downloads](https://pepy.tech/badge/colab-ssh/month)](https://pepy.tech/project/colab-ssh)
  [![Downloads](https://pepy.tech/badge/colab-ssh)](https://pepy.tech/project/colab-ssh)


  Colab-ssh is a light-weight library that allows you to connect to Google Colab Notebook using an SSH Tunnel and optionally via VSCode.


  You can click on the Google Colab button to clone an already setup notebook:

  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/WassimBenzarti/colab-ssh/blob/master/docs/Colab_ssh_Initial_project.ipynb)

  > :warning: Colab-ssh supports Google colaboratory notebooks only, using it on other notebooks may lead to unexpected behavior.



  Now you can watch a demo video on how to setup Colab-ssh with cloudflared on Youtube. Click the video below to open it.

  [![Youtube demo of Colab-ssh](http://img.youtube.com/vi/Q78_MMaNe_U/0.jpg)](http://www.youtube.com/watch?v=Q78_MMaNe_U "Colab-ssh: open Google Colab with VSCode and SSH")

  1. Open Google Colab and run this code in one of the code cells
  ```jupyter

  !pip install colab_ssh --upgrade

  from colab_ssh import launch_ssh_cloudflared, init_git_cloudflared
  launch_ssh_cloudflared(password="<PUT_YOUR_PASSWORD_HERE>")


  repository_url="<PUT_YOUR_REPOSITORY_URL_HERE>"
  init_git_cloudflared(repository_url)
  ```
  > Make sure you replace `<PUT_YOUR_PASSWORD_HERE>` with a password of your choice and `<PUT_YOUR_REPOSITORY_URL_HERE>` with the link to your Github/Gitlab repository (if you use the git integration).

  The output of this snippet will look similar to the following screenshot:
  ![launch_ssh_cloudflared output](docs/assets/launch_ssh_cloudflared.jpg)

  > :warning: If it's the first time you launch colab-ssh on your machine, it's important to follow the instructions in the **"Client machine configuration" section**. To show the steps that you need to do, **just click "Client machine configuration"**. Don't worry, you don't have to repeat these steps again for each notebook.

  > :grey_question: Things doesn't work ? or looking for a way to connect using Ngrok ? Check the [colab-ssh ngrok documentation](docs/ngrok/ngrok.md)



  If you are a Github/Gitlab fan, you probably want to clone a repository (private or public) repeatedly to the Google Colab Notebook.
  This is why `init_git` is created.

  <details><summary> <b> What `init_git` does</b></summary>

  - Clones the repository
  - Uses your personal token (if you provided it) to setup the repository remote URL (this is useful so you don't have to worry about authentication during `git clone` or `git push`). If you clone a private repository without a personal token, you will be asked to put your password (This is only valid for Gitlab, as opposed to Github that recently disabled password authentication).
  - Checkout the branch of your preference
  - Sets up the `user.email` and `user.name` for you, in case you need to commit.
  - Also, it inserts the cloned folder to the `sys.path`. This is helpful when your cloned repository is a python project and you want to import some python modules directly (without specifying the name of the root folder) to your Google Colab Notebook. Example: If you cloned a repository called `example-repo`. A folder should be created containing your cloned repository. If `example-repo` has a python module called `my_module`, instead of writing in your notebook `import example-repo.my_module`, you can simply do `import my_module`.
  </details>



  ```python
  init_git_cloudflared("https://github.com/<OWNER>/<REPO_NAME>.git",
           personal_token="<YOUR_GITHUB_PERSONAL_TOKEN>",
           branch="<YOUR_BRANCH>",
           email="<YOUR_EMAIL>",
           username="<YOUR_USERNAME>")
  ```
  The output of this command will look like this:
  ![init_git_cloudflared output](docs/assets/init_git_cloudflared.jpg)


  This will display a button inside the cell output (or a url in case of a terminal). This is a direct link to open VSCode installed on your machine.
  > Link doesn't appear or doesn't work?
  > - Make sure you have VSCode installed locally for the link to work
  > - Make sure that you run `launch_ssh_cloudflared` before `init_git_cloudflared`. The reason for that is because `init_git_cloudflared` shows the link based on the tunnel information provided by the function `launch_ssh_cloudflared`.

  > :warning: Please note that your Gitlab personal access token requires the following scopes: `read_api, read_repository, write_repository`.


  Instead of setting a password, you can access the SSH tunnel using your own pair of keys.

  > **IMPORTANT**: This feature is only available when you clone your git repository by using the function `init_git_cloudflared()`

  You need to follow these steps:
  1. Create a pair of SSH key
  2. Copy your **public key** (usually it's in the file `~/.ssh/id_rsa.pub`) and make sure you keep your **private key** in a safe place
  3. In the root of your github repository, create a folder called `.colab_ssh` and a file within it called `authorized_keys`
  4. Paste your **public key** inside the file `.collab_ssh/authorized_keys`
  5. Push your changes to the repository and launch the clone again from your Google Colab Notebook

  <details><summary><b>How it works behind the scenes ?</b></summary>

  We get your **public key** from the repository passed into the `init_git()` function and then we add it to the  `authorized_keys` file (found in `~/.ssh` folder).
  </details>


  - [Exposing a Google Colab environment variable](docs/expose-env-variable.md)


  Check the API reference on this [page](docs/api-reference.md).



  <details><summary> <b> Can I open the Colab notebook automatically without user interaction ?</b> </summary>

  No, you still need to open the Google Colab Notebook interface manually in order to setup this tool. Google Colab doesn't have an API yet to automatically run a notebook for you.</details>

  <details><summary> <b> Some environment variables are available on Google Colab but not available when executing from the terminal ?</b> </summary>

  Check out the documentation for how you can [Expose a Google Colab environment variable](docs/expose-env-variable.md).
  </details>


  If you want to buy me a cup of coffee, feel free to reach me or use the following IBAN (International Bank Account Number):
  ```
  TN5904018104003696876646
  ```


  Start by [opening an issue](https://github.com/WassimBenzarti/colab-ssh) so can start working together to enhance the experience of Google Colab users. We would love to hear your ideas!


pkgId: f4dbedd5e20803d7e63f732e41e73564908cf93302e5ab9d23b5460658dedba3
name: python-colab-toolbox
arch: src
version: 0.1.4
epoch: 0
release: 1
url: https://github.com/thinh-vu/colab_toolbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colab-toolbox-0.1.4-1.src.rpm
checksum_type: sha256
summary:
  Effortlessly set up and configure multiple tools for Google Colab without the need for shell commands or extensive coding.

description:
  Simplify the setup and configuration of multiple tools in Google Colab without needing shell commands or extensive coding.




  - **Selenium and ChromeDriver Setup**: Seamlessly install and configure Selenium and ChromeDriver for web scraping and automation.
  - **Quarto Setup for Documentation**: Quickly configure Quarto for exporting documentation in various formats.
  - **Python Environment Setup**: Install and configure Python environments for tasks such as data ingestion, backtesting, modeling, and more.
  - **xterm Setup**: Enable a full terminal experience in Google Colab by setting up xterm.
  - **OCRmyPDF Setup**: Easily configure OCRmyPDF for OCR processing and PDF conversion.



  - **Git Commands for Colab**: Streamline Git operations within Google Colab.
  - **Google Sheets Integration**: Read and write data in Google Sheets using a simplified authentication flow, avoiding the complexities of configuring confidential or service account credentials.


  - **Google Services Authentication Using Service Account Credentials**: Securely authenticate and access Google services.



  To install the `colab_toolbox` package, run:

  ```bash
  pip install colab_toolbox
  ```



  ```python
  from colab_toolbox import ColabInstall


  ColabInstall('selenium')
  ```

  **Available Tools**

  - `selenium`: WebDriver for automated testing of web applications
  - `quarto`: open-source scientific and technical publishing system
  - `talib`: Technical Analysis Library for Stock Trading in Python
  - `pytesseract`: OCR tool for extracting text from images
  - `ocrmypdf`: OCR tool for extracting text from PDF files
  - `xterm`: Terminal emulator for Google Colab environment


pkgId: 50c02c6d036a958b597e0656823c4b5b150d7ae7d190a0931f2fbdd7cfab35d4
name: python-colabcode
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: ColabCode - Run codeserver on Colab!
url: https://github.com/abhishekkrthakur/colabcode
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colabcode-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)
  [![PyPI version](https://badge.fury.io/py/colabcode.svg)](https://badge.fury.io/py/colabcode)
  ![python version](https://img.shields.io/badge/python-3.6%2C3.7%2C3.8-blue?logo=python)



  ```python
  $ pip install colabcode
  ```

  Run code server on [Google Colab](https://colab.research.google.com/) or [Kaggle](https://www.kaggle.com/) Notebooks.



  ColabCode also has a command-line script. So you can just run `colabcode` from command line.

  **`colabcode -h`** will give the following:

  ```console
  usage: colabcode [-h] --port PORT [--password PASSWORD] [--mount_drive]

  ColabCode: Run VS Code On Colab / Kaggle Notebooks

  required arguments:
    --port PORT          the port you want to run code-server on

  optional arguments:
    --password PASSWORD  password to protect your code-server from unauthorized access
    --mount_drive        if you use --mount_drive, your google drive will be mounted
  ```

  **Else**, you can do the following:

  ```python

  $ from colabcode import ColabCode
  ```

  ```python

  $ ColabCode()
  ```

  ```python





  $ ColabCode(port=10000, password="abhishek", mount_drive=True)
  ```



  **Colab** starter notebook: &nbsp;&nbsp; [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/abhishekkrthakur/colabcode/blob/master/colab_starter.ipynb)

  **`ColabCode`**  comes pre-installed with some VS Code extensions.



  [![YouTube Video](https://img.shields.io/youtube/views/7kTbM3D02jU?style=social)](https://youtu.be/7kTbM3D02jU)



  [MIT](LICENSE)


pkgId: c5fb555fb8ba4711d971ab66f3095e1a1808ab66642dcf988b9c68192d909214
name: python-colabfold
arch: src
version: 1.5.5
epoch: 0
release: 1
url: https://github.com/sokrypton/ColabFold
rpm_license: MIT, but separate licenses for the trained weights
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colabfold-1.5.5-1.src.rpm
checksum_type: sha256
summary:
  Making protein folding accessible to all. Predict proteins structures both in google colab and on your machine

description:
  **OLD Updates**
  ```diff
    31Jul2023: 2023/07/31: The ColabFold MSA server is back to normal
               It was using older DB (UniRef30 2202/PDB70 220313) from 27th ~8:30 AM CEST to 31st ~11:10 AM CEST.
    27Jul2023: ColabFold MSA server issue:
               We are using the backup server with old databases
               (UniRef30 2202/PDB70 220313) starting from ~8:30 AM CEST until we resolve the issue.
               Resolved on 31Jul2023 ~11:10 CEST.
    12Jun2023: New databases! UniRef30 updated to 2302 and PDB to 230517.
               We now use PDB100 instead of PDB70 (see notes in the [main](https://colabfold.com) notebook).
    12Jun2023: We introduced a new default pairing strategy:
               Previously, for multimer predictions with more than 2 chains,
               we only pair if all sequences taxonomically match ("complete" pairing).
               The new default "greedy" strategy pairs any taxonomically matching subsets.
    30Apr2023: Amber is working again in our ColabFold Notebook
    29Apr2023: Amber is not working in our Notebook due to Colab update
    18Feb2023: v1.5.2 - fixing: fixing memory leak for large proteins
                      - fixing: --use_dropout (random seed was not changing between recycles)
    06Feb2023: v1.5.1 - fixing: --save-all/--save-recycles
    04Feb2023: v1.5.0 - ColabFold updated to use AlphaFold v2.3.1!
    03Jan2023: The MSA server's faulty hardware from 12/26 was replaced.
               There were intermittent failures on 12/26 and 1/3. Currently,
               there are no known issues. Let us know if you experience any.
    10Oct2022: Bugfix: random_seed was not being used for alphafold-multimer.
               Same structure was returned regardless of defined seed. This
               has been fixed!
    13Jul2022: We have set up a new ColabFold MSA server provided by Korean
               Bioinformation Center. It provides accelerated MSA generation,
               we updated the UniRef30 to 2022_02 and PDB/PDB70 to 220313.
    11Mar2022: We use in default AlphaFold-multimer-v2 weights for complex modeling.
               We also offer the old complex modes "AlphaFold-ptm" or "AlphaFold-multimer-v1"
    04Mar2022: ColabFold now uses a much more powerful server for MSAs and searches through the ColabFoldDB instead of BFD/MGnify.
               Please let us know if you observe any issues.
    26Jan2022: AlphaFold2_mmseqs2, AlphaFold2_batch and colabfold_batch's multimer complexes predictions are
               now in default reranked by iptmscore*0.8+ptmscore*0.2 instead of ptmscore
    16Aug2021: WARNING - MMseqs2 API is undergoing upgrade, you may see error messages.
    17Aug2021: If you see any errors, please report them.
    17Aug2021: We are still debugging the MSA generation procedure...
    20Aug2021: WARNING - MMseqs2 API is undergoing upgrade, you may see error messages.
               To avoid Google Colab from crashing, for large MSA we did -diff 1000 to get
               1K most diverse sequences. This caused some large MSA to degrade in quality,
               as sequences close to query were being merged to single representive.
               We are working on updating the server (today) to fix this, by making sure
               that both diverse and sequences close to query are included in the final MSA.
               We'll post update here when update is complete.
    21Aug2021  The MSA issues should now be resolved! Please report any errors you see.
               In short, to reduce MSA size we filter (qsc > 0.8, id > 0.95) and take 3K
               most diverse sequences at different qid (sequence identity to query) intervals
               and merge them. More specifically 3K sequences at qid at (0→0.2),(0.2→0.4),
               (0.4→0.6),(0.6→0.8) and (0.8→1). If you submitted your sequence between
               16Aug2021 and 20Aug2021, we recommend submitting again for best results!
    21Aug2021  The use_templates option in AlphaFold2_mmseqs2 is not properly working. We are
               working on fixing this. If you are not using templates, this does not affect the
               the results. Other notebooks that do not use_templates are unaffected.
    21Aug2021  The templates issue is resolved!
    11Nov2021  [AlphaFold2_mmseqs2] now uses Alphafold-multimer for complex (homo/hetero-oligomer) modeling.
               Use [AlphaFold2_advanced] notebook for the old complex prediction logic.
    11Nov2021  ColabFold can be installed locally using pip!
    14Nov2021  Template based predictions works again in the Alphafold2_mmseqs2 notebook.
    14Nov2021  WARNING "Single-sequence" mode in AlphaFold2_mmseqs2 and AlphaFold2_batch was broken
               starting 11Nov2021. The MMseqs2 MSA was being used regardless of selection.
    14Nov2021  "Single-sequence" mode is now fixed.
    20Nov2021  WARNING "AMBER" mode in AlphaFold2_mmseqs2 and AlphaFold2_batch was broken
               starting 11Nov2021. Unrelaxed proteins were returned instead.
    20Nov2021  "AMBER" is fixed thanks to Kevin Pan


pkgId: f61c62d5e5564d8227de9943ece72e551c2d152724f80374d2f1aded8bd4e918
name: python-colbert-ai
arch: src
version: 0.2.21
epoch: 0
release: 1
summary: Efficient and Effective Passage Search via Contextualized Late Interaction over BERT
url: https://github.com/stanford-futuredata/ColBERT
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colbert-ai-0.2.21-1.src.rpm
checksum_type: sha256
description:
  * (1/28/24) One of the easiest ways to use ColBERT in applications nowadays is the semi-official, fast-growing [RAGatouille](https://github.com/bclavie/ragatouille) library.
  * (1/29/23) We have merged a new index updater feature and support for additional Hugging Face models! These are in beta so please give us feedback as you try them out.


pkgId: 573592fefa290566bd028facd97df947a7207bd4fb5b6c7344ffe3997100ef62
name: python-colcon-bash
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Extension for colcon to provide Bash scripts.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-bash-0.5.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide `Bash <https://www.gnu.org/software/bash/>`_ scripts.


pkgId: 421354f42ccba4551d647ec6a16d7c44f92f0e96e441136d5e4d89244af4228a
name: python-colcon-cmake
arch: src
version: 0.2.28
epoch: 0
release: 1
summary: Extension for colcon to support CMake packages.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-cmake-0.2.28-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to support `CMake <https://cmake.org>`_ projects.


pkgId: 104452050107588e020ecde6e6f828fd38ba4ffab95cfc0d79655b542cb74974
name: python-colcon-common-extensions
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Meta package aggregating colcon-core and common extensions.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-common-extensions-0.3.0-1.src.rpm
checksum_type: sha256
description:
  A meta package aggregating `colcon-core <https://github.com/colcon/colcon-core>`_ as well as a set of common extensions.


pkgId: fad7853900a304f2da6923e2e7157f7d5ab815cc50e613f1b0b3cd7d9e66a19a
name: python-colcon-core
arch: src
version: 0.17.1
epoch: 0
release: 1
summary: Command line tool to build sets of software packages.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-core-0.17.1-1.src.rpm
checksum_type: sha256
description:
  ``colcon`` is a command line tool to improve the workflow of building, testing and using multiple software packages.
  It automates the process, handles the ordering and sets up the environment to use the packages.
  For more information see `colcon.readthedocs.io <https://colcon.readthedocs.io>`_.


pkgId: 7e8bf3f53d9aaf25729d123aeb800b5b81cba812008f796db7ab33870bc06224
name: python-colcon-coveragepy-result
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: colcon extension for collecting coverage.py results
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-coveragepy-result-0.0.8-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/colcon-coveragepy-result)](https://pypi.org/project/colcon-coveragepy-result/)
  [![GitHub Action Status](https://github.com/colcon/colcon-coveragepy-result/workflows/Test/badge.svg)](https://github.com/colcon/colcon-coveragepy-result/actions)

  A [colcon](https://colcon.readthedocs.io/) extension for collecting [coverage.py](https://coverage.readthedocs.io/en/stable/) results.



  1. Build packages with coverage, e.g. using a [colcon mixin](https://colcon.readthedocs.io/en/released/reference/verb/mixin.html) for [coverage](https://github.com/colcon/colcon-mixin-repository/blob/master/coverage.mixin)
     ```shell
     $ colcon build --mixin coverage-pytest
     ```
  1. Test packages with coverage, again using a mixin
     ```shell
     $ colcon test --mixin coverage-pytest
     ```
  1. Collect coverage results
     ```shell
     $ colcon coveragepy-result
     ```
  1. Open HTML report, which by default is under `coveragepy/htmlcov/`




  * Print coverage reports for each package and a combined coverage report of all packages
     ```shell
     $ colcon coveragepy-result --verbose
     ```
  * Provide additional arguments for reports generation, e.g. to show lines without coverage
     ```shell
     $ colcon coveragepy-result --coverage-report-args -m
     ```
  * Provide additional arguments for HTML report generation, e.g. to skip files with no code
     ```shell
     $ colcon coveragepy-result --coverage-html-args --skip-empty
     ```
  * For more options
     ```shell
     $ colcon coveragepy-result --help
     ```



  See:

  * [*Contributions*](https://colcon.readthedocs.io/en/released/developer/contribution.html) for guidelines
  * [*Bootstrap from source*](https://colcon.readthedocs.io/en/released/developer/bootstrap.html) to test the package from source


pkgId: 697893968142de72e6abfaf72aedeb08aa2c7562b69c3d356201d55628506254
name: python-colcon-defaults
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: Extension for colcon to read defaults from a config file.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-defaults-0.2.8-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide custom default values for the command line arguments from a configuration file.
  For more information about the format of the configuration file see `colcon.readthedocs.io <http://colcon.readthedocs.io/en/released/user/configuration.html#defaults-yaml>`_.


pkgId: 7ab7662c5b3b18d808abe6c0996cf50d52edaddde7089e6d9334dd2cadb0060d
name: python-colcon-devtools
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Extension for colcon to provide information about all extension points and extensions
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-devtools-0.3.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide information about the plugin system.


pkgId: 83d26cfd2f84ae0e87941206b097eba65f068011d111edb86631898ac085116f
name: python-colcon-lcov-result
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Extension for colcon to gather test results.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-lcov-result-0.5.2-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide aggregate
  coverage results using `LCOV <http://ltp.sourceforge.net/coverage/lcov.php>`_.
  LCOV is a graphical front-end for GCC's coverage testing tool
  `gcov <https://gcc.gnu.org/onlinedocs/gcc/Gcov.html>`_, producing the following
  coverage metrics:
  - Statement coverage
  - Function coverage
  - Branch coverage
  For more information, see `this paper
  <http://ltp.sourceforge.net/documentation/technical_papers/gcov-ols2003.pdf>`_
  and `this Wikipedia page <https://en.wikipedia.org/wiki/Code_coverage>`_.


pkgId: 67ef451e82d7dea51902482f20a17e68923eb0acdf2990082d3000a73e19fc5c
name: python-colcon-library-path
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Extension for colcon adding an environment variable to find libraries.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-library-path-0.2.1-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to set an environment variable to find shared libraries at runtime.


pkgId: 83d77f5c0423a1e01b22af310b0aa6a27e72b295dbda37aa30c7db2aa42e9cbf
name: python-colcon-metadata
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Extension for colcon to read package metadata from files.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-metadata-0.2.5-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to fetch and manage package metadata from repositories.
  For an example repository containing metadata see `colcon-metadata-repository <https://github.com/colcon/colcon-metadata-repository>`_.


pkgId: 9c61e77f28bf67da06918738ae62327aba1dd3da319a572027d406d26dae2f2c
name: python-colcon-mixin
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Extension for colcon to read CLI mixins from files.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-mixin-0.2.3-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to fetch and manage CLI mixins from repositories.
  For an example repository containing mixins see `colcon-mixin-repository <https://github.com/colcon/colcon-mixin-repository>`_.


pkgId: ddd8c35e98cf20a391aeb6dc78a47c007241820ec73996a2ca8e4904a6a391b3
name: python-colcon-output
arch: src
version: 0.2.13
epoch: 0
release: 1
summary: Extension for colcon to customize the output in various ways.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-output-0.2.13-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to customize the output in various ways.


pkgId: f566376dc655b7426a466ff1060110bef8d03e960ebe0eb9e4f355c7de49bce3
name: python-colcon-package-information
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Extension for colcon to output package information.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-package-information-0.4.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide information about the packages.


pkgId: f4bb7b8629990981851a50a453d5105dc439d941bea91d931fc57f3620523918
name: python-colcon-package-selection
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: Extension for colcon to select the packages to process.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-package-selection-0.2.10-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to select a subset of packages for processing.


pkgId: 4e1cba8ea52bb5fd29de1f084b8a2819caa8c39223767f9c9f05337bdcd080f7
name: python-colcon-parallel-executor
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Extension for colcon to process packages in parallel.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-parallel-executor-0.3.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to process packages in parallel.


pkgId: 398952c3fd1f47a1f92aba834b5f02b3f19752bec91865439aab85c7c856596b
name: python-colcon-pkg-config
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Extension for colcon adding an environment variable to find pkg-config files.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-pkg-config-0.1.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to set an environment variable to find pkg-config files.


pkgId: f2604b14bafab8050583a308d4a86cc39d4e9c989a9520a556011aa143d553ee
name: python-colcon-powershell
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Extension for colcon to provide PowerShell scripts.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-powershell-0.4.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide `PowerShell <https://github.com/PowerShell/PowerShell>`_ scripts.


pkgId: 3986df5d9a3aa2db8729b4224f3a6873460fbc5f68f74bccd1bbb3bb91150398
name: python-colcon-python-setup-py
arch: src
version: 0.2.8
epoch: 0
release: 1
summary: Extension for colcon to support Python packages with the metadata in the setup.py file.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-python-setup-py-0.2.8-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to identify packages with a ``setup.py`` file by introspecting the arguments to the ``setup()`` function call of  `setuptools <https://setuptools.readthedocs.io/en/latest/>`_.


pkgId: b38e2d54fd498435f6f3e4cc99b1117b23ce06bdda937b70ca7b6b595f34f17c
name: python-colcon-recursive-crawl
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Extension for colcon to recursively crawl for packages.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-recursive-crawl-0.2.3-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to recursively crawl for packages.


pkgId: 49d8796401519e534ec182eb56fd2be7b7a9652eb582e931620ddc7c52489f0e
name: python-colcon-ros
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Extension for colcon to support ROS packages.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-ros-0.5.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to support `ROS packages <http://www.ros.org>`_.


pkgId: c5a631f9523e533b7129a6aa845ea3edeaa12ce3ed4e7ec4d710ac09575bb3a5
name: python-colcon-ros-cargo
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Extension for colcon to support Ament Cargo packages.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-ros-cargo-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Build cargo projects with colcon.



  Packages need to have a `package.xml` in addition to `Cargo.toml`. You should see such packages classified as `ament_cargo` in the output of `colcon list`. If they are classified as `ros.ament_cargo` instead, the `colcon-ros-cargo` extension has not been found by `colcon`. Make sure that you have built and loaded (`source install/setup.bash`) the extension.

  Simply list dependencies (other `ament_cargo` packages or message packages) in `Cargo.toml` and `package.xml` as if they were hosted on crates.io. `colcon-ros-cargo` will find the dependencies and create a `.cargo/config.toml` file that helps cargo find these packages.

  Extra arguments to `cargo` can be passed via the `--cargo-args` option, e.g. `colcon build --cargo-args --release`.

  After building, run binaries with `ros2 run`.

  `colcon-ros-cargo` also aims to support using `cargo` directly as the primary build tool. Just build with `colcon` once, to make sure all non-Cargo dependencies are built and the `.cargo/config.toml` file exists, and then using `cargo` will just work – `cargo build`, `cargo clippy`, `cargo doc`, etc. When the dependency graph changes, rebuild with `colcon`.



  This is by far not a perfect build system.

  Notably, there is _quadratic_ build cost as a function of the dependency chain length. To illustrate this, assume there are packages A, B and C, where C depends on B and B depends on A. If colcon builds this workspace, it builds A first, then B, then C. However, Cargo will _also_ build all the dependencies, i.e., to build B, Cargo will build A again, and to build C, it will build A and B again.

  `colcon test` is not yet supported.


pkgId: e32a09cc91507d8cb4027d754e488861eca1ed628f683a5c752e62627c36884f
name: python-colcon-test-result
arch: src
version: 0.3.8
epoch: 0
release: 1
summary: Extension for colcon to provide information about the test results.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-test-result-0.3.8-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide information about the test results.


pkgId: fe8f7b72d27063f8aafd32d5d8b53bff0729af6770bb084f350938d008dc5081
name: python-colcon-zsh
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Extension for colcon to provide Z shell scripts.
url: https://colcon.readthedocs.io
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colcon-zsh-0.5.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `colcon-core <https://github.com/colcon/colcon-core>`_ to provide `Z shell <http://www.zsh.org>`_ scripts.


pkgId: 364ed24c13f3fac4937e5523f251d2d64d368ea8a8889df3eecbb5bf2e89cd16
name: python-coldfront
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: HPC Resource Allocation System
url: https://coldfront.readthedocs.io
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coldfront-1.1.6-1.src.rpm
checksum_type: sha256
description:
  ![ColdFront](docs/pages/images/logo-lg.png)



  [![Documentation Status](https://readthedocs.org/projects/coldfront/badge/?version=latest)](https://coldfront.readthedocs.io/en/latest/?badge=latest)

  ColdFront is an open source resource and allocation management system designed to provide a
  central portal for administration, reporting, and measuring scientific impact
  of cyberinfrastructure resources. ColdFront was created to help high performance computing (HPC) centers manage access to a diverse set of resources across large groups of users and provide a rich set of
  extensible meta data for comprehensive reporting. The flexiblity of ColdFront allows centers to manage and automate their policies and procedures within the framework provided or extend the functionality with [plugins](docs/pages/index.md#extensibility).  ColdFront is written in Python and released under the GPLv3 license.



  - Allocation based system for managing access to resources
  - Self-service portal for users to request access to resources for their research group
  - Collection of Project, Grant, and Publication data from users
  - Center director approval system and annual project review process
  - Email notifications for expiring/renewing access to resources
  - Ability to define custom attributes on resources and allocations
  - Integration with 3rd party systems for automation, access control, and other system provisioning tasks

  [Read more](docs/pages/index.md)



  - [OpenStack Plugin](https://github.com/nerc-project/coldfront-plugin-openstack)
  - [Keycloak User Search](https://github.com/nerc-project/coldfront-plugin-keycloak)
  - [Starfish Plugin](https://github.com/fasrc/sftocf)

  _Submit a PR to add your plugin to the list above._



  For more information on installing and using ColdFront see our [documentation here](https://coldfront.readthedocs.io)


  If you would like a live demo followed by QA, please contact us at
  ccr-coldfront-admin-list@listserv.buffalo.edu. You can also contact us for
  general inquiries and installation troubleshooting.

  If you would like to join our mailing list to receive news and updates, please
  send an email to listserv@listserv.buffalo.edu with no subject, and the
  following command in the body of the message:

  subscribe ccr-open-coldfront-list@listserv.buffalo.edu first_name last_name




  ColdFront is released under the GPLv3 license. See the LICENSE file.


pkgId: f855eec79e948d26cb0aeee57d949c185377b172042e768cee202959b38ed177
name: python-colivara-py
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: The official Python SDK for the ColiVara API
url: https://github.com/tjmlabs/colivara-py
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colivara-py-1.2.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/colivara-py.svg)](https://pypi.org/project/colivara-py/)
  [![Changelog](https://img.shields.io/github/v/release/tjmlabs/colivara-py?include_prereleases&label=changelog)](https://github.com/tjmlabs/colivara-py/releases)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/tjmlabs/colivara-py/blob/main/LICENSE)
  [![Tests](https://github.com/tjmlabs/colivara-py/actions/workflows/test.yml/badge.svg)](https://github.com/tjmlabs/colivara-py/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/tjmlabs/ColiVara/branch/main/graph/badge.svg)](https://codecov.io/gh/tjmlabs/ColiVara)

  The official Python SDK for the ColiVara API. ColiVara is a document search and retrieval API that uses advanced machine learning techniques to index and search documents. This SDK allows you to interact with the API to create collections, upload documents, search for documents, and generate embeddings.



  Install this library using `pip`:
  ```bash
  pip install colivara-py
  ```


  Please see the [ColiVara API documentation](https://docs.colivara.com) for more information on how to use this library.

  You will need to either self-host the API (see the [ColiVara API repo](https://github.com/tjmlabs/ColiVara)) or use the hosted version at https://colivara.com. You will also need an API key, which you can obtain by signing up at [ColiVara](https://colivara.com) or from your self-hosted API.

  ```python
  import os
  from colivara_py import ColiVara


  rag_client = ColiVara(
       
      api_key=os.environ.get("COLIVARA_API_KEY"),
      
      base_url="https://api.colivara.com"
  )

  new_collection = rag_client.create_collection(name="my_collection", metadata={"description": "A sample collection"})
  print(f"Created collection: {new_collection.name}")


  document = rag_client.upsert_document(
      name="sample_document",
      
      collection_name="my_collection",
      url="https://example.com/sample.pdf",
      metadata={"author": "John Doe"}
  )
  print(f"Uploaded document: {document.name}")


  search_results = rag_client.search(
      query="machine learning",
      collection_name="my_collection",
      top_k=3
  )
  for result in search_results.results:
      print(f"Page {result.page_number} of {result.document_name}: Score {result.normalized_score}")


  documents = client.list_documents(collection_name="my_collection")
  for doc in documents:
      print(f"Document: {doc.name}, Pages: {doc.num_pages}")


  embeddings = rag_client.create_embedding(
      input_data=["This is a sample text for embedding"],
      task="query"
  )
  print(f"Generated {len(embeddings.data)} embeddings")


  rag_client.delete_document("sample_document", collection_name="my_collection")
  print("Document deleted")
  ```



  To contribute to this library, first checkout the code. Then create a new virtual environment:

  We use uv, but you can use the pip interface if you prefer:

  ```bash
  cd colivara-py
  uv venv
  source .venv/bin/activate
  ```
  Now install the dependencies and test dependencies:
  ```bash
  uv sync --extra dev-dependencies
  ```
  To run the tests:
  ```bash
  pytest
  ```

  To build the documenation locally:
  ```bash
  pdocs server colivara_py #to see the documentation locally.
  pdocs as_html colivara_py --overwrite #to generate HTML.
  pdocs as_markdown colivara_py #to generate markdown.
  ```


  This SDK is distributed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0). The API is licensed under Functional Source License, Version 1.1, Apache 2.0 Future License. See the [LICENSE.md](LICENSE.md) file for details.

  For commercial licensing, please contact us at [tjmlabs.com](https://tjmlabs.com). We are happy to work with you to provide a license that meets your needs.


pkgId: 502170a90879754ffeccb2ab83a7724e5eb874d5f821fbaf4adc26d22301754f
name: python-coll-filter
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Collaborative Filtering with multi-process parallelism.
url: https://gitee.com/summry/myai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coll-filter-1.3.1-1.src.rpm
checksum_type: sha256
description:
  Usage Sample
  ''''''''''''

  .. code:: python

      from cf import CollFilter

      if __name__ == '__main__':
          data = read_data('file_path')
          data = pre_process(data)  # return [(user_id: Any, item_id: Any, ratting: float),]
          cf = CollFilter(data)

          ucf = cf.user_cf()  # return {user_id: [(item_id, score),],}
          icf = cf.item_cf()  # return {user_id: [(item_id, score),],}

          recommend = cf.recommend(user_id, recall_num=5) # return [(item_id, score),]
          recommends = cf.recommends(user_ids, recall_num=5) # return {user_id: [(item_id, score),],}

          cf.release()


pkgId: 6a1207263a92eb6b70203f8ea8b720b35c27eb0b9cb2cba0a08f91d8ea4220f3
name: python-collapsar
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Create beautiful admin dashboards in Masonite Framework
url: https://github.com/usecollapsar/collapsar
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collapsar-0.1.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://banners.beyondco.de/Collapsar.png?theme=dark&packageManager=pip+install&packageName=collapsar&pattern=cage&style=style_1&description=Masonite+Dashboard+Package&md=0&showWatermark=1&fontSize=100px&images=emoji-happy">
  </p>

  <p align="center">
    <a href="https://collapsar.aguad.dev">
      <img alt="Collapsar" src="https://img.shields.io/static/v1?label=Masonite&message=package&labelColor=grey&color=blue&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAIRlWElmTU0AKgAAAAgABQESAAMAAAABAAEAAAEaAAUAAAABAAAASgEbAAUAAAABAAAAUgEoAAMAAAABAAIAAIdpAAQAAAABAAAAWgAAAAAAAABIAAAAAQAAAEgAAAABAAOgAQADAAAAAQABAACgAgAEAAAAAQAAAA6gAwAEAAAAAQAAAA4AAAAATspU+QAAAAlwSFlzAAALEwAACxMBAJqcGAAAAVlpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDUuNC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFkb2JlLmNvbS90aWZmLzEuMC8iPgogICAgICAgICA8dGlmZjpPcmllbnRhdGlvbj4xPC90aWZmOk9yaWVudGF0aW9uPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KTMInWQAAAnxJREFUKBVNUl1IVEEUPjPObdd1VdxWM0rMIl3bzbVWLSofVm3th0AhMakHHyqRiNSHEAq5b2HSVvoQRUiEECQUQkkPbRslRGigG8auoon2oPSjpev+3PWeZq7eaC5nDt93vplz5txDQJYpNxX4st4JFiwj9aCqmswUFQNS/A2YskrZJPYefkECC2GhQwAqvLYybwXrwBvq8HSNOXRO92+aH7nW8vc/wS2Z9TqneYt2KHjlf9Iv+43wFJMExzO0YE5OKe60N+AOW6OmE+WJTBrg23jjzWxMBauOlfyycsV24F+cH+zAXYUOGl+DaiDxfl245/W9OnVrSY+O2eqPkyz4sVvHoKp9gOihf5KoAVv3hkQgbj/ihG9fI3RixKcUVx7lJVaEc0vnyf2FFll+ny80ZHZiGhIKowWJBCEAKr+FSuNDLt+lxybSF51lo74arqs113dOZqwsptxNs5bwi7Q3q8npSC2AWmvjTncZf1l61e5DEizNn5mtufpsqk5+CZTuq00sP1wkNPv8jeEikVVlJso+GEwRtNs3QeBt2YP2V2ZI3Tx0e+7T89zK5tNASOLEytJAryGtkLc2PcBM5byyUWYkMQpMioYcDcchC6xN220Iv36Ot8pV0454RHLEwmmD7UWfIdX0zq3GjMPG5NKBtv5qiPEPekK2U51j1451BZoc3i+1ohSQ/UzzG5uYFFn2mwVUnO4O3JblXA91T51l3pB3QweDl7sNXMyEjbguSjrPcQNmwDkNc8CbCvDd0+xCC7RFi9wFulD3mJeXqxQevB4prrqgc0TmQ85NG/K43e2UwnMVAJIEBNfWRYR3HfnvivrIzMyo4Hgy+hfscvLo53jItAAAAABJRU5ErkJggg==">
    </a>
    <img alt="GitHub Workflow Status (branch)" src="https://img.shields.io/github/actions/workflow/status/usecollapsar/collapsar/pythonapp.yml?branch=develop">
    <img src="https://codecov.io/gh/usecollapsar/collapsar/branch/develop/graph/badge.svg?token="/>
    <img alt="PyPI" src="https://img.shields.io/pypi/v/collapsar">
    <img src="https://img.shields.io/badge/python-3.6+-blue.svg" alt="Python Version">
    <img alt="GitHub release (latest by date including pre-releases)" src="https://img.shields.io/github/v/release/usecollapsar/collapsar?include_prereleases">
    <img alt="License" src="https://img.shields.io/github/license/usecollapsar/collapsar">
    <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
  </p>



  Collapsar is a package that will let you save time creating a dashboard for your app. You won't need to worry anymore about creating CRUD's.



  - _Add multiple resources to your dashboard using Masonite Models_
  - _Use fields: TextField, IdField, PasswordField, SelectField and more_
  - _Add basic validations: max, min, required, email, etc._



  See the [official documentation](https://collapsar.aguad.dev) to learn how to use Collapsar.



  ```bash
  pip install collapsar
  ```



  Add CollapsarProvider to your project in `config/providers.py`:

  ```python


  from collapsar import CollapsarProvider


  PROVIDERS = [
      
      
      CollapsarProvider,
      
  ]
  ```

  Create a new resource using

  ```python
  python craft resource MyModel
  ```

  And see your panel on https://localhost/collapsar



  Please read the [Contributing Documentation](https://collapsar.aguad.dev/docs/contributing/) here.



  - [Eduardo Aguad](https://www.github.com/eaguad1337)




  Collapsar is open-sourced software licensed under the [MIT license](LICENSE).


pkgId: 64d1450d5e52a5d036c7c966f74971111d260c24418a5f462c1de7c3e3925728
name: python-collate-data-diff
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: Command-line tool and Python library to efficiently diff rows across two different databases.
url: https://github.com/datafold/data-diff
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collate-data-diff-0.11.3-1.src.rpm
checksum_type: sha256
description:
  <a href="https://github.com/datafold/data-diff/graphs/contributors">
    <img src="https://contributors-img.web.app/image?repo=datafold/data-diff" />
  </a>

  This project is licensed under the terms of the [MIT License](https://github.com/datafold/data-diff/blob/master/LICENSE).


pkgId: f6f14995bde4767d74115fea74db3ec69910965de3400b72a31a3ef23736c652
name: python-collate-sqllineage
arch: src
version: 1.4.5
epoch: 0
release: 1
summary: Collate SQL Lineage for Analysis Tool powered by Python and sqlfluff based on sqllineage.
url: https://pypi.org/project/collate-sqllineage/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collate-sqllineage-1.4.5-1.src.rpm
checksum_type: sha256
description:
  Summary:
  Statements(#): 2
  Source Tables:
      db2.table2
  Target Tables:
      db3.table3
  Intermediate Tables:
      db1.table1
  ```

  By default, sqllineage doesn't validate your SQL and could give confusing result in case of invalid SQL syntax.
  In addition, different SQL dialect has different set of keywords, further weakening sqllineage's capabilities when
  keyword used as table name or column name. To reduce the impact, user are strongly encouraged to pass the dialect to
  assist the lineage analyzing.
  Take below example, `analyze` is a reserved keyword in PostgreSQL. Default non-validating dialect gives incomplete result,
  while ansi dialect gives the correct one and postgres dialect tells you this causes syntax error:
  ```
  $ sqllineage -e "insert into analyze select * from foo;"
  Statements(#): 1
  Source Tables:
      <default>.foo
  Target Tables:
  $ sqllineage -e "insert into analyze select * from foo;" --dialect=ansi
  Statements(#): 1
  Source Tables:
      <default>.foo
  Target Tables:
      <default>.analyze
  $ sqllineage -e "insert into analyze select * from foo;" --dialect=postgres
  sqllineage.exceptions.InvalidSyntaxException: This SQL statement is unparsable, please check potential syntax error for SQL
  ```
  Use `sqllineage --dialects` to see all available dialects.

  We also support column level lineage in command line interface, set level option to column, all column lineage path will
  be printed.
  ```sql
  INSERT OVERWRITE TABLE foo
  SELECT a.col1,
         b.col1     AS col2,
         c.col3_sum AS col3,
         col4,
         d.*
  FROM bar a
           JOIN baz b
                ON a.id = b.bar_id
           LEFT JOIN (SELECT bar_id, sum(col3) AS col3_sum
                      FROM qux
                      GROUP BY bar_id) c
                     ON a.id = sq.bar_id
           CROSS JOIN quux d;
  INSERT OVERWRITE TABLE corge
  SELECT a.col1,
         a.col2 + b.col2 AS col2
  FROM foo a
           LEFT JOIN grault b
                ON a.col1 = b.col1;
  ```
  Suppose this sql is stored in a file called foo.sql
  ```
  $ sqllineage -f foo.sql -l column
  <default>.corge.col1 <- <default>.foo.col1 <- <default>.bar.col1
  <default>.corge.col2 <- <default>.foo.col2 <- <default>.baz.col1
  <default>.corge.col2 <- <default>.grault.col2
  <default>.foo.* <- <default>.quux.*
  <default>.foo.col3 <- c.col3_sum <- <default>.qux.col3
  <default>.foo.col4 <- col4
  ```

  One more cool feature, if you want a graph visualization for the lineage result, toggle graph-visualization option
  Still using the above SQL file
  ```
  sqllineage -g -f foo.sql
  ```
  A webserver will be started, showing DAG representation of the lineage result in browser:
  - Table-Level Lineage
  <img src="https://raw.githubusercontent.com/reata/sqllineage/master/docs/_static/table.jpg" alt="Table-Level Lineage">
  - Column-Level Lineage
  <img src="https://raw.githubusercontent.com/reata/sqllineage/master/docs/_static/column.jpg" alt="Column-Level Lineage">


pkgId: cb8487ee8116630303cdf68d88c6f5f08ea00c181ea8faba9898b92c7ad4d2d8
name: python-collections-extended
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Extra Python Collections - bags (multisets) and setlists (ordered sets)
url: https://github.com/mlenzen/collections-extended
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collections-extended-2.0.2-1.src.rpm
checksum_type: sha256
description:
  ``collections_extended`` is a pure Python module with no dependencies providing:
  - a ``bag`` class, AKA **multiset**,
  - a ``setlist`` class, which is a **unique list** or **ordered set**,
  - a ``bijection`` class, ``RangeMap`` which is a mapping from ranges to values and
  - a ``IndexedDict`` class, which is an ordered mapping whose elements can be accessed using index, in addition to key.
  There are also frozen (hashable) varieties of bags and setlists.
  Compatible with and tested against Python 3.6, 3.7, 3.8, 3.9, 3.10 & PyPy3.


pkgId: d7426c126fd121dc52b875fb064fc65dd43a9a7579be7186b2e6caaef006f2af
name: python-collective.MockMailHost
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Used for integration testing with Plone
url: https://github.com/collective/collective.mockmailhost
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.MockMailHost-3.0.0-1.src.rpm
checksum_type: sha256
description:
  ``collective.MockMailHost`` enables integration testing of email functionality
  from Plone_. Simply add this egg to your [test] runner section, and install
  this product through your ``Layer`` or ``TestCase``.
  Note
    THIS IS FOR TESTING PURPOSE ONLY, do not use this product on your
    running Plone site. It replaces the standard MailHost with a Mock
    MailHost that you can poke at to check email content and recipients.
  Has been tested with Plone 4 but should also work with earlier versions.


pkgId: de268edfb2636a59b318bc5d59830e47bc928cc0dba153f2e0ab4b398510ae80
name: python-collective.behavior.relatedmedia
arch: src
version: 3.6.6
epoch: 0
release: 1
url: https://github.com/kombinat/collective.behavior.relatedmedia
rpm_license: gpl
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.behavior.relatedmedia-3.6.6-1.src.rpm
checksum_type: sha256
summary:
  Adds Various configuration fields and viewlets to manage and show content related images and attachments

description:
  - Configurable large overlay images scale
    [petschki]

  - Inject slickSliderOptions via data-attributes.
    [petschki]

  - Fix Fancybox initialization problems.
    [petschki]

  - Initialize "slick-slider" automatically inside TinyMCE image gallery.
    [petschki]

  - Fix broken attachments.
    [petschki]

  - Hide image/attachment viewlet when no content available.
    [petschki]
  - update JS resources.
    [petschki]

  - Enhanced Attachment viewlet.
    [petschki]

  - Fixed upgrade step for TinyMCE gallery tool.
    Cleanup settings for old template.
    [petschki]

  - Fixed upgrade step for migrating "base_path" relations.
    [petschki]

  - Remove old obsolete JS resource from upload viewlet.
    [petschki]

  - packaging updates.
    [petschki]

  Features:
  - New gallery editor plugin for TinyMCE replacing the gallery template and adds
    possibility to select/reorder gallery images inside TinyMCE.
    [petschki]

  Features:
  - Outputfilter and pattern for related image gallery.
  - TinyMCE template for gallery placement inside richtext.
    [petschki]

  - Do not fail in update script when broken catalog brains exists.
    [petschki]

  - Fix syncing review_state of (deprecated) related media container.
    [petschki]

  - Fix error when invalid attachment is uploaded.
    [petschki]

  - Added upgrade tep for renamed behavior.
    [petschki]

  - Fix default behavior assignment for "Page".
    [petschki]


pkgId: ab55c483104650acc6a90da8b32ef418dc9e63ab725961252ef63720b9ba193e
name: python-collective.behavior.talcondition
arch: src
version: 1.0.0
epoch: 0
release: 1
url: http://pypi.python.org/pypi/collective.behavior.talcondition
rpm_license: GPL V2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.behavior.talcondition-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  This package contains a Dexterity behavior and AT schemaextender to add a TAL condition on a content type.


pkgId: bcca256f5a651f3d03bb753f2cea13033f8b2c7a44ed387bff05d6b3803cf949
name: python-collective.blog
arch: src
version: 1.0.0a13
epoch: 0
release: 1
summary: A Blog-Addon for Plone.
url: https://github.com/collective/collective.blog
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.blog-1.0.0a13-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img alt="kitconcept GmbH" width="200px" src="https://kitconcept.com/logo.svg">
  </p>

  <h1 align="center">collective.blog</h1>
  <h3 align="center">Blog features for Plone</h3>

  <div align="center">

  [![PyPI](https://img.shields.io/pypi/v/collective.blog)](https://pypi.org/project/collective.blog/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/collective.blog)](https://pypi.org/project/collective.blog/)
  [![PyPI - Wheel](https://img.shields.io/pypi/wheel/collective.blog)](https://pypi.org/project/collective.blog/)
  [![PyPI - License](https://img.shields.io/pypi/l/collective.blog)](https://pypi.org/project/collective.blog/)
  [![PyPI - Status](https://img.shields.io/pypi/status/collective.blog)](https://pypi.org/project/collective.blog/)

  [![PyPI - Plone Versions](https://img.shields.io/pypi/frameworkversions/plone/collective.blog)](https://pypi.org/project/collective.blog/)

  [![Meta](https://github.com/collective/collective.blog/actions/workflows/meta.yml/badge.svg)](https://github.com/collective/collective.blog/actions/workflows/meta.yml)
  ![Code Style](https://img.shields.io/badge/Code%20Style-Black-000000)

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

  </div>



  `collective.blog` adds blogging features to a [Plone](https://plone.org/) site.



  | name          | context                                                         |
  | ------------- | --------------------------------------------------------------- |
  | `Blog`        | A folderish content type that supports adding Posts and Authors |
  | `Blog Author` | An Author in a blog                                             |
  | `Blog Tag`    | A Tag for categorizing posts in a blog                          |
  | `Blog Post`   | A Post in a blog                                                |



  Add `collective.blog` as a dependency on your package's `setup.py`

  ```python
      install_requires = [
          "collective.blog",
          "Plone",
          "plone.restapi",
          "setuptools",
      ],
  ```

  Also, add `collective.blog` to your package's `configure.zcml` (or `dependencies.zcml`):

  ```xml
  <include package="collective.blog" />
  ```



  To automatically enable this package when your add-on is installed, add the following line inside the package's `profiles/default/metadata.xml` `dependencies` element:

  ```xml
      <dependency>profile-collective.blog:default</dependency>
  ```



  We welcome contributions to `collective.blog`.

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

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



  - Python 3.8 or later
  - Docker



  Install all development dependencies -- including Plone -- and create a new instance using:

  ```bash
  make install
  ```



  ```bash
  make i18n
  ```



  ```bash
  make format
  ```



  Testing of this package is done with [`pytest`](https://docs.pytest.org/) and [`tox`](https://tox.wiki/).

  Run all tests with:

  ```bash
  make test
  ```

  Run all tests but stop on the first error and open a `pdb` session:

  ```bash
  ./bin/tox -e test -- -x --pdb
  ```

  Run only tests that match `TestVocabAuthors`:

  ```bash
  ./bin/tox -e test -- -k TestVocabAuthors
  ```

  Run only tests that match `TestVocabAuthors`, but stop on the first error and open a `pdb` session:

  ```bash
  ./bin/tox -e test -- -k TestVocabAuthors -x --pdb
  ```



  The development of this add-on has been kindly sponsored by [German Aerospace Center (DLR)](https://www.dlr.de) and [Forschungszentrum Jülich](https://www.fz-juelich.de).

  <img alt="German Aerospace Center (DLR)" width="200px" src="https://raw.githubusercontent.com/collective/collective.blog/main/docs/dlr.svg" style="background-color:white">
  <img alt="Forschungszentrum Jülich" width="200px" src="https://raw.githubusercontent.com/collective/collective.blog/main/docs/fz-juelich.svg" style="background-color:white">

  Developed by [kitconcept](https://www.kitconcept.com/)



  The project is licensed under GPLv2.




  - Jonas Piterek [@jonaspiterek]
  - Érico Andrei [@ericof]
  - Timo Stollenwerk [@tisto]
  - collective [info@kitconcept.com]




  <!--
     You should *NOT* be adding new change log entries to this file.
     You should create a file in the news directory instead.
     For helpful instructions, please see:
     https://github.com/plone/plone.releaser/blob/master/ADD-A-NEWS-ITEM.rst
  -->

  <!-- towncrier release notes start -->






  - Remove custom serializers for blog content types. They were serializing preview_image_link in the wrong format. @davisagli #75






  - Fix tags widget to not have an open vocabulary, and adjust Volto widget @sneridagh #71






  - Fix 'Wrong contained type' error for new blog posts with no tags created using plone.restapi. @davisagli #69






  - - Update German translations [@jonaspiterek] #63
  - Update Brazilian Portuguese translations [@ericof] #67




  - Add a GitHub Actions workflow to automatically check for Changelog entries on pull requests [@ericof] #65






  - Added Blog Tag content type. A tags folder is created for new blogs, but not existing ones. @davisagli #61






  - Limit authors vocabulary to authors from the current blog context. @davisagli #59






  - Allow a Blog Post to be created inside a subfolder of a Blog #54




  - Refactor post_authors indexer to avoid repeated calls to the catalog #56






  - - Add indexer for indexing authors from a blog post [@jonaspiterek] #53







  - Translate id and title for Authors folder on creation [@jonaspiterek] #50







  - Rename Blog fti to BlogFolder, allowing contents with id blog to be added [@ericof] #42
  - Add initial blocks to auto_add_authors_container handler [@jonaspiterek] #43
  - Rename blog index and metadata to blog_uid [@ericof] #48







  - Control creation of "Authors" folder via registry configuration [@ericof] #34
  - Add control panel to configure Blog Settings [@ericof] #36
  - Additional information returned on /@authors endpoint [@ericof] #40




  - Increase test coverage of the package [@ericof] #38







  - Initial Package Structure for Plone 6 [@jonaspiterek] #11
  - Blog and Author should be listed on Plone Navigation [@jonaspiterek] #13
  - Implement i18n support [@ericof] #17
  - Implement `collective.blog.blog_info` behavior [@ericof] #20
  - Disable allowing to add Author globally. Fix GS titles [@jonaspiterek] #21
  - Add index and metadata for blog post and blog author, Add test for blog author [@jonaspiterek] #28
  - Implement collective.blog: Add Author, collective.blog: Add Blog, collective.blog: Add Post permissions [@ericof] #30
  - Create folder authors inside a blog [@jonaspiterek] #32




  - Improve README.md [@ericof] #15




  - Initial release. [@pcdummy]


pkgId: 5464860c161e586ab2175c256ccc94369f0d4e741cd5df9fabbd64f32dc51b25
name: python-collective.checkdocs
arch: src
version: 0.2
epoch: 0
release: 1
summary: Distutils command to view and validate restructured text in package's long_description
url: https://github.com/collective/collective.checkdocs
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.checkdocs-0.2-1.src.rpm
checksum_type: sha256
description:
  Install this to your development Python run-time::
          easy_install collective.checkdocs
  *Note*: On OSX at least Python version 2.5 or newer is required.


pkgId: 82e4ac867a7879cdea514d5b15f5d9700ac154fee7fcf6c1b714460d1a10518e
name: python-collective.classifieds
arch: src
version: 1.7
epoch: 0
release: 1
summary: Add classifieds to your Plone intranet or website.
url: http://www.plone.org/products/classifieds
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.classifieds-1.7-1.src.rpm
checksum_type: sha256
description:
  collective.classifieds
  With this product you can add classifieds to your intranet or website.
  The product exists of categories (which are folderish) and classifieds
  and comes with different kinds of views.
  Some features include:
  * Visitors can browse (all / newest) classifieds
  * Add new classifieds to a category
  * Search classifieds (title, description)
  * View categories containing classifieds
  * View the newest classifieds and view all classifieds created per author
  * Manually order classifieds
  * Add pictures to categories
  * Directlinks to Classifieds (for linking)


pkgId: 804afc75999f2a916fee86283e821ae0395395e6777607404569e4e13a0d5844
name: python-collective.collectionfilter
arch: src
version: 5.2.1
epoch: 0
release: 1
summary: Plone addon for filtering collection results.
url: http://github.com/collective/collective.collectionfilter
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.collectionfilter-5.2.1-1.src.rpm
checksum_type: sha256
description:
  |CI| |Meta|
  Faceted navigation filter for collection or contentlisting tiles.
  This Plone 5 addon allows you to filter listing results for fields which are indexed in the catalog
  (Plones internal search tool).
  For example, you can add a subject filter, but also a filter for authors or portal types.
  The filter types can be extended (see: ``collective.collectionfilter.vocabularies``).
  There are three portlets/tiles available for filtering:
  ``Collection Filter``
      a list with values (select, radio, checkbox, link) you can filter on
  ``Collection Search``
      a SearchableText input field to do a fulltextsearch on the collection results
  ``Collection Maps``
      a LeafletJS map which shows and filters ``IGeolocatable`` items on it
      (this feature is available if ``collective.geolocationbehavior`` is installed and the behavior
      is activated on a contenttype. See installation notes below)
  ``Collection Result Listing Sort``
      a list of indexes where the user can sort the filtered result listing
  ``Collection Filter Reset``
      a link to reset all filters


pkgId: 89c0dfc49f51ba88a11511919de994f31c4812fb53ae6b23dff84e31fda37632
name: python-collective.contact.core
arch: src
version: 1.42.0
epoch: 0
release: 1
summary: Core package for collective.contact add-ons
url: https://github.com/collective/collective.contact.core
rpm_license: gpl
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.contact.core-1.42.0-1.src.rpm
checksum_type: sha256
description:
  This add-on is part of the ``collective.contact.*`` suite. For an overview and a demo of these suite, see `collective.contact.demo <https://github.com/collective/collective.contact.demo>`__.
  A Plone add-on that provides a directory where you create persons, organizations, sub-organizations and positions.


pkgId: 7d0caf8442fa74758e1d6b00ca0f9a74cc49d5951e1b517d85f40e931722cec4
name: python-collective.dexteritytextindexer
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: Dynamic SearchableText index for dexterity content types
url: http://github.com/collective/collective.dexteritytextindexer
rpm_license: GPL2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.dexteritytextindexer-2.4.1-1.src.rpm
checksum_type: sha256
description:
  `collective.dexteritytextindexer` provides a dynamic SearchableText indexer for
  dexterity content types. It makes it possible to index fields of multiple
  behaviors as SearchableText.


pkgId: a5d4e7a54c0f693e6102967212a7e9bd7050ce1cd6ea73d69397fef8b063c345
name: python-collective.dms.mailcontent
arch: src
version: 1.16.2
epoch: 0
release: 1
summary: Mail content type for document management system
url: https://github.com/collective/collective.dms.mailcontent
rpm_license: gpl
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.dms.mailcontent-1.16.2-1.src.rpm
checksum_type: sha256
description:
  Base mail content class (paper document, email) for document management system.
  This product is an extension for `collective.dms.basecontent <https://pypi.org/project/collective.dms.basecontent>`_
  .


pkgId: 6d0d9ca5149c4c184be6e2dc3dc0a8f4a6599e842607bc85d0135702f365d555
name: python-collective.easyslider
arch: src
version: 1.4.1
epoch: 0
release: 1
url: http://plone.org/products/collective.easyslider/
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.easyslider-1.4.1-1.src.rpm
checksum_type: sha256
summary:
  The product will allow you to apply an easyslider to any page with the ability to create each slide using a WYSIWYG editor. It also provides a slider view for Folders and Collections.

description:
  This product allows you to easily add an easySlider content rotator to any page on a plone site using a WYSIWYG editor to design each slide.


pkgId: 445b9a6df82ff9448ef9345fbba3f2eaa78822ef13499fa4aee0c687449d37a1
name: python-collective.eeafaceted.dashboard
arch: src
version: 0.22.0
epoch: 0
release: 1
url: http://pypi.python.org/pypi/collective.eeafaceted.dashboard
rpm_license: GPL V2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.eeafaceted.dashboard-0.22.0-1.src.rpm
checksum_type: sha256
summary:
  This package is the glue between different packages offering a usable and integrated dashboard application

description:
  This package does the glue between :
  - `collective.eeafaceted.collectionwidget <https://github.com/collective/collective.eeafaceted.collectionwidget>`_
  - `collective.eeafaceted.z3ctable <https://github.com/collective/collective.eeafaceted.z3ctable>`_
  - `collective.compoundcriterion <https://github.com/collective/collective.compoundcriterion>`_
  - `collective.documentgenerator <https://github.com/collective/collective.documentgenerator>`_
  This build a useable eea.facetednavigation based dashboard (works on both Plone 4.3.x and Plone 5.x).  Use the demo profile to easily check what it does :
  Dashboard is essentially made of a faceted widget displaying pre-configured searches, results are displayed in a faceted layout using a table.


pkgId: 1a0f2605b533edeef116f23209235e2f8563dadf624f3cb35a27b320a188f45e
name: python-collective.folderishtraverse
arch: src
version: 2.0
epoch: 0
release: 1
summary: Traverse to first item in folder
url: http://github.com/collective/collective.forlderishtraverse
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.folderishtraverse-2.0-1.src.rpm
checksum_type: sha256
description:
  This package provides an view which traverses to the first item found in an
  ordered container. If the default view of the item, which the traverse view is
  traversing to is also a traverse view, the traversing happens again to the next
  sub-sub-item in the sub-folder, if possible.
  The traversing/redirection is only done for users who are not allowed to see
  the folder listing of the current context (usally anonymous users and normal
  members). For users with higher permissions, a folder contents view is shown.
  This way, members can easily edit the folder without being redirected to
  another folder.
  collective.folderishtraverse is an alternative to a default page in Plone. The
  difference is, that the target content is shown in the navigation tree and that
  traversing to any nested content in any level of the tree's hierarchy is
  possible.


pkgId: fe52c99e500d3aed64de1d4c90f895970f873b85b677309f0a9270eec56c94ed
name: python-collective.folderishtypes
arch: src
version: 3.1
epoch: 0
release: 1
summary: Folderish News Item, Document and Event as replacement for default types.
url: http://github.com/collective/collective.folderishtypes
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.folderishtypes-3.1-1.src.rpm
checksum_type: sha256
description:
  Provides the types "Folderish Event", "Folderish News Item" and
  "Folderish Document" as replacements for their `Plone`_ ATContentTypes equivalents.
  Those types are able to hold any other content, like a Folder.
  There is a "portlet" profile, which installs a portlet to show the contents of
  an folderish type.
  You can limit the types, which can be added to FolderishTypes by providing
  a Generic Setup import type configuration.
  The reason for this package is, that in my experience it's easier to group
  related content together at one place. An article about something fancy might
  have an image gallery associated with it as well as some pdf-downloads. With
  this package you can put everything inside the article.
  Another use case is that you can structure content hierarchically and don't need
  to define "default pages" - a concept hard to understand and handle (see:
  https://sixfeetup.com/blog/plone-drupal-features )
  Alexander Limi also wished folderish content back in 2008:
  "#10: Content re-use is overrated — people like folderish"
  https://limi.net/things-plone


pkgId: 6de9a2eed6b0a3520e1d5d7098907acb9671b78272cb8f61c5a07575a16a7163
name: python-collective.geolocationbehavior
arch: src
version: 1.7.2
epoch: 0
release: 1
summary: Dexterity behavior to add geographic locations to contents.
url: https://github.com/collective/collective.geolocationbehavior/
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.geolocationbehavior-1.7.2-1.src.rpm
checksum_type: sha256
description:
  Dexterity based behaviors for geotagging.
  Implements plone.formwidget.geolocation which adds LeafletJS support.
  Adds catalog indexes/metadata for latitude/longitude to support
  GeoJSON Featurelist output/filtering.
  The GeoJSON properties can be customized with the provided IGeoJSONProperties
  adapter.


pkgId: fd43e047b8930ba1e6ec67ee4bd9dffea79c2405909098dfeb5e7eb8104606f3
name: python-collective.indexing
arch: src
version: 2.1
epoch: 0
release: 1
summary: Abstract framework for queueing, optimizing and dispatching index operations for Plone content.
url: https://github.com/collective/collective.indexing
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.indexing-2.1-1.src.rpm
checksum_type: sha256
description:
  `collective.indexing`_ is an approach to provide an abstract framework for
  queuing and optimizing index operations in `Plone`_ as well as dispatching
  them to various backends. The default implementation aims to replace the
  standard indexing mechanism of `CMF`_ to allow index operations to be handled
  asynchronously in a backwards-compatible way.
  Queuing these operations on a transaction level allows to get rid of redundant
  indexing of objects and thereby providing a substantial performance
  improvement.  By leveraging the component architecture and Zope event system
  `collective.indexing`_ also makes it much easier to use backends other
  than or in addition to the standard portal catalog for indexing, such as
  dedicated search engine solutions like `Solr`_, `Xapian`_ or `Google Search
  Appliance`_.  One backend implementation designed to be used with this package
  has already been started in the form of `collective.solr`_.


pkgId: 79a0d36cca43cac13afb387c5943707e32564a3925b2c870260dcfc0254afc16
name: python-collective.mailchimp
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: MailChimp integration for Plone.
url: https://pypi.python.org/pypi/collective.mailchimp
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.mailchimp-3.1.1-1.src.rpm
checksum_type: sha256
description:
  MailChimp integration for Plone 4 and 5.
  MailChimp helps you design email newsletters, share them on social networks, integrate with services you already use, and track your results.
  collective.mailchimp provides a @newsletter view to let visitors subscribe to one or more MailChimp mailing lists. It also provides a MailChimp portlet in case you want to display your newsletter subscription as part of an existing site.
  The newsletter subscriptions forms in both the view and the portlet are extendable, so you can add custom fields that can be stored in your MailChimp subscriber list.
  It also comes with a MailChimp control panel to let you enter your MailChimp credentials for your Plone site.
  collective.mailchimp is tested on Plone 4.x and 5.x and should work on Plone > 3.3
  (with the appropriate version pins for plone.app.registry and z3c.form).


pkgId: ea6b7bd328e213a798fcb12445345d06f8a65bf176984285b8d38ac6a25011db
name: python-collective.pdbpp
arch: src
version: 1.0.0a3
epoch: 0
release: 1
summary: An addon for Plone that allow you debug your code using the pdbpp package
url: https://github.com/collective/collective.pdbpp
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.pdbpp-1.0.0a3-1.src.rpm
checksum_type: sha256
description:
  [![image](https://github.com/collective/collective.pdbpp/actions/workflows/plone-package.yml/badge.svg)](https://github.com/collective/collective.pdbpp/actions/workflows/plone-package.yml)
  [![Coveralls](https://coveralls.io/repos/github/collective/collective.pdbpp/badge.svg?branch=main)](https://coveralls.io/github/collective/collective.pdbpp?branch=main)
  [![image](https://codecov.io/gh/collective/collective.pdbpp/branch/master/graph/badge.svg)](https://codecov.io/gh/collective/collective.pdbpp)
  [![Latest Version](https://img.shields.io/pypi/v/collective.pdbpp.svg)](https://pypi.python.org/pypi/collective.pdbpp/)
  [![Egg Status](https://img.shields.io/pypi/status/collective.pdbpp.svg)](https://pypi.python.org/pypi/collective.pdbpp)
  ![image](https://img.shields.io/pypi/pyversions/collective.pdbpp.svg?style=plastic%20%20%20:alt:%20Supported%20-%20Python%20Versions)
  [![License](https://img.shields.io/pypi/l/collective.pdbpp.svg)](https://pypi.python.org/pypi/collective.pdbpp/)



  An addon for Plone that does allow you to use the [pdbpp](https://github.com/pdbpp/pdbpp) package



  Install `collective.pdbpp` by adding it to your buildout, e.g.:

      [instance]
      eggs +=
          collective.pdbpp

  and then running `bin/buildout`.

  When your instance starts you can enter a pdb session by adding the path `pdb` to any URL, e.g.:

  - http://localhost:8080/pdb
  - http://localhost:8080/Plone/pdb




  The [Syslab.com](https://www.syslab.com) Team.



  Put your name here, you deserve it!

  - Alessandro Pisa, [Syslab.com](https://www.syslab.com)



  - Issue Tracker:
    <https://github.com/collective/collective.pdbpp/issues>
  - Source Code: <https://github.com/collective/collective.pdbpp>
  - Documentation: <https://docs.plone.org/foo/bar>



  If you are having issues, please let us know in the [issue tracker](https://github.com/collective/collective.pdbpp/issues).



  The project is licensed under the GPLv2.





  - ale-rt, alessandro.pisa@gmail.com







  - Add features from rich to make debugging easier.




  - Initial release.
    [ale-rt]


pkgId: 9688983a3c4f8c5f988ffc08a8beb6ab7877ab0bf98f9276553ea4c5e7b36905
name: python-collective.purgebyid
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: p.a.caching add-on for a better purging policy
url: https://github.com/collective/collective.purgebyid
rpm_license: gpl
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.purgebyid-1.2.2-1.src.rpm
checksum_type: sha256
description:
  collective.purgbyid is a new method for cache invalidation of Plone
  based web sites. It uses the idea of adding an extra header, called
  X-Ids-Involved, which contains the uuids of the objects involved in the
  construction of the resources. For example, an image contains just its
  uuid::
      % wget -S http://localhost:8080/Plone/image01
        X-Ids-Involved: #c8d7c0bc2b794325b916d990de91d7ee#
  Other pages may be more complicated. Then a new purge rewrite rule adds
  a custom URL to the set of URLs to purge: the "purge by id" custom URL
  is in the form /@@purgebyid/<UUID> where UUID is the object's uuid to be
  purged.
  Last, Varnish is configured so that, when an URL /@@purgebyid/<UUID> is
  purged, it will ban all the objects that match an X-Ids-Involved header
  of the right type (i.e. containing the uuid of the resource to purge).
  This means that when a resources is purged, it is enough to purge also
  it /@@purgebyid/<UUID> URL because it will be Varnish responsibily to
  also catch all of the occurrencies of the resources whenever the URL
  which is used to access it.


pkgId: 9a880106d20ca8cdb50d27e87f9e691021d2bd9bbdba42fcd9dc1f8415287e5c
name: python-collective.recipe.solrinstance
arch: src
version: 5.3.3
epoch: 0
release: 1
summary: zc.buildout to configure a solr instance
url: http://pypi.python.org/pypi/collective.recipe.solrinstance
rpm_license: ZPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.recipe.solrinstance-5.3.3-1.src.rpm
checksum_type: sha256
description:
  - This version of the recipe supports Solr 3.5, 4.x (including 4.0, 4.1, 4.2
    and 4.5). Please use a release from the 2.x series if you are using Solr 1.4.
  - This version supports Genshi_ templates **only**. Please use a release
    less than 5.x if you require Cheetah_ templating and do not require
    Python 3 support. If you require Python 3 support, you must convert
    any custom templates to use the `Genshi text templating language`_.
  Supported options
  *****************
  The recipe supports the following options.


pkgId: 06e6aab960041091d62f7094dc2bd60973e0cd72712556309fbd970efdb05f04
name: python-collective.recipe.supervisor
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A buildout recipe to install supervisor
url: https://github.com/collective/collective.recipe.supervisor/
rpm_license: ZPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.recipe.supervisor-1.0.0-1.src.rpm
checksum_type: sha256
description:
  The recipe supports the following options:
  sections
      List of enabled supervisor sections.
      Defaults to enable all: ``global http ctl rpc services``.
  plugins
      Extra eggs you want the recipe to install, e.g. ``superlance``
  http-socket
      ``inet`` or ``unix`` socket to use for HTTP administration. Defaults to ``inet``.
  file
      A path to a UNIX domain socket (e.g. ``/tmp/supervisord.sock``) on which
      supervisor will listen for HTTP/XML-RPC requests.
  chmod
      Change the UNIX permission mode bits of the UNIX domain socket to this value at startup.
  chown
      Change the ownership of the UNIX domain socket to this value at startup.
      Either ``user`` or ``user:group``.
  port
      The port number ``supervisord`` listens to, e.g. ``9001``. Can be given as ``host:port``, e.g.
      ``127.0.0.1:9001``. Defaults to ``127.0.0.1:9001``
  user
      The username required for authentication to supervisord
  password
      The password required for authentication to supervisord
  supervisord-conf
      Full path to where the recipe puts the supervisord configuration file.
      Defaults to ``${buildout:directory}/parts/${name}/supervisord.conf``
  supervisord-user
      If supervisord is run as the root user, switch users to this UNIX user
      account before doing any meaningful processing. This value has no effect
      if supervisord is not run as root.
  supervisord-directory
      When supervisord daemonizes, switch to this directory. This option can
      include the value ``s``, which expands to the directory in which the
      supervisord configuration file was found.
  supervisord-environment
      A list of key/value pairs in the form ``KEY=val,KEY2=val2`` that will be placed
      in the supervisord process's environment (and as a result in all of its
      child processes' environments). This option can include the value ``s``,
      which expands to the directory in which the supervisord configuration file
      was found. Note that subprocesses will inherit the environment variables of
      the shell used to start supervisord except for the ones overridden here and
      within the program's environment configuration stanza.
  childlogdir
      The full path of the directory where log files of processes managed by
      Supervisor while be stored. Defaults to ``${buildout:directory}/var/log``
  logfile
      The full path to the supervisord log file. Defaults to
      ``${buildout:directory}/var/log/supervisord.log``
  pidfile
      The pid file of supervisord. Defaults to
      ``${buildout:directory}/var/supervisord.pid``
  logfile-maxbytes
      The maximum number of bytes that may be consumed by the activity log file
      before it is rotated. Defaults to 50MB.
  logfile-backups
      The number of backups to keep around resulting from activity log file
      rotation. Defaults to 10.
  loglevel
     The logging level. Can be one of ``critical``, ``error``, ``warn``, ``info``, ``debug``, ``trace``,
     or ``blather``. Defaults to ``info``.
  umask
     The umask of the supervisord process. Defaults to ``022``.
  nodaemon
     If true, supervisord will start in the foreground instead of daemonizing.
     Defaults to false.
  nocleanup
    Prevent supervisord from clearing any existing AUTO child log files at
    startup time. Useful for debugging. Defaults to false.
  serverurl
     The URL that should be used to access the supervisord server. Defaults to
     ``http://127.0.0.1:9001``
  programs
     A list of programs you want the supervisord to control. One per line.
     The format of a line is as follows::
         priority process_name [(process_opts)] command [[args] [directory] [[redirect_stderr]] [user]]
     The ``[args]`` are any number of arguments you want to pass to the ``command``.
     It has to be given between ``[]`` (e.g. ``[-v fg]``). See examples below.
     If not given, ``redirect_stderr`` defaults to false.
     If not given, the ``directory`` option defaults to the directory containing the
     the command.
     The optional ``process_opts`` argument sets additional options on the proccess
     in the supervisord configuration.
     It has to be given between ``()`` and must contain options in ``key=value`` format
     with spaces only for separating options -- e.g. ``(autostart=false startsecs=10)``.
     The optional ``user`` argument gives the userid that the process should be run
     as (if supervisord is run as root).
     In most cases you will only need to give the 4 first parts::
         priority process_name command [[args]]
  eventlisteners
      A list of eventlisteners you'd like supervisord to run as subprocesses to
      subscribe to event notifications. One per line. Relevant supervisor
      documentation about events is at
      http://supervisord.org/events.html ::
          processname [(process_opts)] events command [[args]]
      ``events`` is a comma-separated list (without spaces) of event type names
      that the listener is interested in receiving notifications for.
      Supervisor provides one event listener called ``memmon`` which can be used to
      restart supervisord child process once they reach a certain memory limit.
      Note that you need to define the variables ``user``, ``password`` and ``serverurl``
      (described in the supported options above) to be able to use the memmon listener.
      An example of defining a memmon event listener, which analyzes memory usage
      every 60 seconds and restarts as needed could look like::
         MemoryMonitor TICK_60 ${buildout:bin-directory}/memmon [-p process_name=200MB]
      As eventlisteners are a special case of processes, the also accept process
      options. One useful option is to start an eventlistener like the HttpOk
      checker only after your webserver has had time to start and load, say
      after 20 seconds:
         HttpOk (startsecs=20) TICK_60 ${buildout:bin-directory}/httpok [-p web -t 20 http://localhost:8080/]
  groups
     A list of programs that become part of a group. One per line.
     The format of a line is as follow::
         priority group_name program_names
     ``programs_name`` is a comma-separated list of program names.
  env-path
      The environment variable PATH, e.g. ``/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin``


pkgId: 6bf30171f4ba1dbfcc55fc21d7886df49189975f84903288a00d01d921dc077c
name: python-collective.recipe.template
arch: src
version: 2.2
epoch: 0
release: 1
summary: Buildout recipe to generate a text file from a template
url: https://github.com/collective/collective.recipe.template
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.recipe.template-2.2-1.src.rpm
checksum_type: sha256
description:
  * Starting with version 1.3, you can also specify a path to the output
    file and the path will be created if it does not exist.
  * Starting with version 1.5, you can use inline templates.
  * Starting with version 1.7, you can use `genshi text templates`_.
  * Starting with version 1.9, you can use a URL to specify template input.
  * Starting with version 1.12, you can specify ``timeout`` as an option to
    configure ``urllib2`` requests.
  * Starting with version 2.1, you can set ``input-encoding`` and
    ``output-encoding`` to specify the character encoding.


pkgId: 73a1cc01939e3f698155e588a10e139fbd39f406c3a3cbb07a98640e248386d9
name: python-collective.recipe.vscode
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Visual Studio Code configuration for buildout-based Python projects
url: https://github.com/nazrulworld/collective.recipe.vscode
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.recipe.vscode-0.1.9-1.src.rpm
checksum_type: sha256
description:
  ``collective.recipe.vscode`` is the buildout recipe for `Visual Studio Code`_ lover who wants python `autocomplete and intelliSense`_ features while developing python `Buildout`_ based project,
  normally buildout eggs are not available in python path even if you provide virtualenv python path.
  This tool will help not only adding eggs path as ``python extraPath`` but also you can manage per project basis vscode settings
  for linter, autoformatting.
  A general question may arise that why we will use this tool, whether we can create `Visual Studio Code`_ project settings easily (we have better knowledge over `Visual Studio Code`_ configuration)?
  Well i completely agree with you, but if you want to get benefited from  `Visual Studio Code`_ autocompletion feature (basically I am lover of autocompletion), you have to add all eggs links and it is hard to manage eggs links manually
  if the size of project is big (think about any `Plone`_ powered project),
  beside it is good practice allways use project specific linter path. For example my global ``flake8`` linter doesn't work
  for my python3 project!


pkgId: c57c3c4693d2880574cf246d57c9584366062cf74cda4b8077df295e2ef50deb
name: python-collective.searchandreplace
arch: src
version: 8.3
epoch: 0
release: 1
summary: Batch Search and Replace
url: https://github.com/collective/collective.searchandreplace
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.searchandreplace-8.3-1.src.rpm
checksum_type: sha256
description:
  The collective.searchandreplace product is a Plone Add-on designed to find and replace text in Plone content objects.
  It searches in all text fields (since version 7.0) and all string fields (since 8.0).
  This includes default content types fields like title, description, and document text.
  It excludes the id/short name string field.
  It operates over single or multiple Plone content objects and can show a preview of changes as well as immediately perform them.
  Features include:
  - being able to control searching in subfolders
  - matching based on case sensitivity/insensitivity
  - maximum number of results
  - fast search using the catalog by default
  - disable the fast search to be able to search and replace raw html tags, for example replace ``<strong>text</strong>`` by ``<em>text</em>``


pkgId: 54ed1a2f87a7b63cca8f9f4e1792f631883638f6ad7635d5bc89be206b768394
name: python-collective.taxonomy
arch: src
version: 3.1.4
epoch: 0
release: 1
summary: Create, edit and use hierarchical taxonomies in Plone!
url: https://pypi.org/project/collective.taxonomy/
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.taxonomy-3.1.4-1.src.rpm
checksum_type: sha256
description:
  |CI|
  Create, edit and use hierarchical taxonomies in `Plone`_.
  This add-on provides support for hierarchical taxonomies in multiple
  languages, letting users easily associate existing content with terms
  from one or more taxonomies.
      `Taxonomy <https://en.wikipedia.org/wiki/Taxonomy>`_ is the
      "discipline of defining groups [...] on the basis of shared
      characteristics and giving names to those groups. Each group is
      given a rank and groups of a given rank can be aggregated to form
      a super group of higher rank and thus create a hierarchical
      classification".
  Here's an example of the "taxonomic kingdoms of life"::
      Living Organisms
      Living Organisms -> Eukaryotic
      Living Organisms -> Eukaryotic -> Simple multicells or unicells
      Living Organisms -> Eukaryotic -> Multicellular
      Living Organisms -> Eukaryotic -> Multicellular -> Autotrophic
      Living Organisms -> Eukaryotic -> Multicellular -> ...
      Living Organisms -> Prokaryotic
      Living Organisms -> Prokaryotic -> Archaebacteria
      Living Organisms -> Prokaryotic -> Eubacteria
      Living Organisms -> Prokaryotic -> Eubacteria -> ...
  Taxonomies can be quite large, sometimes in the tens of thousands
  (10,000+). And in sites with multiple languages, each title – or
  *caption* – must appear in translation.
  Note that the selection of a term in the hierarchy implies the
  selection of all its parents. In the example above this means that if
  "Eubacteria" is selected, then also "Prokaryotic" and "Living
  Organisms" will be.


pkgId: 8065c70dc49d6cb317c1ecca624fe95252460f026f98ca3e7171325e3e5afd26
name: python-collective.transmogrifier
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: A configurable pipeline, aimed at transforming content for import and export
url: https://github.com/collective/collective.transmogrifier
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.transmogrifier-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Transmogrifier provides support for building pipelines that turn one thing
  into another. Specifically, transmogrifier pipelines are used to convert and
  import legacy content into a Plone site. It provides the tools to construct
  pipelines from multiple sections, where each section processes the data
  flowing through the pipe.
  A "transmogrifier pipeline" refers to a description of a set of pipe sections,
  slotted together in a set order. The stated goal is for these sections to
  transform data and ultimately add content to a Plone site based on this data.
  Sections deal with tasks such as sourcing the data (from textfiles, databases,
  etc.) and characterset conversion, through to determining portal type,
  location and workflow state.
  Note that a transmogrifier pipeline can be used to process any number of
  things, and is not specific to Plone content import. However, it's original
  intent is to provide a pluggable way to import legacy content.


pkgId: 9a2ca767eb0fb4b8d1433d15c342dc61f4d11d77af687aeb7a7074504b7e0c1f
name: python-collective.venue
arch: src
version: 4.1
epoch: 0
release: 1
summary: Dexterity venue type for use with events.
url: https://github.com/collective/collective.venue
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.venue-4.1-1.src.rpm
checksum_type: sha256
description:
  This package provides an Dexterity Venue type with geolocation support for use with events or any other location specific content.


pkgId: 99ffd406344819567576b2cf2c14201ab860528cb63d08a31e12d95fcaaf50de
name: python-collective.xmltestreport
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: A test runner which can output an XML report compatible with JUnit and Jenkins
url: https://pypi.org/project/collective.xmltestreport
rpm_license: ZPL 2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.xmltestreport-2.0.2-1.src.rpm
checksum_type: sha256
description:
  This package provides an extension to the test runner to the one that ships
  with ``zope.testrunner``, as well as a buildout recipe based on
  ``zc.recipe.testrunner`` to install a test script for this test runner.
  The test runner is identical to the one in ``zope.testrunner``, but it is
  capable of writing test reports in the XML format output by JUnit/Ant. This
  allows the test results to be analysed by tools such as the Jenkins continuous
  integration server.


pkgId: af020ff37c0b7a3ad39d11b323d22fd6283ed1bf753f054fcf2eb2c7416f265f
name: python-collective.z3cform.datagridfield
arch: src
version: 3.0.3
epoch: 0
release: 1
summary: Fields with repeatable data grid (table-like) for z3.cform
url: https://github.com/collective/collective.z3cform.datagridfield
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collective.z3cform.datagridfield-3.0.3-1.src.rpm
checksum_type: sha256
description:
  Provides a field with a datagrid (table), where each row is a sub form.
  It is a `z3c.form <https://z3cform.readthedocs.io/en/latest/>`_ implementation of the `Products.DataGridField <http://plone.org/products/datagridfield>`_ .
  This product was developed for use with Plone and Dexterity.


pkgId: 4307d025a2f715f1ef1309b677d030c88ae164230f6836d4facc6135eb0fd9ea
name: python-college-board-scraper
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: A package to scrape the CollegeBoard SAT Suite Question Bank webpage.
url: https://github.com/VG-Fish/College-Board/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-college-board-scraper-0.3.3-1.src.rpm
checksum_type: sha256
description:
  - This is the website being scraped: [CollegeBoard SAT Suite Question Bank](https://satsuitequestionbank.collegeboard.org/digital/search)
  - [PyPi Page](https://pypi.org/project/college-board-scraper/)
  - Only the Firefox browser is supported. You must have geckodriver installed. This will be changed in the future.
  - Very long questions or answers aren't fully captured. This will be changed in the future.
  - The scraper is also quite slow, the performance will be improved in future releases.
  - More convenience functions will be added to the `Scraper` class along with ways to change some parameters after they've already been initialized.



  An example of creating the CollegeBoard SAT Suite Question Bank webpage scraper:
  ```python
  from college_board_scraper.core import Scraper
  scraper = Scraper(
      assessment="SAT",
      test="Math",
      options=Scraper.valid_math_options,
      difficulties={"Easy", "Medium", "Hard"},
      skills=Scraper.valid_math_skills,
      exclude_active_questions=True
  )
  ```
  What this does is create a scraper that will select the Easy, Medium, and Hard questions that fall under all of the math skills and options of Math portion of
  the SAT test (which is all of questions). Additionally, it will exclude any questions present in the practice digital SAT tests released by CollegeBoard.

  Next, to get the questions, call the `scraper.scrape()` method. The arguments are `amount`, which is the amount of questions that should be scraped from the
  beginning, or (this is an optional parameter; default is False) supply the `save_images` parameter, which will save the question and answer pngs to their respective directories.
  If `save_images` is False,
  `scraper.scrape()` will return a List of the question number and the question and answer pngs (type is `List[Tuple[int, Tuple[PngImageFile, PngImageFile]]]`).


  Here are some valid arguments for the Scraper Class when you initialize it.
  ```python
  valid_assessments: Tuple[str] = ("SAT", "PSAT/NMSQT & PSAT 10", "PSAT 8/9")
  valid_tests: Tuple[str] = ("Reading and Writing", "Math")

  valid_reading_and_writing_options: Set[str] = {"Information and Ideas", "Craft and Structure", "Expression of Ideas", "Standard English Conventions"}
  valid_math_options: Set[str] = {"Algebra", "Advanced Math", "Problem-Solving and Data Analysis", "Geometry and Trigonometry"}


  valid_difficulty_options: Set[str] = {"Easy", "Medium", "Hard"}

  valid_reading_and_writing_skills: Dict[str, Set[str]] = {
      "Information and Ideas": {"Central Ideas and Details", "Inferences", "Command of Evidence"},
      "Craft and Structure": {"Words in Context", "Text Structure and Purpose", "Cross-Text Connections"},
      "Expression of Ideas": {"Rhetorical Synthesis", "Transitions"},
      "Standard English Conventions": {"Boundaries", "Form, Structure, and Sense"}
  }
  valid_math_skills: Dict[str, Set[str]] = {
      "Algebra": {
          "Linear equations in one variable", "Linear functions", "Linear equations in two variables",
          "Systems of two linear equations in two variables", "Linear inequalities in one or two variables"
      },
      "Advanced Math": {
          "Nonlinear functions", "Nonlinear equations in one variable and systems of equations in two variables", "Equivalent expressions"
      },
      "Problem-Solving and Data Analysis": {
          "Ratios, rates, proportional relationships, and units", "Percentages",
          "One-variable data: Distributions and measures of center and spread", "Two-variable data: Models and scatterplots",
          "Probability and conditional probability", "Inference from sample statistics and margin of error",
          "Evaluating statistical claims: Observational studies and experiments"
      },
      "Geometry and Trigonometry": {"Area and volume", "Lines, angles, and triangles", "Right triangles and trigonometry", "Circles"}
  }
  ```
  You can use all of these using `Scraper.[PARAMETER]`. For the arguments that are type `Set` or `Dict`, you can supply any valid subset to the argument. For example, for the
  `valid_math_options` argument, you may supply `{"Advanced Math", "Problem-Solving and Data Analysis", "Algebra"}`. Attempting to supply invalid arguments will result in a `ValueError()`.
  Look at the error message to see what you have done wrong. For the arguments of type `Tuple`, you must choose one of the values.
  If there are any bugs, create a Github Issue detailing your error, and how you caused it.


  To declare the ScraperAmount Helper Class, do: `from college_board_scraper.helpers import ScraperAmount`.
  If you want to scrape all of the questions, you can supply the `ScraperAmount.ALL` to the amount parameter. In the future, you can use `ScraperAmount.RANDOM` to get a random amount of random questions.

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


pkgId: 3c1cfae071e03e3ffd4adbbc22eec2b3adba5038b93eede62a4210251363d31e
name: python-collektions
arch: src
version: 1.0.3
epoch: 0
release: 1
url: https://pypi.org/project/collektions/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collektions-1.0.3-1.src.rpm
checksum_type: sha256
summary:
  A collection of Python functions on iterables and collections inspired by the Kotlin collections API.

description:
  A collection of Python functions on iterables and collections inspired by the
  [Kotlin collections standard library API](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/#functions).

  For the curious, the name is a reference to the Kotlin collections API in two ways:
  1. The name collections, which is obvious
  2. The intentional misspelling with a K since `kt` is the file extension used for Kotlin source
     files.


pkgId: ae8d6f0c1d4f8fcd358c8397631c07d82348adfa91ee3c8b0f6da5a476361097
name: python-collibra-core
arch: src
version: 2.0.0.post7
epoch: 0
release: 1
summary: Collibra Data Governance Center Core API
url: https://pypi.org/project/collibra-core/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collibra-core-2.0.0.post7-1.src.rpm
checksum_type: sha256
description:
      &lt;p&gt;The Core REST API allows you to create your own integrations with Collibra Data Governance Center.&lt;/p&gt;&lt;p&gt;&lt;i&gt;Create custom applications to help users get access to the right data.&lt;/i&gt;&lt;/p&gt;  # noqa: E501


pkgId: d9d5bfaf78f1073d6c1bf534eec2ec50e1cdae028e3c4888dcbb85ec87a0c424
name: python-collider-check
arch: src
version: 0.2.8
epoch: 0
release: 1
url: https://github.com/ColasDroin/collider_check
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collider-check-0.2.8-1.src.rpm
checksum_type: sha256
summary:
  A small package that provides functions to check the observables in a collider, using a collider built with Xsuite.

description:
  A small package that provides functions to check the observables in a collider, using a collider built with [Xsuite](https://github.com/xsuite) as input (must be a json file). Very useful for debugging purposes before/after tracking, and used as a backend of the [simulation dashboard](https://github.com/ColasDroin/simulation-dashboard).



  The package is available from PyPI, so you can install it with pip:

  ```bash
  pip install collider-check
  ```



  You can import the package in your python script and load a collider with:

  ```python
  import collider_check
  check = collider_check.from_json("path/to/collider.json")
  ```

  To get a quick summary of the collider observables, use:

  ```python
  check.output_check_as_str('output.txt')
  ```

rpm_license:
  MIT License  Copyright (c) [2024] [Colas Droin]  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: 5dc48376709a04f41a6c5869a5c1fdfdf26b2af359bd5af12388403f16ecff69
name: python-collider-check
arch: src
version: 0.3.2
epoch: 0
release: 1
url: https://github.com/ColasDroin/collider_check
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collider-check-0.3.2-1.src.rpm
checksum_type: sha256
summary:
  A small package that provides functions to check the observables in a collider, using a collider built with Xsuite.

description:
  <p align="center">
      <img src="https://img.shields.io/pypi/v/collider-check" alt="PyPI - Version">
      <img src="https://img.shields.io/github/commits-since/ColasDroin/collider_check/latest" alt="GitHub commits since latest release">
      <img src="https://img.shields.io/github/actions/workflow/status/ColasDroin/collider_check/tests.yaml?label=Tests" alt="GitHub Actions Workflow Status">
      <img src="https://img.shields.io/github/license/ColasDroin/collider_check" alt="GitHub License">
      <img src="https://img.shields.io/pypi/pyversions/collider-check" alt="PyPI - Python Version">
      <img src="https://img.shields.io/badge/Built%20with%20uv-8A2BE2">
  </p>



  A small package that provides functions to check the observables in a collider, using a collider built with [Xsuite](https://github.com/xsuite) as input (must be a json file). Very useful for debugging purposes before/after tracking, and used as a backend of the [simulation dashboard](https://github.com/ColasDroin/simulation-dashboard).



  The package is available from PyPI, so you can install it with pip:

  ```bash
  pip install collider-check
  ```



  You can import the package in your python script and load a collider with:

  ```python
  import collider_check
  check = collider_check.from_json("path/to/collider.json")
  ```

  To get a quick summary of the collider observables, use:

  ```python
  check.output_check_as_str('output.txt')
  ```



  This package is distributed under the MIT License. See [LICENSE](LICENSE) for more information.

rpm_license:
  MIT License  Copyright (c) [2024] [Colas Droin]  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: 540ef1a1a8b70ccd7fccac51c0196c5dafca00a315caa890be736d0b711a469f
name: python-collider-dashboard
arch: src
version: 1.4.5.0
epoch: 0
release: 1
url: https://github.com/ColasDroin/simulation-dashboard
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collider-dashboard-1.4.5.0-1.src.rpm
checksum_type: sha256
summary:
  A Dash application to visualize the observables and parameters of a collider built and configured with Xsuite.

description:
  <p align="center">
      <a href="https://opensource.org/license/mit/">
      <img src="https://badgen.net/static/license/MIT/blue">
      </a>
      <a href="https://python-poetry.org/">
      <img src="https://badgen.net/static/Package%20Manager/Poetry/orange">
      </a>
      <a href="https://dash.plotly.com/">
      <img src="https://badgen.net/static/Dash/2.14.1/green">
      </a>
      <a href="https://black.readthedocs.io/en/stable/">
      <img src="https://badgen.net/static/Code%20style/Black/black">
      </a>
      <img src="https://badgen.net/github/release/colasdroin/collider-dashboard">
      <img src="https://badgen.net/github/commits/colasdroin/collider-dashboard">
  </p>


  A Dash application to visualize the observables and parameters of a collider built and configured with Xsuite.



  The dashboard can be installed from PyPI with pip:

  ```bash
  pip install collider-dashboard
  ```

  This will install the required packages and build the application. If you haven't done it already, it is recommended to prebuild the Xsuite kernel to gain some computation time:

  ```bash
  xsuite-prebuild regenerate
  ```



  For personal usage, the simplest way to use the dashboard is to run the package as a development server from the command line, providing a few arguments:

  ```bash
  python -m collider_dashboard --collider-path path_to_collider.json --filling-path path_to_scheme.json --port 8080 --force-reload --ignore-footprint --full-twiss --type-particles proton --debug
  ```

  - `--collider-path`, or `-c`, sets the path to the collider configuration file. Default value to the path of a dummy collider used for testing.
  - `--filling-path`, or `-f`, sets the path to the filling scheme, instead of using the one in the collider configuration file. Optional.
  - `--port`, or `-p`, sets the port on which the dashboard will be deployed. Default value to `8080``.
  - `--force-reload`, or `-r`,  sets a boolean indicating whether the collider dashboard data should be reloaded if already existing. Optional.
  - `--ignore-footprint`, or `-i`, sets a boolean indicating whether the footprint should be ignored to gain computation time. Optional.
  - `--full-twiss`, or `-t`, sets a boolean indicating whether the Twiss/Survey tables should be computed fully (not removing duplicates and entry/exit elements), at the expense of computation time. Optional.
  - `--type-particles`, or `-a`, sets the type of particles to be used for the collider. Default value to `proton`.
  - `--debug`, or `-d`, sets a boolean indicating whether the dashboard should be run in debug mode. Optional.

  After computing some temporary variables (this may take a while the first time), this will deploy a local server and open the dashboard in a browser window.

  Alternatively, one can import the dashboard as a module and use it in a custom script:

  ```python


  from collider_dashboard import build_app
  app, server = build_app(path_to_collider.json,
                          path_scheme=path_to_scheme.json,
                          port=8080,
                          force_reload=False,
                          ignore_footprint=False,
                          debug = False,
                          simplify_tw=True
                          type_particles='proton'
                  )
  ```

  The dashboard can then be deployed e.g. with gunicorn:

  ```bash
  gunicorn my-awesome-dashboard:server -b :8080
  ```

  Note that, as the dashboard deals with global variables, it is not thread-safe. It is therefore recommended to run it with a single worker (it's the case by default).


pkgId: e240eb0df8db671bbfb10b1541527c30bd3a1e2a8a7decb45bb1f1f9b98413b5
name: python-collider-dashboard
arch: src
version: 1.5.0.0
epoch: 0
release: 1
url: https://github.com/ColasDroin/simulation-dashboard
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collider-dashboard-1.5.0.0-1.src.rpm
checksum_type: sha256
summary:
  A Dash application to visualize the observables and parameters of a collider built and configured with Xsuite.

description:
  <p align="center">
      <a href="https://opensource.org/license/mit/">
      <img src="https://badgen.net/static/license/MIT/blue">
      </a>
      <a href="https://python-poetry.org/">
      <img src="https://badgen.net/static/Package%20Manager/Poetry/orange">
      </a>
      <a href="https://dash.plotly.com/">
      <img src="https://badgen.net/static/Dash/2.14.1/green">
      </a>
      <a href="https://black.readthedocs.io/en/stable/">
      <img src="https://badgen.net/static/Code%20style/Black/black">
      </a>
      <img src="https://badgen.net/github/release/colasdroin/collider-dashboard">
      <img src="https://badgen.net/github/commits/colasdroin/collider-dashboard">
  </p>


  A Dash application to visualize the observables and parameters of a collider built and configured with Xsuite.



  The dashboard can be installed from PyPI with pip:

  ```bash
  pip install collider-dashboard
  ```

  This will install the required packages and build the application. If you haven't done it already, it is recommended to prebuild the Xsuite kernel to gain some computation time:

  ```bash
  xsuite-prebuild regenerate
  ```



  For personal usage, the simplest way to use the dashboard is to run the package as a development server from the command line, providing a few arguments:

  ```bash
  python -m collider_dashboard --collider-path path_to_collider.json --filling-path path_to_scheme.json --port 8080 --force-reload --ignore-footprint --full-twiss --type-particles proton --debug
  ```

  - `--collider-path`, or `-c`, sets the path to the collider configuration file. Default value to the path of a dummy collider used for testing.
  - `--filling-path`, or `-f`, sets the path to the filling scheme, instead of using the one in the collider configuration file. Optional.
  - `--port`, or `-p`, sets the port on which the dashboard will be deployed. Default value to `8080``.
  - `--force-reload`, or `-r`,  sets a boolean indicating whether the collider dashboard data should be reloaded if already existing. Optional.
  - `--ignore-footprint`, or `-i`, sets a boolean indicating whether the footprint should be ignored to gain computation time. Optional.
  - `--full-twiss`, or `-t`, sets a boolean indicating whether the Twiss/Survey tables should be computed fully (not removing duplicates and entry/exit elements), at the expense of computation time. Optional.
  - `--type-particles`, or `-a`, sets the type of particles to be used for the collider. Default value is inferred from the config is present in the metadata of the collider. Otherwise, must be provided as "proton" or "lead".
  - `--debug`, or `-d`, sets a boolean indicating whether the dashboard should be run in debug mode. Optional.

  After computing some temporary variables (this may take a while the first time), this will deploy a local server and open the dashboard in a browser window.

  Alternatively, one can import the dashboard as a module and use it in a custom script:

  ```python


  from collider_dashboard import build_app
  app, server = build_app(path_to_collider.json,
                          path_scheme=path_to_scheme.json,
                          port=8080,
                          force_reload=False,
                          ignore_footprint=False,
                          debug = False,
                          simplify_tw=True
                          type_particles='proton'
                  )
  ```

  The dashboard can then be deployed, for instance, with gunicorn:

  ```bash
  gunicorn my-awesome-dashboard:server -b :8080
  ```

  Note that, as the dashboard deals with global variables, it is not thread-safe. It is therefore recommended to run it with a single worker (it's the case by default).



  The dashboard will work with or without a configuration file embedded as metadata in the collider json file. If the metadata is present, the dashboard will use it to infer the type of particles, the filling scheme path, etc. Otherwise, some data and tabs might not be available.


pkgId: e2d9c8f997e200f40685b4e9ae0931a504f6e4c8614ac215bdf78bda6353d019
name: python-collidoscope
arch: src
version: 0.6.5
epoch: 0
release: 1
summary: Brute force detection of glyph collisions
url: https://github.com/simoncozens/collidoscope
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-collidoscope-0.6.5-1.src.rpm
checksum_type: sha256
description:
  `collidoscope` reports on situations where paths overlap in a shaped
  piece of text. For example, the sequence "ؼجب" might cause a collision like so:

  ![](sample-collision.png)

  This software tries every combination of glyphs within a specified Unicode range and up to a specified length of string and outputs a report of all situations where the glyphs collide. It has a number of collision tests:

  * Paths in non-adjacent glyphs are never allowed to collide.
  * If the *cursive* test is turned on, then paths with a cursive attachment anchor are allowed to overlap with paths in an adjacent glyph which also contain a cursive attachment anchor, but are *not* allowed to overlap with a path *without* a cursive attachment anchor.
  * If the *area* test is turned on, then paths in adjacent glyphs may collide so long as the area of overlap does not exceed a given percentage of the smallest path's area. i.e. if the area percentage is set to 25%, then two strokes may *connect*, because the overlap is likely to be quite small compared to the size of the paths involved. But if a stroke significantly overlaps a nukta, it will be reported as a collision. (Of course, this will not detect strokes which merely graze a nukta.)

  Depending on the length of the string and the number of glyphs tested, this may take a *very* long time.



  To use it:

      python3 -m collidoscope -r 0620-064A yourfont.otf

  This creates a collision report on `report.html` for all sequences of three characters within the range 0x620 to 0x64A.

      python3 -m collidoscope -r 0620-064A,0679-06D3 -area 10 yourfont.otf

  This creates a collision report on `report.html` for all sequences of three characters within the range 0x620 to 0x64A and also 0x679 to 0x6D3, and turns on the area test at a tolerance of 10% of the area of the smallest path involved in collision.

      python3 -m collidoscope -c 5 --cursive yourfont.otf

  This tests for non-adjacent glyphs and collisions not involving cursive connection for *all combinations of glyphs in your font* with a five-character string. This may take a number of years to compute.

      python3 -m collidoscope -c 2 -r 0620-064A --area 5 yourfont.otf

  This just runs an area test for two-character sequences across the basic Arabic range.



  ```python
  class Collidoscope()
  ```

  Detect collisions between font glyphs

  <a name="collidoscope.Collidoscope.__init__"></a>


  ```python
   | __init__(fontfilename, rules, direction="LTR", ttFont=None)
  ```

  Create a collision detector.

  The rules dictionary may contain the following entries:

  * faraway (boolean): If true, non-adjacent base glyphs are tested for
  overlap. Mark glyphs are ignored. All collisions are reported.
  * marks (boolean): If true, collisions between all pairs of marks in
  the string are reported.
  * bases (boolean): If *false*, collisions between all pairs of bases in
  the string are *ignored*.
  * cursive (boolean): If true, adjacent glyphs are tested for overlap.
  Paths containing cursive anchors are allowed to overlap, but
  collisions between other paths are reported.
  * area (float): If provided, adjacent glyphs are tested for overlap.
  Collisions are reported if the intersection area is greater than
  the given proportion of the smallest path. (i.e. where cursive
  connection anchors are not used in an Arabic font, you may wish
  to ignore collisions if the overlaid area is less than 5% of the
  smallest path, because this is likely to be the connection point
  between the glyphs. But collisions affecting more than 5% of the
  glyph will be reported.)

  **Arguments**:

  - `fontfilename` - file name of font.
  - `rules` - dictionary of collision rules.
  - `ttFont` - fontTools object (loaded from file if not given).
  - `direction` - "LTR" or "RTL"

  <a name="collidoscope.Collidoscope.get_glyphs"></a>


  ```python
   | get_glyphs(text)
  ```

  Returns an list of dictionaries representing a shaped string.

  This is the first step in collision detection; the dictionaries
  returned can be fed to ``draw_overlaps`` and ``has_collisions``.

  <a name="collidoscope.Collidoscope.draw_overlaps"></a>


  ```python
   | draw_overlaps(glyphs, collisions, attribs="")
  ```

  Return an SVG string displaying the collisions.

  **Arguments**:

  - `glyphs` - A list of glyphs dictionaries.
  - `collisions` - A list of Collision objects.
  - `attribs` - String of attributes added to SVG header.

  <a name="collidoscope.Collidoscope.has_collisions"></a>


  ```python
   | has_collisions(glyphs_in)
  ```

  Run the collision detection algorithm according to the rules provided.

  Note that this does not find *all* overlaps, but returns as soon
  as some collisions are found.

  **Arguments**:

  - `glyphs` - A list of glyph dictionaries returned by ``get_glyphs``.

  - `Returns` - A list of Collision objects.




  This requires some Python modules to be installed. You can install them like so:

      pip3 install -r example-requirements.txt


pkgId: 3385334d7fff92c3ebb57c5f883e5a6a267b66c26bf00afb5ad1c7a174b34541
name: python-colmena
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: colmena: Intelligent Steerable Pipelines on HPC
url: https://pypi.org/project/colmena/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colmena-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/exalearn/colmena/actions/workflows/CI.yml/badge.svg)](https://github.com/exalearn/colmena/actions/workflows/CI.yml)
  [![Documentation Status](https://readthedocs.org/projects/colmena/badge/?version=latest)](https://colmena.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/colmena.svg)](https://badge.fury.io/py/colmena)
  [![Coverage Status](https://coveralls.io/repos/github/exalearn/colmena/badge.svg?branch=master)](https://coveralls.io/github/exalearn/colmena?branch=master)

  Colmena simplifies building autonomous applications that steer large campaigns of simulations on supercomputers.

  Such "high-throughput" campaigns were, historically,
  guided by humans identifying the which tasks to run next &mdash; a time-consuming process with a high latency between "new data" and "decisions."

  Colmena was created to build applications which augment or replace human steering with Artificial Intelligence (AI).



  Colmena is available [via PyPI](): `pip install colmena`

  Consult our [Installation Guide](https://colmena.readthedocs.io/en/latest/installation.html) for further details.



  Colmena applications describe a computational campaign in two components: a "Thinker" that picks computations
  and a "Doer" which executes them.

  Thinkers encode the logic for how to run new calculations as "agents."
  Complex strategies are simple to express when you decompose them into simple steps.
  For example, a distributed optimizer:

  ```python
  from random import random

  from colmena.thinker import BaseThinker, result_processor, task_submitter, ResourceCounter
  from colmena.queue import PipeQueues
  from colmena.models import Result


  queues = PipeQueues()


  class Thinker(BaseThinker):

      def __init__(self, queues, num_workers: int, num_guesses=100):
          super().__init__(queues, ResourceCounter(num_workers))
          self.best_result = None
          self.answer = -10  # A (bad) starting guess
          self.num_guesses = num_guesses

      @task_submitter()
      def submit_task(self):
          """Submit a new guess close to the current best whenever a node is free"""
          self.queues.send_inputs(self.answer - 1 + 2 * random(), method='simulate')

      @result_processor()
      def store_result(self, result: Result):
          """Update best guess whenever a simulation finishes"""
          assert result.success, result.failure_info
          
          if self.best_result is None or result.value > self.best_result:
              self.answer = result.args[0]
              self.best_result = result.value
          self.rec.release()  # Mark that a node is now free

          
          self.num_guesses -= 1
          if self.num_guesses <= 0:
              self.done.set()


  thinker = Thinker(queues, 8)
  ```

  Doers describe the types of computations and available compute resources.
  Colmena provides Task Servers backed by several workflow engines, such as those from the [ExaWorks project](https://exaworks.org/).
  Building one using Parsl requires only that your computations are expressed as Python functions:

  ```python
  from parsl.configs.htex_local import config  # Configuration to run locally
  from colmena.task_server.parsl import ParslTaskServer


  def simulate(x: float) -> float:
      return - x ** 2 + 4


  doer = ParslTaskServer([simulate], queues, config)
  ```

  Once these are defined, launching the application involves starting both

  ```python


  doer.start()
  thinker.start()


  thinker.join()
  queues.send_kill_signal()  # Stop the doer


  print(f'Answer: f({thinker.answer:.2f}) = {thinker.best_result:.2f}')
  ```



  Visit the [Quickstart](https://colmena.readthedocs.io/en/latest/quickstart.html) to learn to build a full application.



  See the [`demo_apps`](./demo_apps) to see a variety of ways to use Colmena.



  Our [Read-the-Docs](https://colmena.readthedocs.io/en/latest/) provides the most up-to-date information about Colmena.

  You can also learn more about Colmena in the papers we published about it:

  - Ward et al. "Colmena: Scalable Machine-Learning-Based Steering of Ensemble Simulations for High Performance Computing".
    _2021 IEEE/ACM Workshop on Machine Learning in High Performance Computing Environments (MLHPC)_
    [[doi](https://doi.org/10.1109/MLHPC54614.2021.00007)] [[ArXiv](https://arxiv.org/abs/2110.02827)]
    [[slides](https://www.researchgate.net/publication/357777568)]
    [[YouTube](https://youtu.be/-3KnbJcm-tQ)]



  This project was supported in part by the Exascale Computing Project (17-SC-20-SC) of the U.S. Department of Energy (DOE) and by DOE’s Advanced Scientific Research Office (ASCR) under contract DE-AC02-06CH11357.

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 2020, Argonne National Laboratory  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: a43984134accf35d29338af39f9d5abc6e7f0a7cf4d29da37e0b3ca4d9badb60
name: python-coloc
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: the COLOC method by Giambartolomei et al.
url: https://gitlab.com/aaylward/coloc
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coloc-0.4.2-1.src.rpm
checksum_type: sha256
description:
  An implementation of the COLOC method for colocalization of GWAS and/or eQTL
  signals by [Giambartolomei et al](https://journals.plos.org/plosgenetics/article?id=10.1371/journal.pgen.1004383).



  ```sh
  pip3 install coloc
  ```
  or
  ```sh
  pip3 install --user coloc
  ```



  ```python
  from coloc import coloc, print_coloc_result
  help(coloc)
  print_coloc_result('not colocalized', *coloc([1, 4, 9], [9, 4, 1]))
  ```
  ```
  not colocalized

  PP0: [|||||               ] [ 0.26540194014704316 ]
  PP1: [||||                ] [ 0.21657860877712054 ]
  PP2: [||||                ] [ 0.21657860877712054 ]
  PP3: [|||                 ] [ 0.17661198683565493 ]
  PP4: [||                  ] [ 0.12482885546306076 ]
  ```
  ```python
  print_coloc_result('colocalized', *coloc([1, 4, 9], [1, 4, 9]))
  ```
  ```
  colocalized

  PP0: [                    ] [ 0.0015168270421050444 ]
  PP1: [                    ] [ 0.001237791593959775 ]
  PP2: [                    ] [ 0.001237791593959775 ]
  PP3: [                    ] [ 1.4094001056824932e-05 ]
  PP4: [||||||||||||||||||| ] [ 0.9959934957689188 ]
  ```


pkgId: 0c33575c64e9cd110fad5f55efc01a903cc0b30fa5e97ccc0a726dc456e083e6
name: python-colomoto-jupyter
arch: src
version: 0.8.10
epoch: 0
release: 1
summary: CoLoMoTo helper functions for Juypter integration
url: https://github.com/colomoto/colomoto-jupyter
rpm_license: LGPL v3+/CeCILL-C
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colomoto-jupyter-0.8.10-1.src.rpm
checksum_type: sha256
description:
  Provides helper functions for integration in the CoLoMoTo Jupyter notebook.

  See https://github.com/colomoto/colomoto-jupyter


pkgId: e94d5fa33847ea15c69c1e315c6630c21a114994a255def6b705125c28fba444
name: python-colony
arch: src
version: 1.4.24
epoch: 0
release: 1
summary: Colony Framework
url: http://getcolony.com
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colony-1.4.24-1.src.rpm
checksum_type: sha256
description:
  The Colony Framework is an open-source plugin framework specification. Its implementations provide a component model at runtime, enabling plugins to be installed, started, stopped, updated, and uninstalled without having to stop the application container. The framework heavily relies on the Inversion of Control principle, making it easier for application components to discover and interact with each other.

  Colony's goal is to simplify the process of creating modular applications by offering a unified, simplified model for component development. This can have practical applications in a variety of fields, ranging from modular enterprise software to application mashing.





  * Install Colony using `pip install colony`
  * Run the command `RUN_MODE=devel colony`



  * Start and activate the environment using `virtualenv .venv && source .venv/bin/activate`
  * Install Colony in the system using `pip install colony`
  * Deploy the console package using `cpm install console_interface`
  * Run your new colony using the command `RUN_MODE=devel colony`



  * Create a new directory to serve as the base for the build `mkdir colony && cd colony`
  * Retrieve the `Dockerfile` from the repo using `wget https://github.com/hivesolutions/colony/raw/master/assets/docker/Dockerfile`
  * Create the new docker image using `docker build --tag self/colony .`
  * Execute colony with `docker run -e RUN_MODE=devel -i -t self/colony`

  To actually do something useful, look into [How to Establish your Colony in 3 Easy Steps](http://getcolony.com/docs/colony/documentation_how_to_establish_your_colony_in_3_easy_steps.html)





  * Set `PYTHONPATH` to the `colony/src` path so that the Python source files may be included
  * Set `PATH` to the `colony/scripts/pypi` to use the provided base scripts



  * Installation via pip: `pip install colony`



  | Name                 | Type   | Default       | Description                                                                           |
  | -------------------- | ------ | ------------- | ------------------------------------------------------------------------------------- |
  | **RUN_MODE**         | `str`  | `development` | The mode in which the Colony will be running.                                         |
  | **LOGGING_LOGSTASH** | `bool` | `False`       | If the [Logstash](https://www.elastic.co/logstash) logging adapter should be enabled. |



  Most of the colony operations are run through the `cpm` command:

  * `cpm clone <target>` - clones the base colony instance into the target directory (new project)
  * `cpm cleanup <target>` - cleans the current instance, removing extra files
  * `cpm pack <target>` - packs the current instance into a .zip file
  * `cpm generate [target] <...>` - generates a .json descriptor file for the provided Python file and then runs
  the build operation for the generated .json file, effectively building the package item
  * `cpm build [descriptor] <...>` - builds the target .json descriptor file into a package file
  * `cpm deploy [package]` - deploys the target .cbx file into the current instance
  * `cpm info [package]` - prints information about the package to the standard output
  * `cpm install [name] <...>` - installs the package with the provided name from the remote repositories
  * `cpm upgrade` - updates the complete set of packages deployed in the instance
  * `cpm require [path] <...>` - installs the complete set of packages defined in the requirements file
  * `cpm upload [target] <repo>` - generates a package for the provided path and then uploads it to the currently
  configured primary repository or another repository if defined



  To run the complete set of available tests for the deployment, use either `colony test`
  or `MODE=test colony` and Colony Manager will boot directly to unit testing and exit in error in
  case at least one test fails.



  * Runtime modularity.
  * No restart is required for deploying new plugins or updating or reconfiguring existing ones.
  * Simplified component model (easy to create a plugin, even easier to combine existing ones).
  * Capabilities: simple extension points that allow your plugins to take advantage of future plugins that adhere to the capability API.
  * Dependencies: simplified dependency management, declare the id of the plugin your plugin needs to function, and the plugin manager
  will ensure your plugin only gets loaded when the conditions are met.
  * Most importantly, runs [Colony Plugins](https://github.com/hivesolutions/colony_plugins).

  And remember, this is just the base runtime. To understand what you can do with Colony,
  browse the [Colony Plugins repository](https://github.com/hivesolutions/colony_plugins).



  Although Colony is still in an early stage, we're welcoming help for all kinds of work.
  The best ways to get involved:

  1. Join the [mailing list](http://groups.google.com/group/colony-users).
  2. Send pull requests for bug fixes or new features and improvements.
  3. Help make the [docs](http://getcolony.com/docs/colony/) better.



  To find the Python native extension required for some of the plugins, use the following sites:

  * Python Imaging Library (PIL) [link](https://pillow.readthedocs.io/).
  * Reportlab PDF Generator [link](http://www.reportlab.com/).
  * Unofficial Windows Binaries for Python Extension Packages [link](http://www.lfd.uci.edu/~gohlke/pythonlibs/).
  * MySQL driver for Python [link](http://sourceforge.net/projects/mysql-python/).



  * Colony Base Source: https://github.com/hivesolutions/colony
  * Colony Base Plugins Source: https://github.com/hivesolutions/colony_plugins
  * Web: http://getcolony.com
  * Docs: http://getcolony.com/docs/colony/
  * Mailing list: http://groups.google.com/group/colony-users
  * Twitter: http://twitter.com/colonyframework



  Colony is an open-source project currently licensed under the [Apache License, Version 2.0](http://www.apache.org/licenses/).



  [![Build Status](https://app.travis-ci.com/hivesolutions/colony.svg?branch=master)](https://travis-ci.com/github/hivesolutions/colony)
  [![Build Status GitHub](https://github.com/hivesolutions/colony/workflows/Main%20Workflow/badge.svg)](https://github.com/hivesolutions/colony/actions)
  [![Coverage Status](https://coveralls.io/repos/hivesolutions/colony/badge.svg?branch=master)](https://coveralls.io/r/hivesolutions/colony?branch=master)
  [![PyPi Status](https://img.shields.io/pypi/v/colony.svg)](https://pypi.python.org/pypi/colony)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://www.apache.org/licenses/)


pkgId: 2b752a8a919831f0393ecfbd408a870d7ce10096f7fb7cd4039b52c929e6eae9
name: python-colony-cli
arch: src
version: 1.3.0b0
epoch: 0
release: 1
summary: A command line interface for colony
url: https://www.quali.com/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-colony-cli-1.3.0b0-1.src.rpm
checksum_type: sha256
description:
  ![quali](quali.png)

  Colony CLI is a Command Line interface tool for CloudShell Colony.
  The main functionality this tool currently provides is validation of Colony Blueprints and launching of Sandbox environments from any branch in addition to testing local changes before committing them.

  When developing Blueprints for Colony, it can be very helpful to immediately check your work for errors.
  Let's assume you are currently working in *development* branch, and you also have a main branch which is connected
  to a Colony space. You would like to be sure that your latest local changes haven't broken anything before commiting to current branch and pushing to remote or before merging changes to main branch.
  This is where this tool might be handy for you. Instead of reconnecting Colony to your development branch in the UI or going with "merge and pray" you can
  use Colony CLI to validate your current Blueprints state and even launch Sandboxes.

  You can install Colony CLI with [pip](https://pip.pypa.io/en/stable/):
  `$ python -m pip install colony-cli`
  Or if you want to install it for your user:
  `$ python -m pip install --user colony-cli`

  In order to allow the CLI tool to authenticate with Colony you must provide several parameters:
  * *Token* The easiest way to generate a token is via the Colony UI. Navigate to *Settings (in your space) -> Integrations ->
  click “Connect” under any of the CI tools -> click “New Token”* to get an API token.
  * *Space* The space in the Colony to use which is mapped to the Git repo you are using
  * *Account* (optional) providing the account name (appearing as the subdomain in your Colony URL,
  e.g <https://YOURACCOUNT.cloudshellcolony.com>). This is not a mandatory value but will help generate easy links.
  The *Token*, *Space* and *Account* parameters can be provided via special command line flags (*--token*, *--space*,
  and *--account* respectively) but can be conveniently placed in a config file relative to your user folder,
  so they don't need to be provided each time.
  The config file can be easily created and managed using the interactive `colony configure` command.
  The CLI supports multiple profiles and we recommend setting up a default profile for ease of use. To use a non-default profile the _--profile_ command line flag needs to be used to specify the profile name.
  To add a new profile or update an existing one run ```colony configure set``` and follow the on-screen directions. First you will be able to choose the profile name. Hit enter to add/update the default profile or enter a custom profile name. If the profile exists it will be update and if it doesn't exist then a new profile will be configured.
  To see all profiles run ```colony configure list``` and the command will output a table of all the profiles that are currently configured. Example output:
  ```bash


pkgId: 09701e982c25d77ac8b373c5cbcce39e4fbaf43523119fee1b741fb941f17ab0
name: python-color-change-filter
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: Change color of image
url: https://github.com/senbonmatsu/color_changer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-color-change-filter-1.1.5-1.src.rpm
checksum_type: sha256
description:
  This code can apply a filter to change the selected color to any color.

  color_change_CUI(self, image_path,output_path,x,y,rgb)
  - image_path: str
  - output_path:str
  - x:int
  - y:int
  - rgb:list

  color_change_CUI changes the color of the specified pixel to an rgb color

  color_change_GUI(self, image_path,output_path)
  - image_path:str
  - output_path:str

  color_change_GUI selects a specified pixel by clicking on it. Also, rgb is selected from the color picker.


  color_change_GUI method

  ```
  from color_change_filter import *
  C = color_change_filter()
  C.color_change_GUI("IMG_3430.jpeg","output.jpg")

  ```

  1. input image
  <br>
  <img src="https://drive.google.com/uc?export=view&id=1_nwdDS7z2xN5Pv4276920SV-g-nFSiHd" width="200px">
  <br>

  2. select color from input image
  <br>
  <img src="https://drive.google.com/uc?export=view&id=1m5X2APSrvFFYXmA_c-vhM_IishERVuyR" width="200px">
  <br>

  3. select color from color picker
  <br>
  <img src="https://drive.google.com/uc?export=view&id=12mXDkKKTg0R-gP-eC_zIKIdwZOjJbZ8u" width="200px">
  <br>

  4. output image
  <br>
  <img src="https://drive.google.com/uc?export=view&id=1dbJIIte8C4Hjbzau6bGbh359qXX7ZiSu" width="200px">


pkgId: 8a1cca65e4cb2ca5581440326f3b0014536970398fd5259c0d7310c887eefbc6
name: python-color-it
arch: src
version: 2.1.3
epoch: 0
release: 1
summary: A cross-platform lightweight package for printing colors in the terminal.
url: https://github.com/CodeForeverAndEver/colorit
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-color-it-2.1.3-1.src.rpm
checksum_type: sha256
description:
  A simple library to add color to your output.

  Have you ever wanted to print Colors to the console? I certainly have. There comes a time when you realize it is a necessity. That's why I created ColorIt. ColorIt is a super simple way to print color to the console.


  Interally, the library creates custom ANSI sequences with RGB values. This means there are 16 million colors that can be used with `colorit`!


  To install `colorit`. Run `pip install color-it` on Windows, or `pip3 install color-it` on macOS and Linux, from there it can be imported with `import colorit`



  To use ColorIt:

  ```python
  from colorit import *


  init_colorit()


  print(color("This text is red", Colors.red))
  print(color("This text is orange", Colors.orange))
  print(color("This text is yellow", Colors.yellow))
  print(color("This text is green", Colors.green))
  print(color("This text is blue", Colors.blue))
  print(color("This text is purple", Colors.purple))
  print(color("This text is white", Colors.white))


  print(background("This text has a background that is red", Colors.red))
  print(background("This text has a background that is orange", Colors.orange))
  print(background("This text has a background that is yellow", Colors.yellow))
  print(background("This text has a background that is green", Colors.green))
  print(background("This text has a background that is blue", Colors.blue))
  print(background("This text has a background that is purple", Colors.purple))
  print(background("This text has a background that is white", Colors.white))


  print(color("This color has a custom grey text color", (150, 150, 150)))
  print(background("This color has a custom grey background", (150, 150, 150)))


  print(
      background(
          color("This text is blue with a white background", Colors.blue), Colors.white
      )
  )


  input()
  ```

  As output you get:

  ![demo](https://user-images.githubusercontent.com/55718659/88487218-1fbcf800-cf51-11ea-8a27-678407774a37.png)

  If you would like to try this for yoyr self, you can download `demo.py` and try it out.

  And that's it. That's really all there is to it.

  **Additional Note**: `init_colorit()` clears the console, so put this somewhere in your code before printing output.


  * Released the first version of ColorIt (v1.0.0)
  * Added a license


  Here is the link to my patreon page: https://www.patreon.com/supermazingcoder :D


pkgId: 72d3917c3d25f297d8777c89d642928ea0e1a582b56cab4e8dbd535244cb8314
name: python-color-ls
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Pure Python implementation of subset of ls command with colors and icons
url: https://gitlab.com/compilation-error/colorls
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-color-ls-2.2.1-1.src.rpm
checksum_type: sha256
description:
  Pure Python implementation of ls command with colors and icons. Inspired from [colorls](https://github.com/athityakumar/colorls).
  Requires [Nerd Fonts](https://github.com/ryanoasis/nerd-fonts/blob/master/readme.md) for icon/glyphs.

  __Note__: This is not optimized and runs an order of magnitude slower than native `ls`.



  This is intended to run as an executable and not a library, it is preferable to use a tool such as [pipx](https://github.com/pypa/pipx)

  `pipx install color-ls`

  To customize the colors or add / change icons, copy `config/colorls.toml` to either `$XDG_CONFIG_HOME/colorls/colorls.toml` or `~/.colorls.toml` and update as required.



  ```
  $ lx -h

  usage: lx [-h] [-1] [-a] [-B] [-d] [-f] [--sd] [--sf] [-F] [-i] [-I PATTERN]
            [-l] [-n] [-R] [-t [DEPTH]] [--version] [--si] [-U] [-H] [-x]
            ...

  Pure Python implementation of `ls` command. Only a subset of available
  arguments are implemented

  positional arguments:
    FILE                  List information about the FILE(s).

  options:
    -h, --help            show this help message and exit
    -1                    list items on individual lines
    -a, --all             do not ignore entries starting with .
    -B, --ignore-backups  do not list implied entries ending with ~
    -d, --directory       list directories themselves, not their contents
    -f, --file            list files only, not directories
    --sd, --sort-directories
                          list directories first
    --sf, --sort-files    list files first
    -F, --classify        append indicator (one of */=>@|) to entries
    -i, --inode           display inode number
    -I PATTERN, --ignore PATTERN
                          do not list implied entries matching shell PATTERN
    -l, --long            use a long listing format
    -n, --numeric-uid-gid
                          like -l, but list numeric user and group IDs
    -R, --recursive       list subdirectories recursively
    -t [DEPTH], --tree [DEPTH]
                          max tree depth
    --version             display current version number and exit
    --si                  display file size in SI units
    -U, --unsorted        do not sort; list entries in directory order
    -H, --header          do not display header
    -x                    do not display icons

  Feature Requests/Bugs should be reported at https://gitlab.com/compilation-
  error/colorls/-/issues
  ```





  ![lx](screenshots/lx.png)



  ![lx -x](screenshots/x.png)



  ![lx -f](screenshots/f.png)
  ![lx -d](screenshots/d.png)



  ![ls --sf](screenshots/sf.png)
  ![lx --sd](screenshots/sd.png)



  ![lx -l](screenshots/l.png)



  ![lx -t[=3]](screenshots/t.png)



  ![lx -I](screenshots/-i.png)



  ![lx --version](screenshots/v.png)



  - Python 3.10 or higher
  - Nerd Fonts



  GPLv3

rpm_license:
  Copyright (c) 2020 Romeet Chhabra  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) 2024  Romeet  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) 2024  Romeet This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: ee7618a9435bf52024d45cffd4697925ef768d0f553dd9fc8ca7835023cdc9c6
name: python-color-processing
arch: src
version: 0.5
epoch: 0
release: 1
summary: A package for fetching detailed color information
url: https://github.com/cop-discord/color_processing
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-color-processing-0.5-1.src.rpm
checksum_type: sha256
description:
  This package implements many methods for color fetching aswell as color name and information fetching
  This can all be super intensive on memory but this is the best way of managing it from what I can tell
  (might change later)


pkgId: 7118da93f09adb02c0d844d71b29ab47177398dff5834aaecf5eb13feb053d16
name: python-color-ur-text
arch: src
version: 0.1.2.2
epoch: 0
release: 1
summary: A module for printing colored text to terminal/console inPython
url: https://github.com/basitganie
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-color-ur-text-0.1.2.2-1.src.rpm
checksum_type: sha256
description:
  A Python module for printing colored text in the terminal with ANSI escape codes. Supports standard colors, bright colors, 256-color mode, and 24-bit RGB.



  You can install the package using pip: pip install colored_text


pkgId: 219b57094c9e17584901b86b3869d889002a1431c6e954a891f734285973da5b
name: python-coloraide
arch: src
version: 4.0
epoch: 0
release: 1
summary: A color library for Python.
url: https://github.com/facelessuser/coloraide
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coloraide-4.0-1.src.rpm
checksum_type: sha256
description:
  [![Donate via PayPal][donate-image]][donate-link]
  [![Build][github-ci-image]][github-ci-link]
  [![Coverage Status][codecov-image]][codecov-link]
  [![PyPI Version][pypi-image]][pypi-link]
  [![PyPI Downloads][pypi-down]][pypi-link]
  [![PyPI - Python Version][python-image]][pypi-link]
  ![License][license-image-mit]





  ColorAide is a pure Python, object oriented approach to colors.

  ```python
  >>> from coloraide import Color
  >>> c = Color("red")
  >>> c.to_string()
  'rgb(255 0 0)'
  >>> c.convert('hsl').to_string()
  'hsl(0 100% 50%)'
  >>> c.set("lch.chroma", 30).to_string()
  'rgb(173.81 114.29 97.218)'
  >>> Color("blue").mix("yellow", space="lch").to_string()
  'rgb(255 65.751 107.47)'
  ```

  ColorAide particularly has a focus on the following:

  - Accurate colors.

  - Proper round tripping (where reasonable).

  - Be generally easy to pick up for the average user.

  - Support modern CSS color spaces and syntax.

  - Make accessible many new and old non-CSS color spaces.

  - Provide a number of useful utilities such as interpolation, color distancing, blending, gamut mapping, filters,
    correlated color temperature, color vision deficiency simulation, etc.

  - Provide a plugin API to extend supported color spaces and approaches to various utilities.

  - Allow users to configure defaults to their liking.

  With ColorAide, you can specify a color, convert it to other color spaces, mix it with other colors, output it in
  different CSS formats, and much more!



  https://facelessuser.github.io/coloraide



  MIT

  [github-ci-image]: https://github.com/facelessuser/coloraide/workflows/build/badge.svg?branch=main&event=push
  [github-ci-link]: https://github.com/facelessuser/coloraide/actions?query=workflow%3Abuild+branch%3Amain
  [codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/coloraide/main.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
  [codecov-link]: https://codecov.io/github/facelessuser/coloraide
  [pypi-image]: https://img.shields.io/pypi/v/coloraide.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-down]: https://img.shields.io/pypi/dm/coloraide.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-link]: https://pypi.python.org/pypi/coloraide
  [python-image]: https://img.shields.io/pypi/pyversions/coloraide?logo=python&logoColor=aaaaaa&labelColor=333333
  [license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
  [donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
  [donate-link]: https://www.paypal.me/facelessuser


