# packages

pkgId: e6268cfd7edae3793b3f8123bf6f1b3f675aa4fb914136c7a39ad983b61dcb48
name: python-CleanIO
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Simple IO eliminating the boilerplate.
url: https://github.com/deeppunster/CleanIO/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CleanIO-0.1.4-1.src.rpm
checksum_type: sha256
description:
  To read a text file.
      1.  Add an import statement
          ``from cleanio import CleanRead``
      2.  Create an instance of the ``CleanRead`` class and pass it the desired filename or path
          ``cr = CleanRead(<<file name or path>>)``
      3.  Accept each line of the file from the generator (e.g. with a ``for`` statement) from the ``clean_read`` method
          ``for line in cr.clean_read():``
      4.  When the generator finishes, it will return a ``StopIteration`` exception (which the for statement will handle automatically
  The file is opened, read, and closed automatically with no extra boilerplate
  needed.


pkgId: b5bf359cc49e696353394664ad1769c342880aa2ccd8c59ba4fcde259cd902d3
name: python-CleanSinhala
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: This will provide similar function "NLTK" "WordNetLemmatizer" module to "Sinhala" words
url: https://pypi.org/project/CleanSinhala/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CleanSinhala-0.1.9-1.src.rpm
checksum_type: sha256
description:
  [![forthebadge made-with-python](http://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)
  [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)

  - Make sure you have Python installed in your system.
  - Run Following command in the CMD.
   ```
    pip install CleanSinhala
    ```

   ```
    from CleanSinhala import simplify
    ```





  ```
    from Clean_Words import simplify
    print(simplify('Chanaka'))
    ```
   returens
   ```
   Chanaka
   ```


pkgId: 35f6687e02bc7d0f59b84ef888f47a96e3bbd2f40500e25a1fdcf19f71c28b37
name: python-CleanerVersion
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: A versioning solution for relational data models using the Django ORM
url: https://github.com/swisscom/cleanerversion
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CleanerVersion-2.1.1-1.src.rpm
checksum_type: sha256
description:
  CleanerVersion is a solution that allows you to read and write multiple versions of an entry to and from your relational database. It allows to keep track of modifications on an object over time, as described by the theory of **Slowly Changing Dimensions** (SCD) **- Type 2**. CleanerVersion therefore enables a Django-based Datawarehouse, which was the initial idea of this package.


pkgId: 4d277048e9e30a7bd57df1d6376424f43263a5ece6f39815f9a9d969a102f622
name: python-ClearIO
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Utility library for accessing IO providers in a uniform way.
url: https://github.com/bradleydonmorris/ClearIO
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ClearIO-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Utility library for accessing IO providers in a uniform way.


  This library uses the following packages:
  - [smbprotocol](https://github.com/jborean93/smbprotocol)
  - [pywin32](https://github.com/mhammond/pywin32)
  - [Paramiko](https://www.paramiko.org/)

  For tests, the following packages are used:
  - [python-dotenv](https://github.com/theskumar/python-dotenv)


pkgId: 2a4a8a7e00ef2c18a36483e0dcf82022ee588cd5502a1e887e555e1313c0be13
name: python-CliRenderer
arch: src
version: 0.1.6.post4
epoch: 0
release: 1
summary: A CLI tool to render unicode art in the terminal
url: https://github.com/ultraflame4/CliR
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CliRenderer-0.1.6.post4-1.src.rpm
checksum_type: sha256
description:
  ![img.png](resources/img.png)
  [Original image from pexels](https://www.pexels.com/photo/view-of-high-rise-buildings-during-day-time-302769/)
  ![img.png](resources/img2.png)
  [Original image from pexels](https://www.pexels.com/photo/dock-under-cloudy-sky-in-front-of-mountain-206359/)

rpm_license:
  MIT License  Copyright (c) 2023 ultraflame4  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: 319cc60cfb126cd2428e0cf0686cea0fd64a65ae9efa6d4771f6f22df9556be1
name: python-Clorm
arch: src
version: 1.6.0
epoch: 0
release: 1
url: https://github.com/potassco/clorm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Clorm-1.6.0-1.src.rpm
checksum_type: sha256
summary:
  Clingo ORM (CLORM) provides a ORM interface for interacting with the Clingo Answer Set Programming (ASP) solver

description:
  Clorm is a Python library that provides an Object Relational Mapping (ORM)
  interface to the Clingo Answer Set Programming (ASP) solver.
  For background, ASP is a declarative language for describing, and solving, hard
  search problems. `Clingo <https://github.com/potassco/clingo>`_ is a feature
  rich ASP solver with an extensive, but relatively low-level, Python API.
  The goal of this library is to make it easier to integrate Clingo within a
  Python application. It is implemented on top of the official Clingo API so is
  designed to supplement and not replace the Clingo API.
  When integrating an ASP program into an application you typically want to model
  the domain as a statically written ASP program, but then to generate problem
  instances and process the results dynamically. Clorm makes this integration
  cleaner, both in terms of code readability but also by providing a framework
  that makes it easier to refactor the python code as the ASP program evolves.
  The documentation is available online `here <https://clorm.readthedocs.io/>`_.
  Note: Clorm works with Python 3.8+ and Clingo 5.6+


pkgId: 3d44b78dde20781d4c873cd7e868029545f16c6041fd4b4b44b6ff4cb167dba9
name: python-CloudPSSInterface
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: CloudPSS电磁暂态仿真平台程序交互接口
url: https://pypi.org/project/CloudPSSInterface/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CloudPSSInterface-1.0.2-1.src.rpm
checksum_type: sha256
description:
  实现从DM数据库读取保护定值、运行CloudPSS仿真、获取仿真输出结果、输出结果写回数据库等功能.

  - 输入参数: 保护定值、软压板
  - 输出结果:日志记录、模拟量
  - 模型链接
    http://cloudpss-calculate.ddns.cloudpss.net/model/w864273603/SiChuanProectionTestSystem#/design/diagram/canvas/canvas_0
  - 示例:参见文件example.ipynb
  - python版本：python 3.9.9 64位
  - 依赖包配置:`pip install cloudpss`、`pip install plotly`、`pip install dmPython`



  若模型链接无法打开，请配置 vpn，参加文件**vpn客户端及配置2024**,注意：要求用户具有内网账号。

  若用户无内网账号，则可以本地导入测试系统、测试元件，已置于文件夹**cloudpssmodel**中。


  - 本地初始化：相关数据库表初始化、数据导入sql脚本,参加文件目录**数据库建表相关**。
  - 远程连接测试：可使用算例提供的数据库案例进行远程测试，Ip、用户名和密码见**数据库建表相关\数据库信息**。


  参见simulink模型文件 **simulinkmodel**目录中的**SiChuanProtectionTest.slx**。



  **simulinkmodel**目录中的**protection2.so**为对应**示例测试元件**在linux64为系统下的编译产物。


  本示例的测试元件的代码实现部分由**simulink封装示例**中的测试元件生成sfunction代码后编译得到，接口实现部分在CloudPSS平台中设计完成，元件接口设计可通过导入**保护仿真接口测试元件**查看。


pkgId: d244f0757c61d19fbf50a3ebedc3c080be45d46a57661c653e0cb1b185fce366
name: python-CloudVoy
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: A library to upload YouTube videos to Instagram Reels automatically.
url: https://pypi.org/project/CloudVoy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CloudVoy-1.0.5-1.src.rpm
checksum_type: sha256
description:
  - **Automated Workflow**: Fetches videos from a specified YouTube playlist, downloads them, uploads to AWS S3, and publishes them as Instagram Reels.
  - **Status Tracking**: Utilizes AWS DynamoDB to track the upload status of each video, preventing duplicate uploads.
  - **Thumbnail Management**: Automatically retrieves and validates YouTube video thumbnails for Instagram Reels.
  - **Error Handling & Logging**: Comprehensive logging to monitor the upload process and handle errors gracefully.
  - **Scalable & Secure**: Leverages AWS services for scalable storage and secure handling of credentials.

  Before using CloudVoy, ensure you have the following:
  1. **Python 3.6 or Higher**: Ensure Python is installed on your system. You can download it from [python.org](https://www.python.org/downloads/).
  2. **YouTube Data API Key**: Obtain an API key from the [Google Developers Console](https://console.developers.google.com/).
  3. **Instagram Graph API Credentials**: Set up a Facebook Developer account and obtain the necessary credentials to interact with the Instagram Graph API.
  4. **AWS Account**: Access to AWS services including S3 and DynamoDB. You'll need your AWS Access Key ID and Secret Access Key.
  5. **AWS S3 Bucket**: Create an S3 bucket where videos will be temporarily stored.
  6. **AWS DynamoDB Table**: Create a DynamoDB table (e.g., `YT_Video_ID_Table`) with `VideoID` as the primary key.

  You can install CloudVoy using `pip`. Ensure you have `pip` installed and updated.
  ```bash
  pip install CloudVoy
  ```
  Alternatively, you can install it directly from the GitHub repository:
  ```bash
  pip install git+https://github.com/yourusername/CloudVoy.git
  ```
  *(Replace yourusername with your actual GitHub username.)*

  CloudVoy uses environment variables to manage configurations securely. Follow the steps below to set up your environment.

  Create a `.env` file in the root directory of the project to store your configuration variables. This file should never be committed to version control for security reasons. Ensure it's added to `.gitignore`.
  **.env**
  ```env

  YOUTUBE_API_KEY=your_youtube_api_key
  YOUTUBE_PLAYLIST_ID=your_playlist_id

  INSTAGRAM_ACCOUNT_ID=your_instagram_account_id
  INSTAGRAM_ACCESS_TOKEN=your_instagram_access_token

  AWS_ACCESS_KEY_ID=your_aws_access_key_id
  AWS_SECRET_ACCESS_KEY=your_aws_secret_access_key
  AWS_S3_BUCKET_NAME=your_s3_bucket_name
  AWS_S3_REGION=your_s3_region

  DYNAMODB_TABLE_NAME=YT_Video_ID_Table

  DOWNLOAD_PATH=downloaded_videos
  ```
  Replace the placeholder values (`your_*`) with your actual credentials and configuration details.

  Ensure all required dependencies are installed. If you installed via pip, this should be handled automatically. Otherwise, install them using `requirements.txt`:
  ```bash
  pip install -r requirements.txt
  ```

  CloudVoy provides two primary methods for uploading videos to Instagram:

  This method allows you to upload a specific YouTube video to Instagram Reels by providing its URL.
  **Example**
  ```python
  from cloudvoy import upload_to_instagram_using_link

  video_url = "https://www.youtube.com/watch?v=VIDEO_ID"


  upload_to_instagram_using_link(video_url)
  ```
  **Parameters**
  - `video_url` (str): The full URL of the YouTube video you wish to upload.
  - `video_id` (str, optional): The unique identifier of the YouTube video. If not provided, it will be extracted from the URL.
  - `title` (str, optional): The caption for the Instagram Reel. If not provided, the video title from YouTube will be used.

  This method scans your specified YouTube playlist for any videos uploaded on the current day (in Indian Standard Time) and uploads them to Instagram Reels.
  **Example**
  ```python
  from cloudvoy import upload_instagram_today_videos

  upload_instagram_today_videos()
  ```
  **Functionality**
  - **Time Zone**: Determines the current day based on IST (Indian Standard Time).
  - **Filtering**: Selects videos from the playlist that were published on the current day.
  - **Upload Process**: For each qualifying video, it performs the upload workflow including downloading, uploading to S3, and publishing to Instagram.

  Here are some practical examples to help you get started with CloudVoy.

  ```python
  from cloudvoy import upload_to_instagram_using_link

  video_url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"

  upload_to_instagram_using_link(video_url)
  ```

  ```python
  from cloudvoy import upload_instagram_today_videos

  upload_instagram_today_videos()
  ```

  CloudVoy uses Python's logging module to provide detailed logs of the upload process. You can configure the logging level as needed.
  ```python
  import logging
  from cloudvoy import upload_to_instagram_using_link

  logging.basicConfig(level=logging.DEBUG, format='s - s - s')
  video_url = "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  upload_to_instagram_using_link(video_url)
  ```

  CloudVoy includes a suite of unit tests to ensure functionality remains intact during development and updates.

  Ensure you have all dependencies installed, then execute the following command from the root directory:
  ```bash
  python -m unittest discover tests
  ```

  The tests cover the primary functionalities of the library, including:
  - Fetching videos from YouTube playlists.
  - Downloading videos.
  - Uploading to AWS S3.
  - Interacting with Instagram Graph API.
  - Managing upload status in DynamoDB.
  **Note**: The tests use mocking to simulate external API interactions, ensuring they run quickly and without side effects.

  Contributions are welcome! If you'd like to enhance CloudVoy, please follow these steps:

  Click the "Fork" button at the top right of the repository page to create your own fork.

  ```bash
  git checkout -b feature/YourFeatureName
  ```

  Implement your feature or bug fix. Ensure your code adheres to the existing coding standards.

  ```bash
  git commit -m "Add your detailed description of the feature or fix"
  ```

  ```bash
  git push origin feature


pkgId: 3c56d16720e8a63dc8954c47821e45c6040bf07e5ffc234b885091f198c9b31f
name: python-CmonCrawl
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/CmonCrawl/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CmonCrawl-1.1.8-1.src.rpm
checksum_type: sha256
description:
  ![CmonCrawl Banner](./banner.webp)



  ![Build](https://github.com/hynky1999/CmonCrawl/actions/workflows/release.yml/badge.svg)
  ![Tests](https://github.com/hynky1999/CmonCrawl/actions/workflows/test_and_types.yml/badge.svg)
  [![Documentation](https://github.com/hynky1999/CmonCrawl/actions/workflows/sphinx_build.yml/badge.svg)](https://hynky1999.github.io/CmonCrawl/)

  ![License](https://img.shields.io/badge/license-MIT-green.svg)
  ![Python Version](https://img.shields.io/badge/python-3.11-blue.svg)
  [![PyPI](https://img.shields.io/badge/pypi-package-blue.svg)](https://pypi.org/project/cmoncrawl/)

  Unlock the full potential of CommonCrawl data with `CmonCrawl`, the most versatile extractor that offers unparalleled modularity and ease of use.



  `CmonCrawl` stands out from the crowd with its unique features:

  - **High Modularity**: Easily create custom extractors tailored to your specific needs.
  - **Comprehensive Access**: Supports all CommonCrawl access methods, including AWS Athena and the CommonCrawl Index API for querying, and S3 and the CommonCrawl API for downloading.
  - **Flexible Utility**: Accessible via a Command Line Interface (CLI) or as a Software Development Kit (SDK), catering to your preferred workflow.
  - **Type Safety**: Built with type safety in mind, ensuring that your code is robust and reliable.






  ```bash
  $ pip install cmoncrawl
  ```

  ```bash
  $ git clone https://github.com/hynky1999/CmonCrawl
  $ cd CmonCrawl
  $ pip install -r requirements.txt
  $ pip install .
  ```




  Begin by preparing your custom extractor. Obtain sample HTML files from the CommonCrawl dataset using the command:

  ```bash
  $ cmon download --match_type=domain --limit=100 html_output example.com html
  ```
  This will download a first 100 html files from *example.com* and save them in `html_output`.



  Create a new Python file for your extractor, such as `my_extractor.py`, and place it in the `extractors` directory. Implement your extraction logic as shown below:

  ```python
  from bs4 import BeautifulSoup
  from cmoncrawl.common.types import PipeMetadata
  from cmoncrawl.processor.pipeline.extractor import BaseExtractor
  class MyExtractor(BaseExtractor):
     def __init__(self):
        
        super().__init__(encoding=None)

     def extract_soup(self, soup: BeautifulSoup, metadata: PipeMetadata):
        
        
        body = soup.select_one("body")
        if body is None:
          return None
        return {
           "body": body.get_text()
        }

     
     
     def filter_raw(self, response: str, metadata: PipeMetadata) -> bool:
        return True
     def filter_soup(self, soup: BeautifulSoup, metadata: PipeMetadata) -> bool:
        return True



  extractor = MyExtractor()
  ```


  Set up a configuration file, `config.json`, to specify the behavior of your extractor(s):
  ```json
  {
      "extractors_path": "./extractors",
      "routes": [
          {
              
              "regexes": [".*"],
              "extractors": [{
                  "name": "my_extractor",
                  
                  on the date of the crawl
                  
                  "since": "2009-01-01",
                  "to": "2025-01-01"
              }]
          },
          
      ]
  }
  ```
  Please note that the configuration file `config.json` must be a valid JSON. Therefore, comments as shown in the example above cannot be included directly in the JSON file.



  Test your extractor with the following command:

  ```bash
  $ cmon extract config.json extracted_output html_output/*.html html
  ```


  After testing, start the full crawl and extraction process:



  ```bash
  cmon download --match_type=domain --limit=100 dr_output example.com record
  ```

  This will download the first 100 records from *example.com* and save them in `dr_output`. By default it saves 100_000 records per file, you can change this with the `--max_crawls_per_file` option.


  ```bash
  $ cmon extract --n_proc=4 config.json extracted_output dr_output/*.jsonl record
  ```

  Note that you can use the `--n_proc` option to specify the number of processes to use for the extraction. Multiprocessing is done on file level, so if you have just one file it will not be used.



  Before implementing any of the strategies to mitigate high error responses, it is crucial to first check the status of the CommonCrawl gateway and S3 buckets. This can provide valuable insights into any ongoing performance issues that might be affecting your access rates. Consult the CommonCrawl status page for the latest updates on performance issues: [Oct-Nov 2023 Performance Issues](https://commoncrawl.org/blog/oct-nov-2023-performance-issues).

  ![CommonCrawl Performance](https://assets-global.website-files.com/647b1c7a9990bad2048d3711/6554fda9c869f5af56e22cea_cf-week.png)

  Encountering a high number of error responses usually indicates excessive request rates. To mitigate this, consider the following strategies in order:

  1. **Switch to S3 Access**: Instead of using the API Gateway, opt for S3 access which allows for higher request rates.
  2. **Regulate Request Rate**: The total requests per second are determined by the formula `n_proc * max_requests_per_process`. To reduce the request rate:
     - Decrease the number of processes (`n_proc`).
     - Reduce the maximum requests per process (`max_requests_per_process`).

     Aim to maintain the total request rate below 40 per second.
  3. **Adjust Retry Settings**: If errors persist:
     - Increase `max_retry` to ensure eventual data retrieval.
     - Set a higher `sleep_base` to prevent API overuse and to respect rate limits.



  `CmonCrawl` was designed with flexibility in mind, allowing you to tailor the framework to your needs. For distributed extraction and more advanced scenarios, refer to our [documentation](https://hynky1999.github.io/CmonCrawl/) and the [CZE-NEC project](https://github.com/hynky1999/Czech-News-Classification-dataset).



  For practical examples and further assistance, visit our [examples directory](https://github.com/hynky1999/CmonCrawl/tree/main/examples).



  Join our community of contributors on [GitHub](https://github.com/hynky1999/CmonCrawl). Your contributions are welcome!



  `CmonCrawl` is open-source software licensed under the MIT license.

rpm_license:
  MIT License  Copyright (c) [2023] [Hynek Kydlíček]  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: 7a5aa0026876b16ac4a52015eaab08b9a0a248ad4f514b2b67dff894fa258374
name: python-CndIO
arch: src
version: 2.4.0
epoch: 0
release: 1
url: https://gitlab.com/changendevops/cnd-io
rpm_license: MIT/X11
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CndIO-2.4.0-1.src.rpm
checksum_type: sha256
summary:
  Tools to manage In/Out file. Easy to add new class if you need to change source/dest (file system, git ...)

description:
  Python lib to import/export content from/into different type of provider : filesystem, git etc...






  First you need declare a provider, in this sample only one provider is available : FileSystem

  For a more simple use of error message, this lib can use CndPrint

  ```
  import cndprint
  import cnd_io

  _print = cndprint.CndPrint(level="Info")
  provider = cnd_io.CndProviderLocalfile(print=_print)
  ```



  ```
  import cndprint
  import cnd_io

  _print = cndprint.CndPrint(level="Info")
  provider = cnd_io.CndProviderLocalfile(print=_print)
  cnd_io = cnd_io.CndIO(provider, print=_print)
  ```



  ```
  import cndprint
  import cnd_io

  _print = cndprint.CndPrint(level="Info")
  provider = cnd_io.CndProviderGitlab(creds={'private_token': 'my-private-token', host="https://gitlab.com/api/v4/"}, print=_print)
  cnd_io = cnd_io.CndIO(provider, print=_print)
  ```


  with file system provider

  ```
  cnd_io.pull_file('source_name', 'path/myfile.txt')
  ```
  with gitlab provider

  ```
  cnd_io.pull_file('source_name', 'path/myfile.txt', branch="main")
  ```



  ```
  cnd_io.push_file('source_name', 'path/myfile.txt', 'content_to_push')
  ```




  ```
  cnd_io.pull_yaml_file('source_name', 'path/myfile.txt')
  ```



  ```
  cnd_io.push_yaml_file('source_name', 'path/myfile.txt', 'content_to_push')
  ```



  ```
  cnd_io.commit_file('source_name', 'path/myfile1.txt', content_to_push1)
  cnd_io.commit_yaml_file('source_name', 'path/myfile2.txt', content_to_push2)
  cnd_io.push_files('source_name')
  ```


pkgId: 3d17ebc898af0523d7fd6dd86023b860a5a18ad9f9fbf7dc363800c72840a919
name: python-CnkiSpider
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: CnkiSpider是一个高效爬取知网文章信息的包
url: https://github.com/zemengchuan/CnkiSpider
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CnkiSpider-1.1.0-1.src.rpm
checksum_type: sha256
description:
    正在爬取第2页……
    正在爬取第3页……
    正在爬取第4页……
    正在爬取第5页……
    正在爬取第6页……
    正在爬取第7页……
    正在爬取第8页……
    正在爬取第9页……
    第9页爬取成功！第9页有28条数据
    第7页爬取成功！第7页有50条数据
    第4页爬取成功！第4页有50条数据
    第6页爬取成功！第6页有50条数据
    第5页爬取成功！第5页有50条数据
    第3页爬取成功！第3页有50条数据
    第2页爬取成功！第2页有50条数据


pkgId: 1f52b1146562451d262fa44c15697834537bb89aa6e580c1b904cf6d386199e3
name: python-CoAPthon3-ACME-CSE
arch: src
version: 1.1.4
epoch: 0
release: 1
url: https://github.com/ankraft/CoAPthon3-ACME-CSE
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CoAPthon3-ACME-CSE-1.1.4-1.src.rpm
checksum_type: sha256
summary:
  CoAPthon is a python library for the CoAP protocol. This fork of the library provides several updates to support the oneM2M CoAP binding of the ACME oneM2M CSE


pkgId: 695e9592b6c4afe97c798f761782eca872650724d058d2f3c25587b503bdf135
name: python-Code-Ocean-Aux-Tools
arch: src
version: 1.1.3
epoch: 0
release: 1
url: https://github.com/codeocean/co_aux_tools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Code-Ocean-Aux-Tools-1.1.3-1.src.rpm
checksum_type: sha256
summary:
  A suite of convenience tools for working with common bioinformatics files in Code Ocean capsules and pipelines.


pkgId: 4a20d80e3a62a418657283aa55cba0bebdc210e41c9679ed24fae22a230336b9
name: python-Code1v1
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: Code 1v1 是 AI悦创·致力推广编程教学而研发的教学库
url: https://github.com/AndersonHJB/Code1v1
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Code1v1-0.0.9-1.src.rpm
checksum_type: sha256
description:
  你好，我是悦创。
  Hello, this is Yue Chuang.
  如果你对 Python 库开发比较熟悉且有兴趣一起研发和优化，欢迎👏发提交 issues 申请。[https://github.com/AndersonHJB/Code1v1/issues](https://github.com/AndersonHJB/Code1v1/issues)。
  If you are familiar with Python library development and are interested in working together to develop and optimize it, please submit an issues request at 👏.[https://github.com/AndersonHJB/Code1v1/issues](https://github.com/AndersonHJB/Code1v1/issues)
  欢迎提交 Pull requests。
  You are welcome to submit Pull requests.

  - Github: [https://github.com/AndersonHJB/Code1v1](https://github.com/AndersonHJB/Code1v1)
  - Pypi: [https://pypi.org/project/Code1v1/](https://pypi.org/project/Code1v1/)
  - 官方文档：[https://bornforthis.cn/Code1v1/](https://bornforthis.cn/Code1v1/)


  ```bash
  pip3 install Code1v1
  ```

  ```bash
  pip install Code1v1
  ```

  - [What is Code1v1?](https://bornforthis.cn/Code1v1/)

  This is free and unencumbered software released into the public domain.
  Anyone is free to copy, modify, publish, use, compile, sell, or
  distribute this software, either in source code form or as a compiled
  binary, for any purpose, commercial or non-commercial, and by any means.


  ![img_1.png](https://github.com/AndersonHJB/Code1v1/raw/main/img.png)


pkgId: 23c46ee913fe48f5ff8f9a04c22acbe846e4e773a04207ab221318eb06fc640f
name: python-CodeChat
arch: src
version: 1.9.4
epoch: 0
release: 1
summary: The CodeChat System for software documentation
url: http://codechat.readthedocs.io/en/latest/
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CodeChat-1.9.4-1.src.rpm
checksum_type: sha256
description:
  Put simply, literate programming (LP) is the realization that a program is a document written to and for fellow programmers, not simply a list of instructions for a computer. LP tools therefore produce a nicely-formatted document which contains the code intermixed with explanatory prose. `Donald Knuth <http://en.wikipedia.org/wiki/Donald_Knuth>`_ introduced literate programming using his WEB tool in his seminal `paper <http://www.literateprogramming.com/knuthweb.pdf>`_. Per Figure 1 of this paper_, the WEB system takes a ``.w`` document as input then produces either a "tangled" source file for compilation or a "woven" document as a ``.tex`` file. The document is beautiful; the WEB source is difficult to digest (see Figure 2a-c); the source code is completely unreadable (see Figure 3). While a plethora of `tools <http://en.wikipedia.org/wiki/Literate_programming#Tools>`_ developed over the years attempt to address these problems, only one `LP-inspired <http://rant.gulbrandsen.priv.no/udoc/history>`_ variant has gained widespread acceptance: documentation generators, such as `Doxygen <http://www.doxygen.org>`_ and `JavaDoc <http://www.oracle.com/technetwork/java/javase/documentation/index-jsp-135444.html>`_, which extract documentation directly from source code, rather than extracting source code from the documentation, as WEB and most LP tools do. CodeChat addresses these LP weaknesses by producing a document directly from the code; employing human-readable markup (reStructuredText); and by supporting a GUI to make editing an LP document-program faster and easier.


pkgId: 35acaf0f8a0d4bc40c863a07db669e9d7b572148ee8e33fef8c83da783c6be55
name: python-CodeChat-Server
arch: src
version: 0.2.23
epoch: 0
release: 1
summary: The CodeChat Server for software documentation
url: http://codechat.readthedocs.io/en/latest/
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CodeChat-Server-0.2.23-1.src.rpm
checksum_type: sha256
description:
  The CodeChat System provides a powerful literate programming authoring system to a variety of text editors and IDEs. Specifically, it provides a GUI to automatically render source code and/or markup documents to HTML, displaying the HTML document produced by the rendering process next to the source. For example:
      This screenshot shows the Visual Studio Code editor with the CodeChat extension.
  In ❶, the left panel shows a the Visual Studio Code text editor with Python source code. CodeChat renders this source code to ❷, the right panel, which shows the resulting HTML document. Finally, ❸ displays output from the build process. A splitter between ❷ and ❸ allows the user to adjust the build output size or hide it entirely. Below ❸, a status bar displays the build status and a count of errors and warnings produced by the build.
  In addition to native support for Markdown and reStructuredText, the CodeChat System supports almost any external renderer via user-provided JSON configuration files. For example, CodeChat can:
  -   invoke `Pandoc <https://pandoc.org/>`_ to render a wide variety of markup formats;
  -   use `Sphinx <https://www.sphinx-doc.org/>`_ to build project documentation;
  -   call `Runestone <https://runestone.academy/>`_ to create interactive textbooks;
  -   employ `Doxygen <https://www.doxygen.nl/>`_ to generate documentation from source code;


pkgId: 10a794c61150899ae5e96930077e7d0037210dfc11c3f4be93ebb36d59fed567
name: python-CodeMetaPy
arch: src
version: 2.5.3
epoch: 0
release: 1
summary: Generate and manage CodeMeta software metadata
url: https://github.com/proycon/codemetapy
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CodeMetaPy-2.5.3-1.src.rpm
checksum_type: sha256
description:
  [![Project Status: Active -- The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
  [![GitHub build](https://github.com/proycon/codemetapy/actions/workflows/codemetapy.yml/badge.svg?branch=master)](https://github.com/proycon/codemetapy/actions/)
  [![GitHub release](https://img.shields.io/github/release/proycon/codemetapy.svg)](https://GitHub.com/proycon/codemetapy/releases/)
  [![Latest release in the Python Package Index](https://img.shields.io/pypi/v/codemetapy)](https://pypi.org/project/codemetapy/)



  Codemetapy is a command-line tool to work with the [codemeta ](https://codemeta.github.io) software metadata standard.
  Codemeta builds upon [schema.org](https://schema.org) and defines a vocabulary for describing software source code. It
  maps various existing metadata standards to a unified vocabulary.

  For more general information about the CodeMeta Project for defining
  software metadata, see <https://codemeta.github.io>. In particular, new
  users might want to start with the User Guide, while those looking to
  learn more about JSON-LD and consuming existing codemeta files should
  see the Developer Guide.

  Using codemetapy you can generate a `codemeta.json` file, which
  serialises using [JSON-LD](https://json-ld.org) , for
  your software. At the moment it supports conversions from the following
  existing metadata specifications:

  * Python distutils/pip packages (`setup.py`/`pyproject.toml`)
  * Java/Maven packages (`pom.xml`)
  * NodeJS packages (`package.json`)
  * Debian package (`apt show` output)
  * Github API (when passed a github URL)
  * GitLab API (when passed a GitLab URL)
  * Web sites/services (see the section on software types and service below):
      * Simple metadata from HTML `<meta>` elements.
      * Script blocks using `application/json+ld`

  It can also read and manipulate existing `codemeta.json` files as well
  as parse simple AUTHORS/CONTRIBUTORS files. One of the most notable
  features of codemetapy is that it allows chaining to successively update
  a metadata description based on multiple sources. Codemetapy is used in
  that way by the [codemeta-harvester](https://github.com/proycon/codemeta-harvester).

  **Note:** If you are looking for an all-in-one solution to automatically
  generate a `codemeta.json` for your project, then
  *[codemeta-harvester](https://github.com/proycon/codemeta-harvester) is the
  best place to start*. It is a higher-level tool that automatically invokes
  codemetapy on various sources it can automatically detect, and combined those into
  a single codemeta representation.



  `pip install codemetapy`



  Query and convert any installed python package:

  `$ codemetapy somepackage`

  Output will be to standard output by default, to write it to an output
  file instead, do either:

  `$ codemetapy somepackage > codemeta.json`

  or use the `-O` parameter:

  `$ codemetapy -O codemeta.json somepackage`

  If you are in the current working directory of any python project and
  there is a `setup.py`or `pyproject.toml`, then you can simply call `codemetapy` without
  arguments to output codemeta for the project. Codemetapy will
  automatically run `python setup.py egg_info` if needed and parse it's output to
  facilitate this:

  `$ codemetapy`

  The tool also supports adding properties through parameters:

  `$ codemetapy --developmentStatus active somepackage > codemeta.json`

  To read an existing codemeta.json and extend it:

  `$ codemetapy -O codemeta.json codemeta.json somepackage`

  or even:

  `$ codemetapy -O codemeta.json codemeta.json codemeta2.json codemeta3.json`

  This makes use of an important characteristic of codemetapy which is *composition*. When you specify multiple input sources, they will be interpreted as referring to the same resource.
  Properties (on `schema:SoftwareSourceCode`) in the later resources will *overwrite* earlier properties. So if `codemeta3.json` specifies authors, all authors that were specified in `codemeta2.json` are lost rather than merged and the end result will have the authors from `codemeta3.json`. However, if `codemeta2.json` has a property that was not in `codemeta3.json`, say `deveopmentStatus`, then that will make it to the end rsult. In other words, the latest source always takes precedence. Any non-overlapping properties will be be merged. This functionality is heavily relied on by the higher-level tool [codemeta-harvester](https://github.com/proycon/codemeta-harvester).

  If you want to start from scratch and build using command line parameters, use `/dev/null` as input, and make sure to pass some identifier and code repository:

  `$ codemetapy --identifier some-id --codeRepository https://github.com/my/code /dev/null > codemeta.json`

  This tool can also deal with debian packages by parsing the output of
  `apt show` (albeit limited):

  `$ apt show somepackage | codemetapy -i debian -`

  Here `-` represents standard input, which enables you to use piping
  solutions on a unix shell, `-i` denotes the input types, you can chain
  as many as you want. The number of input types specifies must correspond
  exactly to the number of input sources (the positional arguments).




  For `codemeta:developmentStatus`, codemetapy attempts to
  assign full [repostatus](https://www.repostatus.org/) URIs whenever
  possible For `schema:license`, full [SPDX](https://spdx.org) URIs are used where possible.



  We distinguish two types of identifiers, first there is the URI or [IRI](https://www.w3.org/TR/rdf11-concepts/#section-IRIs)
  that identifies RDF resources. It is a globally unique identifier and often looks like a URL.

  Codemetapy will assign new URIs for resources if and only if you pass a base URI using ``--baseuri``. Moreover, if you set this, codemetapy will *forcibly* set URIs over any existing ones, effectively assigning new identifiers. The previous identifier will then be covered via the `owl:sameAs` property instead. This allows you to ownership of all URIs.  Internally, codemetapy will create URIs for everything even if you don't specified a base URI (even for blank nodes), but these URIs are stripped again upon serialisation to JSON-LD.

  The second identifier is the [schema:identifier](https://schema.org/identifier), of which there may even be multiple.
  Codemetapy typically expects such an identifier to be a simple unspaced string holding a name for software. For example, a Python package name would make a good identifier. If this property is present, codemetapy will use it when generating URIs.
  The `schema:identifier` property can be contrasted with `schema:name`, which is the human readable form of the name and may be more elaborate.
  The identifier is typically also used for other identifiers (such as DOIs, ISBNs, etc), which should come in the following form:

  ```json
  "identifier:" {
      "@type": "PropertyValue",
      "propertyID": "doi",
      "value": "10.5281/zenodo.6882966"
  }
  ```

  But short-hand forms such as ``doi:10.5281/zenodo.6882966`` or as a URL like `https://doi.org/10.5281/zenodo.6882966` are also recognised by this library.




  Codemetapy (since 2.0) implements an extension to codemeta that allows
  linking the software source code to the actual instantiation of the
  software, with explicit regard for the interface type. This is done via
  the `schema:targetProduct` property, which takes as range a
  `schema:SoftwareApplication`, `schema:WebAPI`,
  `schema:WebSite` or any of the extra types defined in
  <https://github.com/SoftwareUnderstanding/software_types/> . This was
  proposed in [this issue](https://github.com/codemeta/codemeta/issues/271)

  This extension is enabled by default and can be disabled by setting the
  `--strict` flag.

  When you pass codemetapy a URL it will assume this is where the software
  is run as a service, and attempt to extract metadata from the site and
  encode is via `targetProduct`. For example, here we read an
  existing `codemeta.json` and extend it with some place where
  it is instantiated as a service:

  `$ codemetapy codemeta.json https://example.org/`

  If served HTML, codemetapy will use your `<script>` block
  using `application/json+ld` if it provides a valid software types (as
  mentioned above). For other HTML, codemetapy will simply extract some
  metadata from HTML `<meta>` elements. Content negotation will be used
  and the we favour json+ld, json and even yaml and XML over HTML.

  (Note: the older Entypoint Extension from before codemetapy 2.0 is now deprecated)



  You can use codemetapy to generate one big knowledge graph expressing
  multiple codemeta resources using the `--graph` parameter:

  `$ codemetapy --graph resource1.json resource2.json`

  This will produce JSON-LD output with multiple resources in the graph.



  Codemetapy can make use of the Github API to query metdata from GitHub,
  but this allows only limited anonymous requests before you hit a limit.
  To allow more requests, please set the environment variable
  `$GITHUB_TOKEN` to a [personal access
  token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token).



  Codemetapy can make use of the GitLab API to query metdata from GitLab,
  but this allows only limited anonymous requests before you hit a limit.
  To allow more requests, please set the environment variable
  `$GITLAB_TOKEN` to a [personal access
  token](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html).



  You can integrate `codemeta.json` generation in your project's
  `setup.py`, this will add an extra `python setup.py codemeta` command
  that will generate a new metadata file or update an already existing
  metadata file. Note that this must be run *after*
  `python setup.py install` (or `python setup.py develop`).

  To integrate this, add the following to your project's `setup.py`:

  ```python
  try:
      from codemeta.codemeta import CodeMetaCommand
      cmdclass={
          'codemeta': CodeMetaCommand,
      }
  except ImportError:
      cmdclass={}
  ```

  And in your `setup()` call add the parameter:

  ```python
  cmdclass=cmdclass
  ```

  This will ensure your `setup.py` works in all cases, even if codemetapy
  is not installed, and that the command will be available if codemetapy
  is available.

  If you want to ship your package with the generated `codemeta.json`,
  then simply add a line saying `codemeta.json` to the file `MANIFEST.in`
  in the root of your project.



  This work is conducted at the [KNAW Humanities Cluster](https://huc.knaw.nl/)'s
  [Digital Infrastructure department](https://di.huc.knaw.nl/) in the scope of the
  [CLARIAH](https://www.clariah.nl) project (CLARIAH-PLUS, NWO grant 184.034.023) as
  part of the FAIR Tool Discovery track of the Shared Development Roadmap.


pkgId: 46e21f13ea17e2d12895faceada2d984b6e319ef49a55097516986dbdc8ed053
name: python-CodingRider
arch: src
version: 2.9
epoch: 0
release: 1
summary: Library for CodingRider
url: https://imssam.me/shop/view.php?index_no=4031
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CodingRider-2.9-1.src.rpm
checksum_type: sha256
description:
  * Install
  ```
  > pip install CodingRider
  > pip --no-cache-dir install CodingRider
  ```

  * Upgrade
  ```
  > pip install --upgrade CodingRider
  ```

  * Uninstall
  ```
  > pip uninstall CodingRider
  ```





  * [PyPI CodingRider](https://pypi.org/project/CodingRider/)
  * [ALUX Dev](http://dev.byrobot.co.kr/)


pkgId: b55612d56d2f41ccc0ccf884653878dc27e27b51b782e25b224fc5eee9126f3b
name: python-Codyssey
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Python arsenal for competitive mastery
url: https://github.com/varskann/Codyssey
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Codyssey-1.0.8-1.src.rpm
checksum_type: sha256
description:
  <!-- PROJECT SHIELDS -->
  [![Contributors][contributors-shield]][contributors-url]
  [![Forks][forks-shield]][forks-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]
  [![MIT License][license-shield]][license-url]
  [![LinkedIn][linkedin-shield]][linkedin-url]



  <!-- PROJECT LOGO -->
  <br />
  <div align="center">
    <a href="https://github.com/varskann/Codyssey">
      <img src="images/codyssey_logo.png" alt="Logo" width="80" height="80"/>

    </a>

    <h3 align="center">Codyssey</h3>

    <p align="center">
      Codyssey: Your Python arsenal for competitive mastery.
      <br />
      <a href="https://github.com/varskann/Codyssey"><strong>Explore the docs »</strong></a>
      <br />
      <br />
      <a href="https://github.com/varskann/Codyssey">View Demo</a>
      ·
      <a href="https://github.com/varskann/Codyssey/issues">Report Bug</a>
      ·
      <a href="https://github.com/varskann/Codyssey/issues">Request Feature</a>

    </p>

  </div>

  <!-- TABLE OF CONTENTS -->
  <details>
    <summary>Table of Contents</summary>
    <ol>
      <li>
        <a href="#about-the-project">About The Project</a>
        <ul>
          <li><a href="#built-with">Built With</a></li>

        </ul>

      </li>
      <li>
        <a href="#getting-started">Getting Started</a>
        <ul>
          <li><a href="#prerequisites">Prerequisites</a></li>

          <li><a href="#installation">Installation</a></li>

        </ul>

      </li>

      <li><a href="#usage">Usage</a></li>
      <li><a href="#roadmap">Roadmap</a></li>
      <li><a href="#contributing">Contributing</a></li>
      <li><a href="#license">License</a></li>
      <li><a href="#contact">Contact</a></li>
      <li><a href="#acknowledgments">Acknowledgments</a></li>

    </ol>

  </details>



  <!-- ABOUT THE PROJECT -->


  Embark on a journey to conquer the algorithmic wilderness and ascend the ranks of competitive coding heroes with Codyssey, your Python-powered resource for mastering data structures, algorithms, and competitive programming challenges.

  <h3>What's inside?</h3>
   - **Pythonic Solutions:** LeetCode, NeetCode & beyond, conquered with crystal-clear Python.
   - **DSA Sharpening:** From novice to ninja, hone your data structures & algorithms.
   - **Beyond the Platform:** CLRS & more, competitive coding mastery from all corners.
   - **Blog of Wisdom:** In-depth insights, strategies, and wisdom from coding veterans.

  <h3>Why Codyssey?</h3>
   - **Clear and concise explanations:** Understand the "why" behind the code, not just the "how."
   - **Focus on Python:** Master the art of algorithmic problem-solving using your favorite language.
   - **Community of Coders:** Join a thriving, open-source, community of fellow adventurers on their quest for competitive mastery.
   - **Competitive Programming:** Learn from the best, and get inspired by the best.
   - **Continuous Growth:** The journey never ends. We constantly expand our resources and add new content to keep you challenged and engaged.




  Crystal-clear, concise, and powerful - your Python code conquers challenges like a Jedi Master's lightsaber.

  [![Python][Python]][Python-url]


  <!-- GETTING STARTED -->


  Explore the repository for solutions to a variety of coding challenges.
  Dive into the blog series for in-depth explanations and insights.
  Share your thoughts, questions, and progress in the discussion forum.







  _Below is an example of how you can instruct your audience on installing and setting up your app. This template doesn't rely on any external dependencies or services._

  1. Clone the repo
     ```sh
     git clone https://github.com/varskan/Codyssey.git
     ```
  2. Install Pip packages
     ```sh
     pip install codyssey
     ```

  <!-- USAGE EXAMPLES -->


  Use this space to show useful examples of how a project can be used. Additional screenshots, code examples and demos work well in this space. You may also link to more resources.

  _For more examples, please refer to the [Documentation](https://example.com)_

  <p align="right">(<a href="#readme-top">back to top</a>)</p>



  <!-- ROADMAP -->


  - [x] Add Changelog
  - [x] Add back to top links
  - [ ] Add Additional Templates w/ Examples
  - [ ] Add "components" document to easily copy & paste sections of the readme
  - [ ] Multi-language Support
      - [ ] Chinese
      - [ ] Spanish

  See the [open issues](https://github.com/varskann/Codyssey/issues) for a full list of proposed features (and known issues).



  <!-- CONTRIBUTING -->


  Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.

  If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
  Don't forget to give the project a star! Thanks again!

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request


  <!-- TODO -->

  - Setup Read the Docs Page
  - Setup Github Pages
  - Update ReadMe and detailed guidelines
  - Link with Medium blogs
  - Understand Changelog

  <!-- LICENSE -->


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


  <!-- CONTACT -->


  [@varskann](https://twitter.com/your_username) - varskann1993@gmail.com

  Project Link: [https://github.com/varskann/Codyssey](https://github.com/varskann/Codyssey)


  <!-- ACKNOWLEDGMENTS -->


  Use this space to list resources you find helpful and would like to give credit to. I've included a few of my favorites to kick things off!

  * [Choose an Open Source License](https://choosealicense.com)
  * [GitHub Emoji Cheat Sheet](https://www.webpagefx.com/tools/emoji-cheat-sheet)
  * [Malven's Flexbox Cheatsheet](https://flexbox.malven.co/)
  * [Malven's Grid Cheatsheet](https://grid.malven.co/)
  * [Img Shields](https://shields.io)
  * [GitHub Pages](https://pages.github.com)
  * [Font Awesome](https://fontawesome.com)
  * [React Icons](https://react-icons.github.io/react-icons/search)



  <!-- MARKDOWN LINKS & IMAGES -->
  <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
  [contributors-shield]: https://img.shields.io/github/contributors/varskann/Codyssey.svg?style=for-the-badge
  [contributors-url]: https://github.com/varskann/Codyssey/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/varskann/Codyssey.svg?style=for-the-badge
  [forks-url]: https://github.com/varskann/Codyssey/network/members
  [stars-shield]: https://img.shields.io/github/stars/varskann/Codyssey.svg?style=for-the-badge
  [stars-url]: https://github.com/varskann/Codyssey/stargazers
  [issues-shield]: https://img.shields.io/github/issues/varskann/Codyssey.svg?style=for-the-badge
  [issues-url]: https://github.com/varskann/Codyssey/issues
  [license-shield]: https://img.shields.io/github/license/varskann/Codyssey.svg?style=for-the-badge
  [license-url]: https://github.com/varskann/Codyssey/blob/master/LICENSE.txt
  [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
  [linkedin-url]: https://linkedin.com/in/varskann
  [Python]: https://img.shields.io/badge/Python-3776ab?style=for-the-badge&logo=Python&logoColor=yellow
  [Python-url]: https://www.python.org/


pkgId: 650db0bbdf8732cd4a2d5089d2184235b8467b8fa75d3087c59a87bf7330b8c1
name: python-CoffeeLintBear
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: 'CoffeeLintBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/CoffeeLintBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CoffeeLintBear-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Check CoffeeScript code for a clean and consistent style.

      For more information about coffeelint, visit <http://www.coffeelint.org/>.


pkgId: 980ee89cbf07b519512f47e8b0206209b15d1abdff9226a439fb2e3c1db420fe
name: python-CogEnvDecoder
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: For decoding observation data from Cog virtual environment
url: https://github.com/DRL-CASIA/COG-sim2real-challenge
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CogEnvDecoder-1.0.3-1.src.rpm
checksum_type: sha256
description:
  This is a package for COG participants to get necessary image and vector data to train and test their models.

  pip install CogEnvDecoder

  The code is able to get observations generated from ml-agents in the COG stimulation environment.
  With the code, you can get:
  - Blue one rover
  	- Image generated from virtual camera setted up on Blue one
  	- Blue one rover position & angle
  	- Enemy rover position & angle
  	- Remaining HP & bullets
  	- Goals' position
  - Judgement system information
  	- Current score
  	- Number of goals have been achieved
  	- Whether enemy rover has been activated
  	- Enemy rover remaining HP & bullets
  	- Blue one caused damage
  	- Time passed in the round
  	- collision information


pkgId: 6e46c0074f0a71e58aaf520e04fa948bf5d30d58710f888134b2cd5c6592ee6e
name: python-CoinCrypt
arch: src
version: 0.0.2.10.0
epoch: 0
release: 1
summary: Simple methods for working with coinmarketcap API
url: https://pypi.org/project/CoinCrypt/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CoinCrypt-0.0.2.10.0-1.src.rpm
checksum_type: sha256
description:
  An code to handle basic methods in the coin market cap API.

  To use this code initialize an class Coincrypt

  [Link to Github](https://github.com/HenriqueDomiciano/CoinCrypt)





  Simple Code to connect the API :

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  ```





  **get_price_by_symbol :**



  This method is made for getting the actual price(USD) given an symbol ex (BTC,ETE,LTC...)

  Obs - in version >=2.10.0 you can also use list of strings

  - Parameters:

      - symbol :: str -- The symbol of the crypto (for multiple prices use , inside the string )

      - max_search :: int -- the maximun number of cryptos the method will search



  Code Example:

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.get_price_by_symbol('BTC,ADA,ETH')

  ```



  **get_by_price :**



  This method is made to give an python dictionary with all the coins inside the parameters given

  - Parameters:

      - max_price :: float -- The maximum price of the coin

      - min_price :: float -- The minimum price of the coin

      - max_search :: int -- the maximun number of cryptos the method will search



  Code Example :

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.get_by_price(min_price = 0.2,max_price = 1, max_search = 100)# will return a python dict with the coins inside this values

  ```



  get_price_by_name :



  This methods get the price by the name of the coin ex : cardano, bitcoin, ethereum ...

      Parameters:

      name :: str -- The name of the coin,(To use multiple coins separte then by , )



  Code Example :

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.get_price_by_name(name = 'cardano,bitcoin')

  ```

  **get_by_volume :**



  This method returns an python dictionary with the coins symbols and the volume in certain period

  - Parameters :

      - min_vol :: float -- minimun volume for search

      - max_vol :: float -- maximum volume for search

      - period :: int -- the period you want to volume to be analized

          - period == 0 --> volume in 24 hours

          - period == 1 --> moving average of the last 7 days

          - period == 2 --> moving average of the last 30 days

      - max_search :: int -- the maximun number of cryptos the method will search



  Code Example:

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.get_price_by_volume(min_vol = 0 , max_vol = 100000, period = 0 )# get all the coins with the volume of 0 to 100000 in 24 hours in a dict with vol

  ```



  **get_by_change :**



  This method returns a python dictionary with the coins that are inside the interval of changes

  - Parameters :.

      - min_change :: float -- the minimum of the interval of change

      - max_change :: float -- the maximun of the interval of change

      - period :: int -- the period you want the interval of chage to be analized

          - period == 0 --> change in percentage of 1 hour

          - period == 1 --> change in percentage in 24 hours

          - period == 2 --> change in percentage in 7 days

          - period == 3 --> change in percentage in 30 days



  Code Example :

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.get_price_by_volume(min_change = 0 , max_change = 1, period = 0) # will return a dict with all coins with the variation between 0 and 1 in 1 hour

  ```

  **get_historical :**



  This method gives the historical features of the coin

  - Parameters :

      - symbol :: str -- The symbol of the coin you want to know the history of (only accepts one)



  Code Example :

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.get_historical('BTC')# returns historical features of bitcoin in json Object

  ```



  **convert_crypto :**



  This method converts criptos(BTC,ETH,ADA...) in their value in fiat coins such as BRL,EUR,USD,GBP...

  Obs - in version >=2.10.0 you can also use list of strings in convert_to

  - Parameters :

      - converte_from :: str -- The symbol of the cryptocurrency you want to be converted (can use multiple entrance depending on your api plan)

      - convert_to :: str -- The symbol of the flat coin you want to be converted to

      - amount :: float -- The amount of cryptocurrency you want to be converted



  Code Example :

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.convert_crypto('BTC','USD,1)# returns a dict with the realtion between USD and the price of 1 bitcoin

  ```

  **get_global_metrics :**



  This method gives the global metrics of the crytptocurrencies market

  - Parameters :

      - convert_to :: str -- The symbol of the currency wich the data will be showed



  Code Example:

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.convert_crypto('BRL') # return global market data in dict format converted to BRL('Brazilian Real)

  ```

  **get_FCAS_latest**:



  Show the latest FCAS (Fundamental Crypto Asset Score) of the crypto

  - Parameters :

      - slug :: str -- The name of the crypto you want to have tha data information

      - symbol :: str -- The symbol of the crypto you want to have the data information



  Code Example:



  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.get_FCAS_latest('BTC')# returns json Object with the FCAS data

  ```



  **get_data_by_string:**



  Get all the data avaliable by the API given an string of symbols or names of coins

  Obs - in version >=2.10.0 you can also use list of strings

  - Parameters :

      - slug :: str -- The name of the crypto you want to have tha data information

      - symbol :: str -- The symbol of the crypto you want to have the data information



  Code Example:

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = cp.coincrypt('API_KEY')

  cr.get_data_by_string(symbol = 'BTC,ETH,BNB')

  ```

  **how_much_can_buy**



  Returns an dict with the number of coins such amount of fiat coin can buy

  Obs - in version >=2.10.0 you can also use list of strings

  - Parameters:

      - slug :: str -- The name of the crypto you want to 'buy'

      - symbol :: str -- the symbol of the crypto you want to 'buy'

      - fiat_coin :: str -- the code of the fiat coin you want to buy from

      - amount :: float -- the amount of fiat coin you have to buy in that cryptocurrencies

  Code Example :

  ```python

  from CoinCrypt import Coincrypt as cp

  cr = coincrypt('API_KEY')

  amount = cr.how_much_can_buy(symbol='ADA,ETH',amount=80))

  ```

  if you like to help me here is my cardano,BitCoin and Ethereum wallet:



      ADA : addr1q9rm6tavahr3qda2dje7vsac6l0yyqxuj3x82l9ckjpm7fxj7y2w4rym5f6psf5v4kw5dcezdjmw29625sews2zqtjhql2dlxj

      BTC : bc1qazdaj8at50mcs5fsm5vj8wzfn6yxac9nes3ktg

      ETH : 0x62786833a10436B394512E8F42F26C6BD3c4040c



  Created by Henrique Domiciano Osinski


pkgId: 5652354e5cbb5efb3c64dfd64e96ab6ea11ccbd299263b157892c668dbd6a79f
name: python-Coins
arch: src
version: 0.2.2
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/halfmoonlabs/coins
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Coins-0.2.2-1.src.rpm
checksum_type: sha256
summary:
  Tools for Bitcoin & other cryptocurrencies (incl. Litecoin, Namecoin, Peercoin, Primecoin, Dogecoin, Worldcoin, Megacoin, Anoncoin, Feathercoin, Terracoin, and Novacoin).


pkgId: 1b6bec7456ad2d0017baefa28f7e084d654daf19ee28251240552582df0e4b9a
name: python-ColabGeek
arch: src
version: 1.3.8
epoch: 0
release: 1
url: https://github.com/yimingsun12138/ColabGeek
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColabGeek-1.3.8-1.src.rpm
checksum_type: sha256
summary:
  ColabGeek is designed to help run useful tools on Google Colab, including port forwarding, web IDE and so on. It is worth noting that this package is also compatible with other Ubuntu operating system servers, so try on other platforms as well.

description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/yimingsun12138/ColabGeek/blob/main/LICENSE)
  [![PyPI version](https://badge.fury.io/py/ColabGeek.svg)](https://badge.fury.io/py/ColabGeek)

  ColabGeek Python package is designed to help run useful tools on Google Colab, including web IDE, port forwarding and so on. It is worth noting that this package is also compatible with other Ubuntu operating system based servers, so try this package on other platforms as well.



  Version: 1.3.8

  Platform: Ubuntu 22.04 LTS

  Update: 2024/10/24



  ```python
  pip install ColabGeek
  ```



  First load the ColabGeek module and update all the packages and dependencies in the system (Please run under user root!).

  ```python
  import ColabGeek

  ColabGeek.update_environment()
  ```

  Initiate the Colab session by adding a new user (or change the password for the existing user) and mounting Google Drive.

  ```python
  main = ColabGeek.ColabSession(user='Knight',password='midnight',mount_GD=True)
  ```



  As a cloud computing platform based on Jupyter notebooks, Google Colab does not provide a top-notch comfortable environment for R language data analysis and other non-Python programming. Therefore, this project provides methods for quickly installing other web IDEs on Google Colab, enabling it to expand its range of capabilities.



  [code server](https://github.com/coder/code-server) is a web IDE provided by Coder that enables developers to write, run and debug code from a web browser. It is built on the open-source Visual Studio Code editor and offers many of the same features, such as code highlighting, auto completion, and debugging.

  ```python





  main.Run_code_server()
  ```

  You can also install code server extension by providing extension id or the path of the VSIX file downloaded from [vscode marketplace](https://marketplace.visualstudio.com/vscode).

  ```python




  main.Install_code_server_extension(extension='ms-python.anaconda-extension-pack')
  ```

  You can also config code server through `ColabGeek.Config_code_server` method.

  ```python




  main.Config_code_server(property='workbench.colorTheme',value='Default Dark+')
  main.Config_code_server(property='editor.fontSize',value=18)
  main.Config_code_server(property='terminal.integrated.fontSize',value=18)
  main.Config_code_server(property='files.autoSave',value='off')
  ```



  [Rstudio server](https://posit.co/products/open-source/rstudio-server/) is a web IDE for R programming. With Rstudio server, users can run R scripts, create and manage R projects, develop and test code, and share their work with others. Rstudio server also offers powerful features such as syntax highlighting, code completion, debugging and data visualization.

  ```python




  main.Run_Rstudio_server()
  ```


  [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/index.html) is an interactive web IDE for working with Jupyter notebooks, code, and data. It is a flexible and extensible platform designed to support the entire workflow in data science, scientific computing, and machine learning projects. ColabGeek pulls the [mrdoge/jupyterlab docker image](https://hub.docker.com/r/mrdoge/jupyterlab) from Docker Hub and execute the docker container using [udocker](https://github.com/indigo-dc/udocker). Notice that it is not recommended to run udocker and JupyterLab under user root.

  ```python






  main.Run_JupyterLab()
  ```



  Google Colab does not allow any internet connections to their servers except the official web interface. So, port forwarding methods are required to proxy the web IDE installed.



  ```python






  main.Run_localtunnel()
  ```



  ```python






  main.Run_ngrok()
  ```



  ```python




  main.Run_Cloudflare_Tunnel(token='replace with your own tunnel token!')
  ```





  Although not allowed by Google and not recommended by myself, building a proxy server using Colab sounds pretty 'Geek'. However, this function only helps to install and run shadowsocks on Colab, and I have no clue how to connect to the shadowsocks server. Just use this method on your own Ubuntu servers, that should work. If you have any good ideas, leave an issue please!

  ```python






  main.Run_shadowsocks()
  ```



  [Jekyll](https://jekyllrb.com/) is a simple, blog-aware, static site generator that allows users to create their own websites or blogs without the need for databases or server-side programming languages. It takes text written in Markdown, processes it through a template engine, and generates a ready-to-publish static website. ColabGeek now provides a method to automatically install Jekyll and all of its dependencies. Users can easily access their Jekyll sites using tunneling methods, also provided by ColabGeek.

  ```python




  main.Install_Jekyll(Ruby_version='3.2.2',verbose=True)
  ```



  [Stable Diffusion](https://github.com/CompVis/stable-diffusion) is a deep learning, text-to-image model released in 2022 based on diffusion techniques. It is primarily used to generate detailed images conditioned on text descriptions, though it can also be applied to other tasks such as inpainting, outpainting, and generating image-to-image translations guided by a text prompt. [Stable Diffusion WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) is a browser interface for Stable Diffusion that allows to create beautiful art much more easily. Stable Diffusion WebUI can be easily installed through ColabGeek and conveniently accessed using the tunneling method also provided by ColabGeek.

  ```python







  main.Run_stable_diffusion_webui()




  ```



  ColabGeek violated numerous community rules of Google Colab. But still, I developed ColabGeek, because the simple Jupyter interface just does not meet the requirements of many software applications and is not user-friendly for coding in non-Python languages. I recommend all ColabGeek users purchase Colab Pro or Pro+ to support the excellent services provided by Google. Keep in mind, avoid misuse and Don't Be Evil.


pkgId: 8edc7ffda9c320611282fd73803ded2a85c201183b578324c6654c0b3e8fc4cb
name: python-ColabGeek
arch: src
version: 1.4.1
epoch: 0
release: 1
url: https://github.com/yimingsun12138/ColabGeek
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColabGeek-1.4.1-1.src.rpm
checksum_type: sha256
summary:
  ColabGeek is designed to help run useful tools on Google Colab, including web IDE, port forwarding and so on.

description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/yimingsun12138/ColabGeek/blob/main/LICENSE)
  [![PyPI version](https://badge.fury.io/py/ColabGeek.svg)](https://badge.fury.io/py/ColabGeek)

  ColabGeek is designed to help run useful tools on Google Colab, including web IDE, port forwarding and so on. It is worth noting that this package is also compatible with other Ubuntu operating system based servers, so try this package on other platforms as well.



  Version: 1.4.1

  Platform: Ubuntu 22.04 LTS

  Update: 2024/11/20



  ```python
  pip install ColabGeek
  ```



  First import ColabGeek and update all the packages and dependencies in the system (Please run under root privilege).

  ```python
  import ColabGeek

  ColabGeek.update_environment()
  ```

  Initialize the Colab session by adding a new user (or changing the password for the existing user) and mounting Google Drive.

  ```python
  main = ColabGeek.ColabSession(user = "knight",password = "midnight",mount_GD = True)
  ```



  As a cloud computing platform based on Jupyter notebook, Google Colab does not provide a top-notch user-friendly environment for R language data mining and other non-Python programming. Therefore, this project aims to provide methods for quickly installing other web IDEs on Google Colab, enabling it to expand its range of capabilities.



  [code server](https://github.com/coder/code-server) is a web IDE provided by Coder that enables developers to write, run and debug code from a web browser. It is built on the open-source Visual Studio Code editor and offers many of the same features, such as code highlighting, auto completion, and debugging.

  ```python





  main.Run_code_server()
  ```

  You can also install code server extension by providing extension id or the path of the VSIX file downloaded from [VSCode marketplace](https://marketplace.visualstudio.com/vscode).

  ```python




  main.Install_code_server_extension(extension = "ms-python.anaconda-extension-pack")
  ```

  You can also configure code server through `ColabSession.Config_code_server` method.

  ```python




  main.Config_code_server(property = "workbench.colorTheme",value = "Default Dark+")
  main.Config_code_server(property = "editor.fontSize",value = 18)
  main.Config_code_server(property = "terminal.integrated.fontSize",value = 18)
  main.Config_code_server(property = "files.autoSave",value = "off")
  ```



  [Rstudio server](https://posit.co/products/open-source/rstudio-server/) is a web IDE for R programming. With Rstudio server, users can run R scripts, create and manage R projects, develop and test code, and share their work with others. Rstudio server also offers powerful features such as syntax highlighting, code completion, debugging and data visualization.

  ```python




  main.Run_Rstudio_server()
  ```


  [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/index.html) is a flexible and extensible web IDE designed to support the entire workflow in data science, scientific computing, and machine learning projects. ColabGeek pulls the [mrdoge/jupyterlab docker image](https://hub.docker.com/r/mrdoge/jupyterlab) from Docker Hub and executes using [udocker](https://github.com/indigo-dc/udocker). Notice that it is not recommended to run udocker and JupyterLab under ColabSession user root.

  ```python






  main.Run_JupyterLab()
  ```



  Google Colab does not allow any internet connections to their host servers except the official web interface. Therefore, a tunnelling method is required to access services installed on Colab.



  ```python






  main.Run_localtunnel()
  ```



  ```python






  main.Run_ngrok(token = "replace with your own ngrok token!")
  ```



  ```python




  main.Run_Cloudflare_Tunnel(token = "replace with your own tunnel token!")
  ```





  Although not allowed by Google and not recommended by myself, building a proxy server using Colab sounds pretty "Geek". However, this function only helps to install and run shadowsocks on Colab, and I have no clue how to connect to the shadowsocks server. Just use this method on your own Ubuntu servers, that should work. If you have any good ideas, leave an issue please!

  ```python






  main.Run_shadowsocks()
  ```



  [Jekyll](https://jekyllrb.com/) is a simple, blog-aware, static site generator that allows users to create their own websites or blogs without the need for databases or server-side programming languages. It takes text written in Markdown, processes it through a template engine, and generates a ready-to-publish static website. ColabGeek provides a method to automatically install Jekyll and all of its dependencies. Users can easily access their Jekyll websites using tunnelling methods also provided by ColabGeek.

  ```python




  main.Install_Jekyll(Ruby_version = "3.3.5",verbose = True)
  ```



  [Stable Diffusion](https://github.com/CompVis/stable-diffusion) is a deep learning, text-to-image model released in 2022 based on diffusion techniques. It is primarily used to generate detailed images conditioned on text descriptions, though it can also be applied to other tasks such as inpainting, outpainting, and generating image-to-image translations guided by a text prompt. [Stable Diffusion WebUI](https://github.com/AUTOMATIC1111/stable-diffusion-webui) is a browser interface for Stable Diffusion that allows to create beautiful art much more easily. Stable Diffusion WebUI can be easily installed through ColabGeek and conveniently accessed by the tunnelling methods also provided by ColabGeek.

  ```python







  main.Run_Stable_Diffusion_WebUI()




  ```



  ColabGeek has violated numerous community rules of Google Colab. Therefore, users should consider carefully before using ColabGeek, as the author assumes no responsibility for any potential risks. All ColabGeek users are encouraged to consider subscribing Colab Pro or Pro+ to support the excellent services provided by Google. Keep in mind, avoid misuse and Don't Be Evil.


pkgId: c83fb7d36574d999b6740af1b4267c8316bc9306dae881c8f28d57c2205897ad
name: python-ColabTurtlePlus
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: An HTML based Turtle implementation with classes for Google Colab and Jupyter Labs
url: https://github.com/mathriddle/ColabTurtlePlus
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColabTurtlePlus-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Create an empty code cell and type:
      !pip install ColabTurtlePlus
  Run the code cell to install the library.
  **Note:** The previous non-class version of ColabTurtlePlus can be installed using !pip install ColabTurtlePlus==1.5.


pkgId: 48b155626b93da52a4f25125fc601e942d4c74725ef30217aeeff7c741065c42
name: python-ColanderAlchemy
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Autogenerate Colander schemas based on SQLAlchemy models.
url: https://github.com/stefanofontanelli/ColanderAlchemy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColanderAlchemy-0.3.4-1.src.rpm
checksum_type: sha256
description:
  `ColanderAlchemy` helps you to auto-generate `Colander
  <http://docs.pylonsproject.org/projects/colander/>`_ schemas
  that are based on `SQLAlchemy <http://www.sqlalchemy.org/>`_ mapped
  classes.
  Such `Colander` schemas can be used with libraries like `Deform
  <http://docs.pylonsproject.org/projects/deform/>`_ and helps remove the
  need for duplication of schema definitions.


pkgId: ee43fb79d432f02f0ea8020d6d6d37857b969a8c229795bbfbc31a16029fcd64
name: python-ColdTOFU
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Cold Atoms Time-of-Flight Utilities
url: https://github.com/chetanmadasu/TOFU
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColdTOFU-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Time of flight utilities - a simple package built using numpy and scipy to analyze absorption and fluorescence images
  from cold atoms experiments.

  `pip install ColdTOFU`

  or

  `pip install -e .` from the source directory to modify the code according to your usage.

  [![DOI](https://zenodo.org/badge/544229576.svg)](https://zenodo.org/badge/latestdoi/544229576)

  See requirements.txt for the necessary packages.

  See documentation and examples [here](https://chetanmadasu.github.io/examples.html)


pkgId: 97466d25fab3440308d31f8ee93d1718e9ac15606b642323442079b603f1ab24
name: python-Colectica-API
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Python interface to the Colectica API
url: https://github.com/CLOSER-Cohorts/colectica_api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Colectica-API-0.0.8-1.src.rpm
checksum_type: sha256
description:
  This repository provides some utility classes to use the Rest APIs on a Colectica Portal.
  Developed as an in-house resource for CLOSER, we are making it publicly avaliable for others using the Colectica Portal.
  If you have any requests or find any bugs, please log it under *Issues*.

  If you want further advice or support please contact us at: closer@ucl.ac.uk

  Colectica provide examples at https://docs.colectica.com/repository/functionality/rest-api/examples/
  and the Colectica Documentation for the API is available at https://discovery.closer.ac.uk/swagger/index.html



  ```
  pip install colectica-api
  ```



  ```
  from colectica_api import ColecticaObject
  C = ColecticaObject("colectica.example.com", <username>, <password>)
  C.search_items(...)
  ```

  See `example.ipynb` for a more complete example.


  Colectica Portal supports DDI LIfecycle, the graph below, represents the relationship between the various DDI Elements to enable retrieval of related elements, e.g. variables linked to a specific question

  ```mermaid
  graph LR
    QGr[Question Group] --> Concept
    QGr[Question Group] --> Question
    QGr[Question Group] --> QG[Question Grid]
    VG[Variable Group] --> Variable
    VG[Variable Group] --> Concept
    UnG[Universe Group] --> Universe
    Variable --> Question
    Group --> Organization
    Group --> Universe
    Group --> Study
    Study --> Organization
    Study --> Universe
    Study --> DaC[Data Collection]
    Study --> DaS[Data Set]
    DaC[Data Collection] --> Organization
    DaC[Data Collection] ==> Instrument
    UnG[Universe Group] --> Universe
    Instrument --> Sequence
    Sequence --> Statement
    Sequence --> QA[Question Activity]
    QA[Question Activity] --> Question
    QG[Question Grid] --> CoS[Code Set]
    QG[Question Grid] --> II[Interviewer Instruction]
    Question --> CoS[Code Set]
    Question --> II[Interviewer Instruction]
    CoS --> Category
    CCS[Control Construct Set] --> Sequence
    Conditional --> Sequence
    CCS[Control Construct Set] --> Conditional
    CCS[Control Construct Set] --> Statement
    CCS[Control Construct Set] --> Loop
    CCS[Control Construct Set] --> QA[Question Activity]
    DaS[Data Set] --> VaS[Variable Statistic]
    DaS[Data Set] --> Variable
    VaS[Variable Statistic] --> Variable
    Variable --> VariableRepresentation
    VariableRepresentation ==> CoS[Code Set]
    VariableRepresentation ==> Numeric
    VariableRepresentation ==> Text
    VariableRepresentation ==> DateTime
    Loop --> Sequence
  ```


pkgId: f3d224b0b850b76f6fdc4494bfef5c77f081b64dfcf376f5a8fe595dbdc4facb
name: python-CollabAgents
arch: src
version: 0.0.6
epoch: 0
release: 1
url: https://pypi.org/project/CollabAgents/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CollabAgents-0.0.6-1.src.rpm
checksum_type: sha256
summary:
  CollabAgents is a Python framework developed by Vishnu D. for developing AI agents equipped with specialized roles and tools to handle complex user requests efficiently. Users have 100 percent control over their prompts.

description:
  <div style="text-align: center;">
      <img src="https://i.postimg.cc/wTCWFxf4/logo.png" alt="logo.png" width="400"/>
  </div>


  CollabAgents is a versatile Python framework developed by Vishnu Durairaj, designed to facilitate the creation of intelligent AI agents equipped with a diverse range of tools and functionalities. This open-source framework simplifies the development of sophisticated AI systems capable of handling various tasks through role-based agents and supports advanced multi-agent orchestration.



  - **Create AI Agents with Tools**: Easily build AI agents with a diverse set of tools, from Python execution to file operations and terminal commands.
  - **Role-Based Agents**: Define agents with specific roles and responsibilities to handle different tasks and collaborate effectively.
  - **Interacting Entities**: Simulate scenarios where multiple agents or companies work together to complete user requests.
  - **Flexible Integration**: Supports both Anthropic and OpenAI models, providing flexibility in choosing the best AI model for your needs.
  - **Memory Management**: Efficiently handle conversation history with various memory options:
    - **ConversationBufferMemory**: Retains the entire conversation history. Use this when you need to maintain a complete record of all interactions without any summarization or truncation.
    - **ConversationBufferWindowMemory**: Retains only the last K messages in the conversation. Ideal for scenarios where you want to limit memory usage and only keep the most recent interactions. (`memory = ConversationBufferWindowMemory(last_k=3)`)
    - **ConversationSummaryMemory**: Automatically summarizes the conversation once it exceeds a specified number of messages. Use this to manage lengthy conversations by creating concise summaries while retaining overall context. (`memory = ConversationSummaryMemory(number_of_messages=5)`)
    - **ConversationSummaryBufferMemory**: Combines summarization with selective message retention. Summarizes the conversation after a certain point and retains only the most recent N messages. Perfect for balancing context preservation with memory constraints by keeping key recent interactions while summarizing earlier ones. (`memory = ConversationSummaryBufferMemory(buffer_size=5)`)




  You can try out the notebook directly in Google Colab using the following link:

  <a href="https://colab.research.google.com/drive/1cRVz-YS8Cf_GO-uTo0WUz5pLYTj_l4pn?usp=sharing" style="display: flex; align-items: center; text-decoration: none;">
      <img src="https://colab.research.google.com/img/colab_favicon_256px.png" alt="Open in Google Colab" width="150"/>
  </a>




  You can install the CollabAgents framework using pip:

  ```bash

  pip install CollabAgents

  ```







  Here’s an example of how to create a agent with tools using CollabAgents:



  ```python
  import os
  import nest_asyncio
  from CollabAgents.helper import print_colored
  from CollabAgents.agent import StructuredAgent
  from CollabAgents.models import OpenaiChatModel
  from CollabAgents.memory import ConversationBufferMemory
  from CollabAgents.tools.FileOperationsTool import SaveFile, CreateFolder
  ```



  ```python

  ```


  ```python


  description = "Responsible for writing story."


  instruction = "You are a creative storyteller who crafts imaginative narratives with vivid details, rich characters, and unexpected plot twists."
  ```


  ```python

  tools = [CreateFolder, SaveFile]
  ```


  ```python
  openai_api_key = "Your API Key"

  ```


  ```python
  model = OpenaiChatModel(model_name="gpt-4o-mini", api_key=openai_api_key, temperature=0)
  ```


  ```python

  memory = ConversationBufferMemory()














  ```


  ```python
  agent = StructuredAgent(model=model, agent_name="AI Assistant", agent_description=description, agent_instructions=instruction, tools=tools, assistant_agents=[],max_allowed_attempts=5, verbose=True,memory=memory)
  ```



  ```python

  print_colored("Starting the application...........", "green")




  user_input = input("User : ")


  messages = []


  while user_input != "bye":
      
      output = agent.run(user_input, messages)

      
      messages = agent.messages

      
      

      
      user_input = input("User Input : ")

  ```



  Here’s an example of how to create a custom tool using pydantic base model:

  ```python
  import os
  from typing import List
  from pydantic import BaseModel,Field

  class AppendToFile(BaseModel):
      
      """
      Use this tool to append content to an existing file.
      """
      
      reasoning :List[str] = Field(description="Why you are using this tool")

      
      file_name: str = Field(..., description="File name to append to.")
      content: str = Field(..., description="Content to append.")

      
      def run(self):
          try:
              with open(self.file_name, "a") as file:
                  file.write(self.content)
              return f"Content appended to file: {self.file_name}"
          except Exception as e:
              return f"An error occurred while appending to the file: {str(e)}"

  AppendToFile(reasoning=["Thoughts"],file_name="path to the file",content="content to append").run()

  ```


  Here’s an example of how to create multiple agents with tools using CollabAgents:

  ```python

  import os,nest_asyncio
  from CollabAgents.models import AnthropicModel
  from CollabAgents.agent import StructuredAgent
  from CollabAgents.tools.FileOperationsTool import CreateFolder,SaveFile,ListFilesInDirectory,ReadTextFile
  from CollabAgents.memory import ConversationSummaryBufferMemory,ConversationSummaryMemory,ConversationBufferWindowMemory,ConversationBufferMemory




  api_key = "Your API KEY"

  model = AnthropicModel(model_name="claude-3-sonnet-20240229",api_key=api_key,temperature=0)

  memory = ConversationBufferMemory()






  Story_Planner_agent_description = (
      "Responsible for creating the story outline and structure. "
      "Works with the CEO to understand client requirements and plan the story accordingly."
  )


  Story_Planner_instructions = (
      "As the Story Planner, you will receive the client requirements from the CEO. "
      "Create a detailed outline and structure for the story based on these requirements. "
      "Save the story outline in the project folder created by the CEO. "
      "Ensure that your plan is comprehensive and aligns with the client's vision. "
      "Collaborate with the CEO and Story Writer as needed to ensure the story's structure is clear and achievable."
  )



  story_planner_tools = [SaveFile]

  story_planner = StructuredAgent(model,"Story Planner",Story_Planner_agent_description,Story_Planner_instructions,tools=story_planner_tools,max_allowed_attempts=20,memory=memory)




  Story_Writer_agent_description = (
      "Responsible for writing the story based on the outline provided by the Story Planner. "
      "Ensures the final story meets client expectations and follows the planned structure."
  )


  Story_Writer_instructions = (
      "As the Story Writer, you will receive the story outline from the Story Planner, which is stored in the project folder created by the CEO. "
      "Write the story based on this outline, ensuring it meets the client's requirements and follows the planned structure. "
      "Save the completed story as a Markdown (.md) file in the same project folder. "
      "Communicate with the CEO for feedback and any necessary revisions to ensure the final story aligns with client expectations."
  )


  story_writter_tools = [ReadTextFile,SaveFile]

  story_writter = StructuredAgent(model,"Story Writer",Story_Writer_agent_description,Story_Writer_instructions,tools=story_writter_tools,max_allowed_attempts=20,memory=memory)




  CEO_agent_description = (
      "Responsible for client communication, task assignments, and coordination with other agents. "
      "Creates a new folder for each project to organize story planning and writing, and ensures the final story is stored as a Markdown file."
  )


  CEO_agent_instructions = (
      "As the CEO of the Story Writing Company, you will manage client interactions and gather detailed requirements. "
      "Create a new folder in the current directory for each project based on the client's requirements to keep all related files organized. "
      "Delegate tasks to the Story Planner and Story Writer, instructing them to store their respective outputs (story plan and final story content) in the designated folder by providing the exact path. "
      "Ensure that the final story is saved as a Markdown (.md) file in the project folder and coordinate with both agents to guarantee smooth progress and timely delivery."
  )


  CEO_tools = [CreateFolder,ListFilesInDirectory]

  CEO_agent = StructuredAgent(model,"CEO",CEO_agent_description,CEO_agent_instructions,tools=CEO_tools,assistant_agents=[story_planner,story_writter],max_allowed_attempts=10,memory=memory)



  if __name__ =="__main__":

      
      

      user_input = input("User : ")

      
      messages = []

      
      while user_input != "bye":
          
          output = CEO_agent.run(user_input, messages)

          
          messages = CEO_agent.messages

          
          

          
          user_input = input("User Input : ")

  ```



  Here’s an example of async implementation:

  ```python
  import os,nest_asyncio,asyncio
  from CollabAgents.helper import print_colored
  from CollabAgents.agent import StructuredAgent
  from CollabAgents.models import OpenaiChatModel
  from CollabAgents.tools.FileOperationsTool import SaveFile, CreateFolder
  from CollabAgents.memory import ConversationSummaryBufferMemory,ConversationSummaryMemory,ConversationBufferWindowMemory,ConversationBufferMemory






  description = "Responsible for writing story."


  instruction = "You are a creative storyteller who crafts imaginative narratives with vivid details, rich characters, and unexpected plot twists."



  tools = [CreateFolder, SaveFile]


  openai_api_key = "Your API Key"



  model = OpenaiChatModel(model_name="gpt-4o-mini", api_key=openai_api_key, temperature=0)





  memory = ConversationBufferMemory()















  agent = StructuredAgent(model=model, agent_name="AI Assistant", agent_description=description, agent_instructions=instruction, tools=tools, assistant_agents=[],max_allowed_attempts=50, verbose=True,memory=memory)

  if __name__ =="__main__":

      async def main():

          print_colored("Starting the application...........", "green")

          
          

          user_input = input("User : ")

          
          messages = []

          
          while user_input != "bye":

              
              output = await agent.arun(user_input, messages)

              
              messages = agent.messages

              
              

              
              user_input = input("User Input : ")

      asyncio.run(main())

  ```



  <a href="https://www.youtube.com/@learnwithvichu" style="display: flex; align-items: center; text-decoration: none;">
      <img src="https://img.shields.io/badge/YouTube-%23FF0000.svg?style=for-the-badge&logo=YouTube&logoColor=white" alt="YouTube Channel" width="150"/>
  </a>



  <a href="https://www.linkedin.com/in/vishnu-d-121650167" style="display: flex; align-items: center; text-decoration: none;">
      <img src="https://img.shields.io/badge/LinkedIn-%230077B5.svg?style=for-the-badge&logo=LinkedIn&logoColor=white" alt="LinkedIn Profile" width="150"/>
  </a>



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


pkgId: 522f437f0e959b7bdfde8d9ea22f460acd008ac7dab2ac614f766ee6bb328982
name: python-CollabConnector
arch: src
version: 0.1.1723827163
epoch: 0
release: 1
summary: An attempt at a simplified API collection for Cisco Collab products
url: https://github.com/mycollablab/CollabConnector
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CollabConnector-0.1.1723827163-1.src.rpm
checksum_type: sha256
description:
   Cisco Collab Connector Library

  This library is made to try and be a single source for all Cisco Collab APIs (which can be lots). The goal is to unify requests and responses across different REST and SOAP APIs availble to make connecting to and scripting Collab tasks easier.  Hopefully.  Maybe.

  Install:
  ```
  pip3 install CollabConnector
  ```

  Usage:
  ```commandline
  >>> from CollabConnector import CUCM
  >>> from CollabConnector import CUCX
  >>> from CollabConnector import UCCX
  >>> from CollabConnector.Webex import Webex

  >>> cucm = CUCM.Connect("10.10.10.10", "admin", "P@ssw0rd")
  >>> cucm.query("select count(*) from enduser")
  [{'count': '5'}]
  >>> cucm.get.Phone(name="SEP3C08F67A9618")
  [{'name': 'SEP3C08F67A9618', 'description': 'Auto 1000', 'product': 'Cisco 7841', 'mod... }]
  >>> cucm.uds.get("version")
  {'@uri': 'https://10.10.10.10:8443/cucm-uds/version', '@version': '12.5.1', 'version': '12.5.1', 'capabil... }]
  >>> cucm.ast.cluster
  {'cluster_name': 'StandAloneCluster', 'nodes': ['cucm-01.lab-01.mycollablab.org', 'cucm-02.lab-01.mycollablab.org'], 'service...}]
  >>> cucm.serviceability.status("Cisco Tftp")
  {'cucm-01.lab-01.mycollablab.org': {'Cisco Tftp': {'ServiceName': 'Cisco Tftp', 'ServiceStatus': 'Started', 'ReasonCode': -1, 'Rea...}]
  >>> cucm.registration_status("SEP3C08F67A9618")
  {'SEP3C08F67A9618': {'name': 'SEP3C08F67A9618', 'node': ..., 'firmware': 'sip78xx.12-7-1-0001-393', 'IPAddress': ..., 'dirn': '1000', 'status': 'Registered'}}

  >>> unity = CUCX.Connect("10.10.10.20", "admin", "P@ssw0rd")
  >>> unity.get("users")
  [{'URI': '/vmrest/users/a151...123', 'ObjectId': 'a151...123', 'Alias': 'undeliverablemess... }]
  >>> unity.get("/vmrest/users", DtmfAccessId="10*", sort="DtmfAccessId")
  [{'URI': ..., 'ObjectId': ..., 'FirstName': '', 'LastName': '', 'Alias': '1000', 'DisplayName': '1000', 'EmailAddress': '', ... }]

  >>> ccx = UCCX.Connect("10.10.10.40", "admin", "P@ssw0rd")
  >>> ccx.get("application")
  [{'@type': 'applicationXMLList', 'application': []}]

  >>> wbx = Webex.Connect(token)
  >>> wbx.get("/v1/people/me")
  {'id': 'Y2l...mYTg', 'emails': ['jsn....com'], 'phoneNumbers': [{'type': 'work', 'value': '2001'}, ...}]
  ```

  Notes:
  The AXL SOAP API was generated based on the version 14 WSDL files and may not be complete or function depending on version. A version specific SOAP client is built at CollabConnector.CUCM.axl and can be leveraged as a backup as needed, however no post call treatment is made so soap responses will need to be sterilized etc if used.
  ```commandline
  >>> from CollabConnector import CUCM

  >>> cucm = CUCM.Connect("10.10.10.10", "admin", "P@ssw0rd")
  >>> cucm.axl.getPhone(name="SEPAAAABBBBCCCC")
  [{'name': 'SEP3C08F67A9618', 'description': 'Auto 1000', 'product': 'Cisco 7841', 'mod... }]
  ```


pkgId: 734f660048abff405ec484311d878c12b7de9b5c44c160f1c4702660071c342d
name: python-Collectfast
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: A Faster Collectstatic
url: https://github.com/antonagestam/collectfast/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Collectfast-2.2.0-1.src.rpm
checksum_type: sha256
description:
  collectfast.strategies.boto3.Boto3Strategy|storages.backends.s3boto3.S3Boto3Storage
  collectfast.strategies.gcloud.GoogleCloudStrategy|storages.backends.gcloud.GoogleCloudStorage
  collectfast.strategies.filesystem.FileSystemStrategy|django.core.files.storage.FileSystemStorage
  Custom strategies can also be made for backends not listed above by
  implementing the `collectfast.strategies.Strategy` ABC.

  Collectfast overrides Django's builtin `collectstatic` command so just run
  `python manage.py collectstatic` as normal.
  You can disable Collectfast by using the `--disable-collectfast` option or by
  setting `COLLECTFAST_ENABLED = False` in your settings file.

  It's recommended to setup a dedicated cache backend for Collectfast. Every time
  Collectfast does not find a lookup for a file in the cache it will trigger a
  lookup to the storage backend, so it's recommended to have a fairly high
  `TIMEOUT` setting.
  Configure your dedicated cache with the `COLLECTFAST_CACHE` setting:
  ```python
  CACHES = {
      'default': {
          
      },
      'collectfast': {
          
      },
  }
  COLLECTFAST_CACHE = 'collectfast'
  ```
  If `COLLECTFAST_CACHE` isn't set, the `default` cache will be used.
  **Note:** Collectfast will never clean the cache of obsolete files. To clean
  out the entire cache, use `cache.clear()`. [See docs for Django's cache
  framework][django-cache].
  **Note:** We recommend you to set the `MAX_ENTRIES` setting if you have more
  than 300 static files, see [#47][issue-47].
  [django-cache]: https://docs.djangoproject.com/en/stable/topics/cache/
  [issue-47]: https://github.com/antonagestam/collectfast/issues/47

  The parallelization feature enables parallel file uploads using Python's
  `concurrent.futures` module. Enable it by setting the `COLLECTFAST_THREADS`
  setting.
  To enable parallel uploads, a dedicated cache backend must be setup and it must
  use a backend that is thread-safe, i.e. something other than Django's default
  LocMemCache.
  ```python
  COLLECTFAST_THREADS = 20
  ```

  By default, Collectfast will suppress any exceptions that happens when copying
  and let Django's `collectstatic` handle it. To debug those suppressed errors
  you can set `COLLECTFAST_DEBUG = True` in your Django settings file.

  Please feel free to contribute by using issues and pull requests. Discussion is
  open and welcome.

  The test suite is built to run against live S3 and GCloud buckets. You can
  disable live tests by setting `SKIP_LIVE_TESTS=true` or running `make
  test-skip-live`. To run live tests locally you need to provide API credentials
  to test against. Add the credentials to a file named `storage-credentials` in
  the root of the project directory:
  ```bash
  export AWS_ACCESS_KEY_ID='...'
  export AWS_SECRET_ACCESS_KEY='...'
  export GCLOUD_CREDENTIALS='{...}'  # Google Cloud credentials as JSON
  ```
  Install test dependencies and target Django version:
  ```bash
  python3 -m pip install -r test-requirements.txt
  python3 -m pip install django==2.2
  ```
  Run test suite:
  ```bash
  make test
  ```
  Code quality tools are broken out from test requirements because some of them
  only install on Python >= 3.7.
  ```bash
  python3 -m pip install -r lint-requirements.txt
  ```
  Run linters and static type check:
  ```bash
  make lint
  ```

  Collectfast is licensed under the MIT License, see LICENSE file for more
  information.


pkgId: cf1f4c397fa3e06d77ac33ef481b642c0ae59dfd63bc8d4fa1a52835d9e6a8f3
name: python-Collectfasta
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: A Faster Collectstatic
url: https://github.com/jasongi/collectfasta/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Collectfasta-3.2.0-1.src.rpm
checksum_type: sha256
description:
  collectfasta.strategies.boto3.Boto3Strategy|storages.backends.s3.S3Storage
  collectfasta.strategies.boto3.Boto3Strategy|storages.backends.s3.S3StaticStorage
  collectfasta.strategies.boto3.Boto3ManifestMemoryStrategy (recommended)|storages.backends.s3.S3ManifestStaticStorage
  collectfasta.strategies.boto3.Boto3ManifestFileSystemStrategy|storages.backends.s3.S3ManifestStaticStorage
  collectfasta.strategies.gcloud.GoogleCloudStrategy|storages.backends.gcloud.GoogleCloudStorage
  collectfasta.strategies.filesystem.FileSystemStrategy|django.core.files.storage.FileSystemStorage
  Custom strategies can also be made for backends not listed above by
  implementing the `collectfasta.strategies.Strategy` ABC.

  Collectfasta overrides Django's builtin `collectstatic` command so just run
  `python manage.py collectstatic` as normal.
  You can disable Collectfasta by using the `--disable-collectfasta` option or by
  setting `COLLECTFASTA_ENABLED = False` in your settings file.

  It's recommended to setup a dedicated cache backend for Collectfasta. Every time
  Collectfasta does not find a lookup for a file in the cache it will trigger a
  lookup to the storage backend, so it's recommended to have a fairly high
  `TIMEOUT` setting.
  Configure your dedicated cache with the `COLLECTFASTA_CACHE` setting:
  ```python
  CACHES = {
      "default": {
          
      },
      "collectfasta": {
          
      },
  }
  COLLECTFASTA_CACHE = "collectfasta"
  ```
  If `COLLECTFASTA_CACHE` isn't set, the `default` cache will be used.
  **Note:** Collectfasta will never clean the cache of obsolete files. To clean
  out the entire cache, use `cache.clear()`. [See docs for Django's cache
  framework][django-cache].
  **Note:** We recommend you to set the `MAX_ENTRIES` setting if you have more
  than 300 static files, see [#47][issue-47].
  [django-cache]: https://docs.djangoproject.com/en/stable/topics/cache/
  [issue-47]: https://github.com/antonagestam/collectfast/issues/47

  The parallelization feature enables parallel file uploads using Python's
  `concurrent.futures` module. Enable it by setting the `COLLECTFASTA_THREADS`
  setting.
  To enable parallel uploads, a dedicated cache backend must be setup and it must
  use a backend that is thread-safe, i.e. something other than Django's default
  LocMemCache.
  ```python
  COLLECTFASTA_THREADS = 20
  ```

  By default, Collectfasta will suppress any exceptions that happens when copying
  and let Django's `collectstatic` handle it. To debug those suppressed errors
  you can set `COLLECTFASTA_DEBUG = True` in your Django settings file.

  Please feel free to contribute by using issues and pull requests. Discussion is
  open and welcome.

  The test suite is built to run against localstack / fake-gcs-server OR live S3 and GCloud buckets.
  To run live tests locally you need to provide API credentials to test against as environment variables.
  ```bash
  export AWS_ACCESS_KEY_ID='...'
  export AWS_SECRET_ACCESS_KEY='...'
  export GCLOUD_API_CREDENTIALS_BASE64='{...}'  # Google Cloud credentials as Base64'd json
  ```
  Install test dependencies and target Django version:
  ```bash
  python3 -m pip install -r test-requirements.txt
  python3 -m pip install django==5.0.2
  ```
  Run test suite:
  ```bash
  make test
  ```
  Run test against localstack/fake-gcs-server:
  ```bash
  make test-docker
  ```
  Code quality tools are broken out from test requirements because some of them
  only install on Python >= 3.7.
  ```bash
  python3 -m pip install -r lint-requirements.txt
  ```
  Run linters and static type check:
  ```bash
  make lint
  ```

  Collectfasta is licensed under the MIT License, see LICENSE file for more
  information.


pkgId: 42e8b06dc87f591c192ff07e1956b0f571c5c19673d93ae124ef7c1f9c999b01
name: python-ColorFlow
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://pypi.org/project/ColorFlow/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColorFlow-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  A Python library for creating and applying full-color, linear, and circular gradients to text with easy color management.

description:
  - Comprehensive **color presets**
  - Create colors using **RGB**, **HSL**, or **HTML hex codes**
  - Generate **linear** and **circular** gradients
  - Apply gradients to multi-line text
  - Support for **color interpolation**


pkgId: 529c350510581c5af2604d6fd858240f74f7c2b0bc7c7ccdad700a3c56499983
name: python-ColorFlow
arch: src
version: 2.0.0
epoch: 0
release: 1
url: https://pypi.org/project/ColorFlow/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColorFlow-2.0.0-1.src.rpm
checksum_type: sha256
summary:
  A Python library for creating and applying full-color, linear, and circular gradients to text with easy color management.

description:
  A Python library for creating stunning color gradients, including full-color, and applying them to text. It supports both linear and circular gradients with comprehensive color management tools.



  Install ColorFlow using pip:

  ```bash
  pip install colorflow
  ```



  ColorFlow introduces flexible color layer control, allowing developers to apply colors to text with precision. Developers can choose to color the foreground text, background, or both simultaneously.

  ```python
  from colorflow import Presets, ColorLayer

  blue = Presets.Blue


  print(blue("Blue Text", layer=ColorLayer.FOREGROUND))


  print(blue("Blue Background", layer=ColorLayer.BACKGROUND))


  print(blue("Blue Everywhere", layer=ColorLayer.BOTH))
  ```



  The library supports multiple color generation techniques, enabling developers to create colors through various input formats.

  ```python
  from colorflow import FromRGB, FromHTML, FromHSL


  custom_blue = FromRGB(0, 0, 255)


  web_red = FromHTML("#FF0000")


  pastel_green = FromHSL(120, 0.5, 0.6)


  ```



  ColorFlow provides a comprehensive collection of predefined colors, simplifying color selection for developers.

  ```python
  from colorflow import Presets

  blue = Presets.Blue
  red = Presets.Red
  green = Presets.Green
  ```



  The library supports both linear and radial color gradients, enabling sophisticated text color transitions.



  ```python
  from colorflow import ColorSequence, Presets, GradientType, ColorLayer

  gradient = ColorSequence({
      0: Presets.Blue,
      1: Presets.Red
  }, gradient_type=GradientType.LINEAR)

  print(gradient("Smooth color transition", layer=ColorLayer.FOREGROUND))
  ```



  ```python
  angular_gradient = ColorSequence({
      0: Presets.Blue,
      0.5: Presets.White,
      1: Presets.Red
  }, gradient_type=GradientType.RADIAL)

  print(angular_gradient("Radial color spread", layer=ColorLayer.FOREGROUND))
  ```



  Developers can create complex color mappings, assigning unique colors to individual characters.

  ```python
  from colorflow import MapCharsToColors, Presets, ColorLayer

  mapper = MapCharsToColors({
      'h': Presets.Red,
      'e': Presets.Green,
      'l': Presets.Blue,
      'o': Presets.Purple
  }, layer=ColorLayer.BOTH)

  print(mapper("hello"))
  ```



  ColorFlow offers random color generation with optional color palette constraints.

  ```python
  from colorflow import RandomColor, Presets

  random_color = RandomColor()  # Completely random
  specific_colors = RandomColor([Presets.Red, Presets.Green, Presets.Blue])
  ```



  Gradient coordinates are normalized between `(0, 0)` and `(1, 1)`:
  - `(0, 0)` represents the top-left corner
  - `(1, 1)` represents the bottom-right corner
  - `(0.5, 0.5)` indicates the center point



  Distributed under the MIT License.


pkgId: 85eab38eed31d7a30fba23f93a9a28090f87e6f44c1fa68c91a6d90a4586ed2e
name: python-ColorInfo
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: ColorInfo 是一个使用Python3编写的简单的彩色日志工具，拥有简单、友好的语法,采用纯原始功能实现,无需依赖任何第三方模块
url: https://gitee.com/liumou_site/ColorInfo
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColorInfo-2.2.0-1.src.rpm
checksum_type: sha256
description:
  ColorInfo 是一个使用Python3编写的简单的彩色日志工具,主要特性:

  * 使用简单
  * 彩色输出
  * 中文注释
  * 支持全部Python3版本(>=3.0)





  * 独立实例参数配置




  执行下面的命令即可

  ```shell
  pip3 install --upgrade ColorInfo
  ```



  ```

  """
  @File    :   demo.py
  @Time    :   2022-10-26 23:51
  @Author  :   坐公交也用券
  @Version :   1.0
  @Contact :   liumou.site@qq.com
  @Homepage : https://liumou.site
  @Desc    :   演示
  """
  from ColorInfo import ColorLogger

  log = ColorLogger(txt=True, fileinfo=True, basename=False)
  log.info(msg='1', x="23")
  log.error('2', '22', '222')
  log.debug('3', '21')
  log.warning('4', '20', 22)
  ```



  请在`gitee`项目主页查看图片

  ![logg.png](./Demo.png)



  [https://pypi.org/project/ColorInfo/](https://pypi.org/project/ColorInfo/)

  [https://gitee.com/liumou_site/ColorInfo.git](https://gitee.com/liumou_site/ColorInfo.git)


pkgId: 810dbf0da77c2af4073e9812382d8ab5129c62fb7fec6b40788e1b610a8bef40
name: python-ColorReliefEditor
arch: src
version: 0.1.10
epoch: 0
release: 1
url: https://github.com/corb555/colorReliefEditor
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColorReliefEditor-0.1.10-1.src.rpm
checksum_type: sha256
summary:
  Editor for the color text file used by gdaldem color-relief.  Display the colors and allow you to edit colors and elevations

description:
  ![screenshot](https://github.com/corb555/ColorReliefEditor/blob/8b9dc20a4ae7fdd0e1b266afe9492fbab3d42d52/colorrelief.png)

  An editor for the color definition file used by the gdaldem color-relief utility. This tool displays the color for each elevation
  and allows you to edit each color and elevation.
  gdaldem generates a color relief map based on defining colors for each elevation based on a file.
  For details on gdaldem:  https://gdal.org/programs/gdaldem.html


  `python3 -m pip install "ColorReliefEditor"`


  `python3 ColorReliefEditor`
  This will display a file dialog filtered for *.txt

  This will edit a color relief file which contains lines of the format:
  _elevation_value red green blue_


pkgId: 8b99c38f8eadb550e3eee585e89c1c756d4d436442da6bbe4e9565365954e8a4
name: python-ColoreRegioni
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://github.com/MCilento93/ColoreRegioni
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColoreRegioni-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  Web-scraping del sito del governo italiano per la classificazione delle misure restrittive regionali

description:
  [![Build Status](https://travis-ci.com/MCilento93/ColoreRegioni.svg)](https://travis-ci.com/MCilento93/ColoreRegioni)
  [![Coverage Status](https://coveralls.io/repos/github/MCilento93/ColoreRegioni/badge.svg)](https://coveralls.io/github/MCilento93/ColoreRegioni)
  [![PyPI](https://img.shields.io/pypi/v/ColoreRegioni)](https://pypi.org/project/ColoreRegioni/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/ColoreRegioni)](https://pypistats.org/packages/coloreregioni)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ColoreRegioni)
  ![PyPI - Wheel](https://img.shields.io/pypi/wheel/ColoreRegioni)
  ![GitHub contributors](https://img.shields.io/github/contributors/MCilento93/ColoreRegioni)
  ![GitHub issues](https://img.shields.io/github/issues-raw/MCilento93/ColoreRegioni)
  ![GitHub](https://img.shields.io/github/license/MCilento93/ColoreRegioni)

  Web-scraping del **[sito del governo italiano](http://www.governo.it/it/articolo/domande-frequenti-sulle-misure-adottate-dal-governo/15638?gclid=CjwKCAiAwrf-BRA9EiwAUWwKXicC1bzopYynHP9pvRxHUza7Ar4dte9hWHi55Uj4xfuAHanOCf7a1BoCTggQAvD_BwE)** per la classificazione delle misure restrittive regionali per COVID-19.
  Denominazione regione in accordo a [nomenclatura istat](https://www.istat.it/it/archivio/6789).


  ```
  pip install ColoreRegioni
  ```


  La classe ColoreRegioni() restituisce il dizionario con il colore e la corrispondente emoji:
  ```
  from ColoreRegioni import ColoreRegioni

  colore_regioni=ColoreRegioni()
  full_dict=colore_regioni.colori_emoji
  ```
  ![full_dict](https://github.com/MCilento93/ColoreRegioni/blob/main/images/full_dict.png?raw=true)</br>
  Disponibili anche i risultati parziali:
  ```
  denominazioni=colore_regioni.denominazioni
  dict_only_colors=colore_regioni.colori
  dict_only_emoji=colore_regioni.emoji
  ```


  Il software Ã¨ liceziato con licenza **[MIT](LICENSE)** (c) 2020 GitHub, Inc.


  * [checoloresono.info](https://checoloresono.info/#/) di **[Azzeccagarbugli](https://github.com/Azzeccagarbugli/checoloresono)**
  * [coronavirusitaliamap](https://coronavirusitaliamap.altervista.org/) di **Stefano Quaggio**


pkgId: 75a56d3ea930c48e3d86aebf5d63e851f0332203fe7f5b26c226abd17166fbbf
name: python-Colorthon
arch: src
version: 2.9.6
epoch: 0
release: 1
summary: Colorthon Best and Fast Package For Generating Color For Text Color and Back Color Text Format
url: https://github.com/colorthon/colorthon
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Colorthon-2.9.6-1.src.rpm
checksum_type: sha256
description:
  Colorthon is a powerful Python package that provides a simple and intuitive way to work with colors in the terminal.



  - Easy-to-use syntax for applying colors and background colors to text in the terminal.
  - Supports a wide range of colors and background colors.
  - Lightweight and efficient implementation.



  You can install Colorthon using pip:

  ```shell
  pip install colorthon

  pip3 install colorthon
  ```



  To start using Colorthon, import the Colors and Back modules:

  ```python
  from colorthon import Colors, Back

  ```
  Now, you can use the color and background color codes provided by Colorthon. For example, you can define the following color variables:

  ```python
  from colorthon import Colors, Back


  red = Colors.RED
  green = Colors.GREEN
  blue = Colors.BLUE
  black = Colors.BLACK
  magenta = Colors.MAGENTA
  yellow = Colors.YELLOW
  cyan = Colors.CYAN
  white = Colors.WHITE

  on_red = Back.RED
  on_green = Back.GREEN
  on_blue = Back.BLUE
  on_yellow = Back.YELLOW
  on_white = Back.WHITE
  on_magenta = Back.MAGENTA
  on_cyan = Back.CYAN
  on_black = Back.BLACK

  reset = Colors.RESET
  ```

  These variables allow you to easily apply colors and background colors to your text. Here's an example usage:

  ```python
  print(f"{red}This text is red.{reset}")
  print(f"{green}This text is green.{reset}")
  print(f"{on_red}This text has a red background.{reset}")
  print(f"{on_green}This text has a green background.{reset}")

  ```


  Contributions are welcome! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request. Make sure to read our Contribution Guidelines before getting started.



  This project is licensed under the MIT License.
  Contact

  If you have any questions or need support, feel free to reach out to us at pymmdrza@gmail.com We'd be happy to assist you!


  other package :

  **_Blockthon_** - _Generate Easy and Fast Private Key & Mnemonic and Decimal , Binary & seed (Bytes)_ , Compress and UnCompress address Bitcoin , Ethereum , TRON, Dogecoin, Litecoin, zcash, Digibyte, Dash, Qtum, Ravencoin, BitcoinGold

  programmer and Owner Website : [Mmdrza.Com](https://mmdrza.com)


pkgId: a2066cb382c90cefc1d9b2b9426e26fa978d31a469a49fa24cc989dc36e3c05f
name: python-ColourScript
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A small package for functionality with text
url: https://google.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColourScript-0.0.1-1.src.rpm
checksum_type: sha256
description:
  This is a simple package to manipulate colour in strings in Python.
  More functionality being added in later versions.

  >Authored by Tariq Tayebi 2024 Sydney, Australia


pkgId: 180c86e1de5608bc672326861e9435ac7a26a0ee2b053d47bb5368a09e1ba8df
name: python-ColourScript
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: A package for functionality with text, escape codes octal and hexadecimal codes, and other data.
url: https://colourscript-documentation.readthedocs.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColourScript-0.0.6-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/colourscript)](https://pypi.org/project/ColourScript/)
  [![PyPI Licence](https://img.shields.io/pypi/l/colourscript.svg?v=1)](https://pypi.org/search/?c=License+%3A%3A+OSI+Approved+%3A%3A+MIT+License)


  This is a simple yet effective package to manipulate ASCII and other codes in Python.
  More functionality being added in later versions. Data has been added in version 0.0.6 and above.

  >Authored by Tariq Tayebi 2024 Sydney, Australia


pkgId: 35e6c3e93594362e6a09863c86a8be3242ee593656c6a58941ee99a6f688f042
name: python-ColourScript
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: A package for functionality with text, escape codes, octal and hexadecimal codes, and other data.
url: https://colourscript-documentation.readthedocs.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ColourScript-0.0.9-1.src.rpm
checksum_type: sha256
description:
  ![https://raw.githubusercontent.com/TariqTheCoder/ColourScript-Documentation/refs/heads/main/Screenshot%202024-11-22%20191301.png](https://raw.githubusercontent.com/TariqTheCoder/ColourScript-Documentation/refs/heads/main/Screenshot%202024-11-22%20191301.png)


  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/colourscript)](https://pypi.org/project/ColourScript/)
  [![PyPI Licence](https://img.shields.io/pypi/l/colourscript.svg?v=1)](https://pypi.org/search/?c=License+%3A%3A+OSI+Approved+%3A%3A+MIT+License)
  [![Docs Status](https://readthedocs.org/projects/colourscript-documentation/badge/?version=latest)]()


  This is a simple yet effective package to manipulate ASCII and other codes in Python.
  More functionality has been added in later versions: Data has been added in version 0.0.6 and above.
  - ASCII escape codes
  - RGB codes for functionality not found in native Python
  - Data
  - Characters and functionality for strings and output

  >Authored by Tariq Tayebi: 2024 Sydney, Australia


pkgId: 7bde2a082ab7fcce9492f8a21d17063a360ed4ec96601d7de8820bce6f224a2f
name: python-Colr
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Easy terminal colors, with chainable methods.
url: https://github.com/welbornprod/colr
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Colr-0.9.1-1.src.rpm
checksum_type: sha256
description:
  A python module for using terminal colors. It contains a simple
  ``color`` function that accepts style and color names, and outputs a
  string with escape codes, but also has all colors and styles as


pkgId: 32810be1fd32202a53ca9b20231eb0dd1e578756433162ee218a4a5f73e45961
name: python-CombCov
arch: src
version: 0.6.5
epoch: 0
release: 1
summary: Searching for combinatorial covers.
url: https://github.com/PermutaTriangle/CombCov
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CombCov-0.6.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/travis/PermutaTriangle/CombCov.svg?label=Linux%20CI&logo=travis&logoColor=white)](https://travis-ci.org/PermutaTriangle/CombCov)
  [![Coverage Status](https://img.shields.io/coveralls/github/PermutaTriangle/CombCov.svg)](https://coveralls.io/github/PermutaTriangle/CombCov)
  [![Requirements Status](https://img.shields.io/requires/github/PermutaTriangle/CombCov.svg)](https://requires.io/github/PermutaTriangle/CombCov/requirements)
  [![Licence](https://img.shields.io/github/license/PermutaTriangle/CombCov.svg)](https://raw.githubusercontent.com/PermutaTriangle/CombCov/master/LICENSE)

  [![PyPi Version](https://img.shields.io/pypi/v/CombCov.svg)](https://pypi.org/project/CombCov/)
  [![PyPi Downloads](https://img.shields.io/pypi/dm/CombCov.svg)](https://pypi.org/project/CombCov/)
  [![Python Implementation](https://img.shields.io/pypi/implementation/CombCov.svg)](https://pypi.org/project/CombCov/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/CombCov.svg)](https://pypi.org/project/CombCov/)

  A generalization of the permutation-specific algorithm [Struct](https://github.com/PermutaTriangle/PermStruct) --
  extended for other types of combinatorial objects.




  Take a look at the `demo/` folder in this repo to see examples on how to use
  `CombCov` with your own combinatorial object. On example finds a _Word Set_
  cover for the set of words over the alphabet `{a,b}` that avoids the subword
  `aa` (meaning no words in the set contains `aa` as a subword).

  ```bash
  $ python -m demo.word_set
  [INFO] (CombCov) Enumerating all elements of size up to 7...
  [INFO] (CombCov) ...DONE enumerating elements! (Running time: 0.00 sec)
  [INFO] (CombCov) Total of 87 elements.
  [INFO] (CombCov) Enumeration: [1, 2, 3, 5, 8, 13, 21, 34]
  [INFO] (CombCov) Creating binary strings and rules...
  [INFO] (CombCov) Bitstring to cover: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
  [INFO] (WordSet) Generated 16 subrules
  [INFO] (CombCov) ...DONE creating binary strings and rules! (Running time: 0.00 sec)
  [INFO] (CombCov) Total of 14 valid rules with 14 distinct binary strings.
  [INFO] (CombCov) Searching for a cover for ''*Av(aa) over ∑={a,b}...
  [INFO] (CombCov) Gurobi installed on system and set as solver
  [INFO] (CombCov) ...DONE searching for a cover! (Running time: 0.02 sec)
  Solution found!
   - Rule #1 with bitstring 000000000000000000000000000000000000000000000000000000000000000000000000000000000000001: ''*Av(a,b) over ∑={a,b}
   - Rule #2 with bitstring 000000000000000000000000000000000000000000000000000000000000000000000000000000000000010: 'a'*Av(a,b) over ∑={a,b}
   - Rule #3 with bitstring 111111111111111111111000000000000011111111111110000000011111111000001111100011100110100: 'b'*Av(aa) over ∑={a,b}
   - Rule #4 with bitstring 000000000000000000000111111111111100000000000001111111100000000111110000011100011001000: 'ab'*Av(aa) over ∑={a,b}

  ```




  Run unittests (with coverage for the `demo` module as well):

  ```bash
  ./setup.py test --addopts --cov=demo
  ```


pkgId: 8a852dcce2ad1605987427fb72d19049f0f601e5cbcd2c984303f2271f297564
name: python-Comel
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Opinionated PySide6 Light/Dark Theme Toggler.
url: https://github.com/hueyyeng/Comel
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Comel-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Opinionated PySide6 Light/Dark Theme Toggler. Oh wait yet another ~~Qt for Python~~ PySide6 light/dark theme package?
  Yes it is!

  ![](docs/images/comel_takusan.gif)

  > **ATTENTION:** This package is designed with writing/deploying standalone PySide6 application in mind.



  1. Custom QMainWindow widget with built-in light/dark mode toggler. Connect the `toggle_theme` function to QtWidgets
     callback function and you're done.
  2. Very simple package (for now). Not bloated from trying to cater various Qt for Python packages.



  Last tested with **Python 3.10+** but any Python version that PySide6 supports. Highly recommend using virtual
  environment when testing/implementing this.



  ```shell
  pip install Comel
  ```



  Clone this repo and copy the `comel` package into your project. Ensure both `darkdetect` and `PySide6` is installed in
  your Python environment.



  Import `ComelMainWindowWrapper` class and connect `toggle_theme` to a widget action. That's it!

  Refer to examples directory for `barebone_app.py` for boilerplate code or `takusan_app.py` for a typical PySide app
  written from scratch without using Qt Designer.



  There is **CCheckBox** and **CRadioButton** which uses custom icons and size override. Using the regular **QCheckBox**
  and
  **QRadioButton** will result in bigger than usual size as it displays the 32x32 size icon image.



  ```shell

  python examples/barebone_app.py


  python examples/takusan_app.py


  python examples/check_disabled_state_app.py
  ```



  > Refer to https://doc.qt.io/qt-6/stylesheet-examples.html for examples on the correct CSS selectors. Search on Stack
  > Overflow/Qt Forum/etc if you cannot find the specific CSS selectors.

  1. Edit `base.qss` and `presets.py` with the relevant variable and color.
  2. Run `generate_qss.py` to generate `light.qss` and `dark.qss` located in `qss/themes` and `comel/themes` folder.



  1. The default Qt arrow icons does not play nicely when using Qt Style Sheets. While there is a way to bundle custom
     icons, I'm not fancy with the extra steps needed to compile Qt `.qrc` into Python file. I might create wrapper class
     for the affected widgets in future updates.
  2. This library does not cover every single widget styles. Create an issue if you encounter a widget that is missing
     either light or dark styling.
  3. **QMdiArea** and **QMdiSubWindow** is missing the window resize handle after applying Comel stylesheets. Suspecting
     one of the selector override to be the root cause.



  ![](examples/icons/icons8-fat-cat-96.png)

  Qt is pronounced as "cute". Comel means **cute** in Bahasa Melayu aka Malay language. Also, the name of my childhood
  cat.



  - Uses [darkdetect](https://github.com/albertosottile/darkdetect) for detecting the operating system dark mode.
  - Uses icons from [Icons8](https://icons8.com).
  - Special thanks to [izzthedude](https://github.com/izzthedude) for experimenting with this idea.

rpm_license:
  MIT License  Copyright (c) 2022 Huey Yeng  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: bf83e5a73342464d58bbc88ae64311e3881d23f8dc798657470789b53c38876e
name: python-ComfyUI-EasyNodes
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: Makes creating new nodes for ComfyUI a breeze.
url: https://github.com/andrewharp/ComfyUI-EasyNodes
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ComfyUI-EasyNodes-1.2.7-1.src.rpm
checksum_type: sha256
description:
  This package aims to make adding new [ComfyUI](https://github.com/comfyanonymous/ComfyUI) nodes as easy as possible, allowing you to write basic annotated Python and automatically turn it into a ComfyUI node definition via a simple `@ComfyNode` annotation.

  For example:
  ```python
  from easy_nodes import ComfyNode, ImageTensor, MaskTensor, NumberInput

  @ComfyNode(color="#0066cc", bg_color="#ffcc00", return_names=["Below", "Above"])
  def threshold_image(image: ImageTensor,
                      threshold: float = NumberInput(0.5, 0, 1, 0.01, display="slider")) -> tuple[MaskTensor, MaskTensor]:
      """Returns separate masks for values above and below the threshold value."""
      mask_below = torch.any(image < threshold, dim=-1)
      return mask_below.float(), (~mask_below).float()
  ```

  That (plus [a tiny bit of initialization](#installation) in `__init__.py`) and your node is ready for ComfyUI!

  In addition, it provides enhanced node customization previously only available with custom JavaScript (e.g. color, and adding preview images/text), and several general ComfyUI quality of life improvements.

  More examples can be found [here](example/example_nodes.py).




  - **@ComfyNode Decorator**: Simplifies custom node declaration with automagic node definition based on Python type annotations. Just write annotated Python and turn your functions into nodes with a simple @ComfyNode decorator.
  - **ComfyUI Type Support**: Includes common types (e.g., ImageTensor, MaskTensor) to support ComfyUI's connection semantics. Register your own custom types with `easy_nodes.register_type()`
  - **Widget Support**: Special classes (StringInput, NumberInput and Choice) provide full support for ComfyUI's widget behavior when used as defaults to int, float and string inputs.
  - **Automatic List and Tuple Handling**: Simplifies input/output for functions expecting or returning collections.
  - **Init-time andChecking**: Provides early alerts for common setup issues like duplicate node definitions.
  - **Built-in Text and Image Previews**: Easily add previews to nodes without JavaScript using `easy_nodes.show_text()` and `easy_nodes.show_image()`.
  - **Change node defaults**: Set node colors and initial dimensions via the decorator, also avoiding the need to write custom JavaScript.


  - **Dynamic Node Creation**: Automatically create nodes from existing Python classes, adding widgets for every field (for basic types like string, int and float).
  - **ComfyUI Node Definition Support**: Includes options for validate_input, is_output_node, and other ComfyUI-specific features.
  - **Log Streaming**: Stream node logs directly to the browser for real-time debugging. Just hover the mouse over the 📜 icon to show the latest captured log from that node in a pop-up window, or click through to open in a new tab.
  - **Deep Source Links**: Quick access to the source code for your nodes in IDEs or GitHub when base paths are configured in options.
  - **Info Tooltips**: Auto-generated from function docstrings.
  - **Custom Type Verification**: Verify tensor shapes and data types according to catch problematic behavior early.
  - **LLM-based Debugging**: Optional ChatGPT-powered debugging and automatic code fixing for exceptions during node execution.


  - **Better Stack Traces**: Enhanced exception windows with deep source links when configured (works for all nodes).
  - **Preview Image Persistence**: Keep your preview images across browser sessions, so that you don't have to re-run your prompts just to see them again.
  - **Automatic Module Reloading**: Immediately see code changes to EasyNodes nodes on the next run with this optional setting, saving you time that would normally be spent restarting ComfyUI.



  |||
  |------|-------|
  |<img src="assets/threshold_example.png" alt="basic example" style="width: 100%;">New icons on node titlebars: Logs, Info, and Source.<br>Node colors set via @ComfyNode decorator.|<img src="assets/log_streaming.png" alt="Log streaming" style="width: 100%;">Live log streaming. Just hover over the 📜 icon, and click the pin to make the window persistent.|
  |<img src="assets/menu_options.png" alt="New menu options" style="width: 100%;">All options.|<img src="assets/exceptions.png" alt="Better stack traces">Better stack traces. Set the stack trace prefix to get prettier dialogues with links directly to the source locations.|






  - Stream node logs right to your browser; when an EasyNode is run it will show a log icon on the title bar. Clicking this will open up a new tab where you can see the logs accumulated during that node's execution. Icon rendering can be disabled via settings option if you want to keep things cleaner; in this case access via right-click menu option.
  - Added save_node_list function to export nodes to a json file. This can be helpful e.g. for ingestion by ComfyUI-Manager.
  - Set default node width and height, and add force_input to NumberInput (thanks isaacwasserman)
  - Retain preview images across browser refreshes if option is enabled (applies to all ComfyUI nodes)
  - Bug fixes and cleanup.



  - Custom verifiers for types on input and output for your nodes. For example, it will automatically verify that images always have 1, 3 or 4 channels (B&W, RGB and RGBA). Set `verify_level` when calling initialize_easy_nodes to either CheckSeverityMode OFF, WARN, or FATAL (default is WARN). You can write your own verifiers. See [comfy_types.py](easy_nodes/comfy_types.py) for examples of types with verifiers.
  - Expanded ComfyUI type support. See [comfy_types.py](easy_nodes/comfy_types.py) for the full list of registered types.
  - Added warnings if relying on node auto-registration without explicitly asking for it (while also supporting get_node_mappings() at the same time). This is because the default for auto_register will change to False in a future release, in order to make ComfyUI-EasyNodes more easily findable by indexers like ComfyUI-Manager (which expects your nodes to be found in your `__init__.py`). Options:
    - If you wish to retain the previous behavior, you can enable auto-registration explicitly with `easy_nodes.initialize_easy_nodes(auto_register=True)`.
    - Otherwise, export your nodes the normal way as shown in the [installation](#installation) section.



  - Renamed to ComfyUI-EasyNodes from ComfyUI-Annotations to better reflect the package's goal (rather than the means)
    - Package is now `easy_nodes` rather than `comfy_annotations`
  - Now on pip/PyPI! ```pip install ComfyUI-EasyNodes```
  - Set node foreground and background color via Python argument, no JS required: `@ComfyNode(color="FF0000", bg_color="00FF00")`
  - Add previews to nodes without JavaScript. Just drop either of these in the body of your node's function:
    - `easy_nodes.show_text("hello world")`
    - `easy_nodes.show_image(image)`
  - Automatically create nodes from existing Python classes. The dynamic node will automatically add a widget for every field.
  - Info tooltip on nodes auto-generated from your function's docstring
  - New optional settings features:
    - Make images persist across browser refreshes via a settings option (provided they're still on the server)
    - Automatic module reloading: if you turn on the setting, immediately see the changes to code on the next run.
    - LLM-based debugging: optionally have ChatGPT take a crack at fixing your code
    - Deep links to source code if you set a base source path (e.g. to github or your IDE)
  - Bug fixes



  To use this module in your ComfyUI project, follow these steps:

  1. **Install the Module**: Run the following command to install the ComfyUI-EasyNodes module:

      ```bash
      pip install ComfyUI-EasyNodes
      ```
      or, if you want to have an editable version:
      ```bash
      git clone https://github.com/andrewharp/ComfyUI-EasyNodes
      pip install -e ComfyUI-EasyNodes
      ```
      Note that this is not a typical ComfyUI nodepack, so does not itself live under custom_nodes.

      However, after installing you can copy the example node directory into custom_nodes to test them out:
      ```bash
      git clone --depth=1 https://github.com/andrewharp/ComfyUI-EasyNodes.git /tmp/easynodes
      mv /tmp/easynodes/example $COMFYUI_DIR/custom_nodes/easynodes
      ```

  3. **Integrate into Your Project**:
      In `__init__.py`:

      ```python
      import easy_nodes
      easy_nodes.initialize_easy_nodes(default_category=my_category, auto_register=False)

      
      import your_node_module  # noqa: E402

      NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS = easy_nodes.get_node_mappings()

      
      __all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

      
      easy_nodes.save_node_list(os.path.join(os.path.dirname(__file__), "node_list.json"))
      ```

      You can also initialize with auto_register=True, in which case you won't have to do anything else after the import. However, this may be problematic for having your nodes indexed so will default to False in a future update (currently not setting it explicitly will auto-register and complain).




  The options passed to `easy_nodes.initialize_easy_nodes` will apply to all nodes registered until the next time `easy_nodes.initialize_easy_nodes` is called.

  The settings mostly control defaults and some optional features that I find nice to have, but which may not work for everybody, so some are turned off by default.

  - `default_category`: The default category for nodes. Defaults to "EasyNodes".
  - `auto_register`: Whether to automatically register nodes with ComfyUI (so you don't have to export). Previously defaulted to True; now defaults to half-true (will auto-register, allow you to export, and print a warning). In a future release will default to False.
  - `docstring_mode`: The mode for generating node descriptions that show up in tooltips. Defaults to AutoDescriptionMode.FULL.
  - `verify_level`: Whether to verify tensors for shape and data type according to ComfyUI type (MASK, IMAGE, etc). Runs on inputs and outputs. Can be set to CheckSeverityMode.OFF, WARN, or FATAL. Defaults to WARN, as I've made some assumptions about shapes that may not be universal.
  - `auto_move_tensors`: Whether to automatically move torch Tensors to the GPU before your function gets called, and then to the CPU on output. Defaults to False.




  1. **Annotate Functions with @ComfyNode**: Decorate your processing functions with `@ComfyNode`. The decorator accepts the following parameters:
     - `category`: Specifies the category under which the node will be listed in ComfyUI. Default is `"ComfyNode"`.
     - `display_name`: Optionally specifies a human-readable name for the node as it will appear in ComfyUI. If not provided, a name is generated based on the function name.
     - `workflow_name`: The internal unique identifier for this node type. If not provided, a name is generated based on the function name.
     - `description`: An optional description for the node. If not provided the function's docstring, if any, will be used according to `easy_nodes.docstring_mode`.
     - `is_output_node`: Maps to ComfyUI's IS_OUTPUT_NODE.
     - `return_types`: Maps to ComfyUI's RETURN_TYPES. Use if the return type of the function itself is dynamic.
     - `return_names`: Maps to ComfyUI's RETURN_NAMES.
     - `validate_inputs`: Maps to ComfyUI's VALIDATE_INPUTS.
     - `is_changed`: Maps to ComfyUI's IS_CHANGED.
     - `always_run`: Makes the node always run by generating a random IS_CHANGED.
     - `debug`: A boolean that makes this node print out extra information during its lifecycle.
     - `color`: Changes the node's color.
     - `bg_color`: Changes the node's color. If color is set and not bg_color, bg_color will just be a slightly darker color.
     - `width`: Default width for this node type on creation.
     - `height`: Default height for this node type on creation.

      Example:
      ```python
      from easy_nodes import ComfyNode, ImageTensor, NumberInput

      @ComfyNode(category="Image Processing",
                 display_name="Enhance Image",
                 is_output_node=True,
                 debug=True,
                 color="#FF00FF")
      def enhance_image(image: ImageTensor, factor: NumberInput(0.5, 0, 1, 0.1)) -> ImageTensor:
          output_image = enhance_my_image(image, factor)
          easy_nodes.show_image(output_image)  # Will show the image on the node, so you don't need a separate PreviewImage node.
          return output_image
      ```

  2. **Annotate your function inputs and outputs**: Fully annotate function parameters and return types, using `list` to wrap types as appropriate. `tuple[output1, output2]` should be used if you have multiple outputs, otherwise you can just return the naked type (in the example below, that would be `list[int]`). This information is used to generate the fields of the internal class definition `@ComfyNode` sends to ComfyUI. If you don't annotate the inputs, the input will be treated as a wildcard. If you don't annotate the output, you won't see anything at all in ComfyUI.

      Example:
      ```python
      @ComfyNode("Utilities")
      def add_value(img_list: list[ImageTensor], val: int) -> list[int]:
          return [img + val for img in img_list]
      ```



  Say you want a new type of special Tensor that ComfyUI will treat differently from Images; perhaps a rotation matrix. Just create a placeholder class for it and use that in your annotations -- it's just for semantics; internally your functions will get whatever type of class they're handed (though with the verification settings turned on, you can still be assured it's a Tensor object (and you are free to create your own custom verifier for more control).

  ```python
  class RotationMatrix(torch.Tensor):
      def __init__(self):
          raise TypeError("!") # Will never be instantiated

  easy_nodes.register_type(RotationMatrix, "ROTATION_MATRIX", verifier=TensorVerifier("ROTATION_MATRIX"))

  @ComfyNode()
  def rotate_matrix_more(rot1: RotationMatrix, rot2: RotationMatrix) -> RotationMatrix:
      return rot1 * rot2
  ```

  Making the class extend a torch.Tensor is not necessary, but it will give you nice type hints in IDEs.



  You can also automatically create nodes that will expose the fields of a class as widgets (as long as it has a default constructor). Say you have a complex options class from a third-party library you want to pass to a node.

  ```python
  from some_library import ComplexOptions

  easy_nodes.register_type(ComplexOptions)

  easy_nodes.create_field_setter_node(ComplexOptions)
  ```

  Now you should be should find a node named ComplexOptions that will have all the basic field types (str, int, float, bool) exposed as widgets.



  To enable the experimental LLM-based debugging, set your OPENAI_API_KEY prior to starting ComfyUI.

  e.g.:
  ```bash
  export OPENAI_API_KEY=sk-P#$@%J345jsd...
  python main.py
  ```

  Then open settings and turn the LLM debugging option to either "On" or "AutoFix".

  Behavior:
    * "On": any exception in execution by an EasyNodes node (not regular nodes) will cause EasyNodes to collect all the relevent data and package it into a prompt for ChatGPT, which is instructed to reply with a fixed version of your function function from which a patch is created. That patch is displayed in the console and also saved to disk for evaluation.
    * "AutoFix": All of the above, and EasyNodes will also apply the patch and attempt to run the prompt again. This will repeat up to the configurable retry limit.

  This feature is very experimental, and any contributions for things like improving the prompt flow and suporting other LLMs are welcome! You can find the implementation in [easy_nodes/llm_debugging.py](easy_nodes/llm_debugging.py).



  Contributions are welcome! Please submit pull requests or open issues for any bugs, features, or improvements.

rpm_license:
  MIT License  Copyright (c) 2024 Andrew Harp  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: 87c987845d337df4fc0e25041f84876d87ad971e854eec5a2a43750af0ec49cc
name: python-Command
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Command runner with debug capabilities
url: http://github.com/helgi/python-command
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Command-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Wrapper around subprocess.popen with on the fly debug / logging
  capabilities and timeout handling.
  Uses tempfiles for stdout/stderr to get past the 64kb subprocess.PIPE
  bug/limitation in python.
  Normal command run
      import command
      response = command.run(['ls'])
      print response.output
      print response.exit
  Print the output as it happens
      import command
      def debug(text):
          print text
      response = command.run(['ls'], debug=debug)
      print response.output
      print response.exit


pkgId: e57e411a5d7029b764839cc36fb97142dc82bd61ba57a3af7d04a97f727cce3c
name: python-CommcareTranslationChecker
arch: src
version: 0.9.7
epoch: 0
release: 1
url: https://github.com/dimagi/CommcareTranslationChecker
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CommcareTranslationChecker-0.9.7-1.src.rpm
checksum_type: sha256
summary:
  Command line tool to check that Bulk Translation files for CommCare apps have consistent <output value.../> tags across translations.

description:
  https://github.com/dimagi/CommcareTranslationChecker
  A command-line tool to check multiple columns of a [Bulk Translation File](https://confluence.dimagi.com/display/commcarepublic/Form+Bulk+Translation) against each other, to ensure that output value tags are being used consistently between columns.


pkgId: f82eb24046b2c5b7cbe23c5fc1783da91a49df00b0f2c2383c9a25622a4e3212
name: python-CommonLib-AV
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Common methods for google bigquery
url: https://github.com/pypa/sampleproject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CommonLib-AV-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This package contains basic functions for using google cloud, service now rest api and some daily common methods


pkgId: d7bcb79dee5c3705b760bafa225c017c41d27f96bd6f50e2badba7e12a352370
name: python-CompNeuroPy
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: General package for computational neuroscience with ANNarchy.
url: https://pypi.org/project/CompNeuroPy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CompNeuroPy-1.0.4-1.src.rpm
checksum_type: sha256
description:
  Assisting package for computational neuroscience with ANNarchy ([GitHub](https://github.com/ANNarchy/ANNarchy), [documentation](https://annarchy.github.io/), [DOI](https://doi.org/10.5281/zenodo.6415039)).

  The documentation is available online at:
  [https://olimaol.github.io/CompNeuroPy/](https://olimaol.github.io/CompNeuroPy/)

  The documentation for olimaol_develop branch is available at:
  [https://compneuropy.github.io/CompNeuroPy/](https://compneuropy.github.io/CompNeuroPy/)



  * Oliver Maith (oli_maith@gmx.de)

rpm_license:
  MIT License  Copyright (c) 2022 Oliver Maith  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: 42e5fdc14cbdaad6808907b689e421abec5f32825e81ff4942e392e733d5a466
name: python-CompStats
arch: src
version: 0.1.2
epoch: 0
release: 1
url: https://compstats.readthedocs.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CompStats-0.1.2-1.src.rpm
checksum_type: sha256
summary:
  CompStats implements an evaluation methodology for statistically analyzing competition results and competition


pkgId: 2e0f9c1e9a93a0942d87a1fe731a5a5b269d5bed5160e38e9bb2e8f46786937d
name: python-CompactObject-TOV
arch: src
version: 1.9.10
epoch: 0
release: 1
summary: A small example package
url: https://github.com/ChunHuangPhy/CompactOject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CompactObject-TOV-1.9.10-1.src.rpm
checksum_type: sha256
description:
  <!-- ABOUT THE PROJECT -->


  **CompactObject** is an open-source package designed to perform Bayesian inference on neutron star equation of state (EOS) constraints. It offers a comprehensive workflow that integrates astrophysical observations and nuclear measurements to explore the interior composition of neutron stars. The package is built to be user-friendly, easily extendable, and thoroughly documented, making it an essential tool for researchers in nuclear astrophysics.

  We have a detailed documentation please check here: [CompactObject Package Website](https://chunhuangphy.github.io/CompactObject/)

  **Please star this repository if you find it is helpful!**



  - [Core Functionality](#core-functionality)
  - [Papers](#papers)
  - [Sample Citation](#sample-citation)
  - [Includes](#includes)
  - [Installation](#installation)
  - [Physics Notations](#physics-notations)
  - [License](#license)
  - [Contact](#contact)
  - [Acknowledgments](#acknowledgments)



  CompactObject offers a range of functionalities essential for constraining the EOS of neutron stars:

  1. **Equation of State (EOS) Generation**
      - Utilizes multiple physics/meta models, including Relativistic Mean Field (RMF), strange star, quark star, polytrope, and speed of sound models, to generate neutron star EOS.
      - [EOSgenerators](https://github.com/ChunHuangPhy/EoS_inference/blob/main/EOSgenerators) Package

  2. **Tolman-Oppenheimer-Volkoff (TOV) Solver**
      - Solves the TOV equations for a spherically symmetric compact object based on a given neutron star EOS.
      - [TOVsolver](https://github.com/ChunHuangPhy/EoS_inference/blob/main/TOVsolver) Package

  3. **Bayesian Inference Workflow**
      - Implements neutron star EOS inference using Nested Sampling.
      - Provide options for single machine users using MCMC sampling by emcee.
      - Integrates constraints from nuclear experiments, neutron star mass and/or radius observations (from X-ray timing and/or radio timing), and tidal measurements from gravitational wave detections.
      - [InferenceWorkflow](https://github.com/ChunHuangPhy/EoS_inference/blob/main/InferenceWorkflow) Package



  Please consider cite the following papers if you use CompactObject in your research:

  1. **Huang, C., Raaijmakers, G., Watts, A. L., Tolos, L., & Providência, C.** (2024). *Constraining fundamental nuclear physics parameters using neutron star mass-radius measurements I: Nucleonic models*. *Monthly Notices of the Royal Astronomical Society*, 529. [DOI:10.1093/mnras/stae844](https://academic.oup.com/mnras/article/529/4/4650/7634362)

  2. **Huang, C., Tolos, L., Providência, C., & Watts, A.** (2024). *Constraining a relativistic mean field model using neutron star mass-radius measurements II: Hyperonic models*. *arXiv preprint arXiv:2410.14572*. [https://arxiv.org/abs/2410.14572](https://arxiv.org/abs/2410.14572)

  3. **Huang, C., & Zheng, X.-P.** (2024). *Bayesian Insights into post-Glitch Dynamics: Model comparison and parameter constraint from decades-long observation data of the Crab pulsar*. *arXiv preprint arXiv:2409.18432*. [https://arxiv.org/abs/2409.18432](https://arxiv.org/abs/2409.18432)





  "The inference conducted here relies on the framework in the *CompactObject* \cite{CompactObject} package\footnote{https://chunhuangphy.github.io/CompactObject/}. This is an open-source, comprehensive package designed to implement Bayesian constraints on the neutron star EOS. Other works based on this package include ..."




  CompactObject includes the following components to facilitate neutron star EOS inference analysis:

  1. **EOS Output Validation Routine**
      - Compute various type of EOS by different models
      - Checks the validity of EOS inputs.

  2. **Mass, Radius, and Tidal Deformability Calculator**
      - Returns mass, radius, tidal deformability, by solve TOV equation, and computes the corresponding speed of sound.

  3. **Sample TOV Solver Notebook**
      - [Test_TOVsolver.ipynb](https://github.com/ChunHuangPhy/EoS_inference/blob/main/Test_Case/test_TOVsolver.ipynb)
      - Demonstrates how to solve the TOV equation with a given EOS.

  4. **Sample EOS Generators Notebook**
      - [test_EOSgenerators.ipynb](https://github.com/ChunHuangPhy/EoS_inference/blob/main/Test_Case/test_EOSgenerators.ipynb)
      - Showcases all integrated EOS computations, including:
          - Polytrope
          - Speed of Sound Model
          - RMF Model
          - Strange Star Model
          - Quark Star Model

  5. **Sample Analysis and Tutorial Notebook**
      - [test_Inference.ipynb](https://github.com/ChunHuangPhy/EoS_inference/blob/main/Test_Case/test_Inference.ipynb)
      - Demonstrates the entire pipeline of Bayesian inference using supported EOS models, constructing priors and likelihoods, and the types of likelihoods supported in this project. Also provide a MCMC based emcee example for people don't have access to High Performance Computer. This is specifically focus on the RMF EOS,
      However, **please check this notebook before all other notebook,**
      **since here we showcase all the likelihood**
      - Other Inference pipline that using different EOS are
          - [MIT bag inference](https://github.com/ChunHuangPhy/CompactObject/blob/main/Test_Case/test_Bayesian_inference_MITbag_EOS.ipynb)
          - [Strangeon Star inference](https://github.com/ChunHuangPhy/CompactObject/blob/main/Test_Case/test_Bayesian_inference_Strangeon_EOS.ipynb)
          - [Polytrope inference](https://github.com/ChunHuangPhy/CompactObject/blob/main/Test_Case/test_Inference_polytrope.ipynb)

  > **Note:** Please review these notebooks before starting your own project to familiarize yourself with the coding routines.



  Below are the commands to install and update the CompactObject package, along with a link to PyPI.



  1. **Install the Package**
      ```sh
      pip install CompactObject-TOV
      ```

  2. **Update the Package**
      ```sh
      pip install CompactObject-TOV --upgrade
      ```



  - **For EOS Computation:**
      ```python
      import EOSgenerators
      ```

  - **For TOV Solver:**
      ```python
      import TOVsolver
      ```

  - **For Bayesian Inference:**
      ```python
      import InferenceWorkflow
      ```



  1. **Units:**
      - **CGS Units** are used throughout the package.
      - **Pressure (P):** erg/cm³
      - **Energy Density (ρ):** g/cm³
      - **Default Unit system** any input in this package is follow the cgs unit

  2. **Unit Conventions:**
      - Follow the unit system defined in the [Unit Conversion](https://chunhuangphy.github.io/CompactObject/UnitConventionForDeveloper.html) notebook.
      - **Basic Rules:**
          1. If using a quantity with a unit, multiply by the unit during computations.
          2. If plotting or demonstrating values in a specific unit, divide accordingly.
      - Detailed guidelines can be found in the [Unit Conversion](https://chunhuangphy.github.io/CompactObject/UnitConventionForDeveloper.html) documentation.



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

  <p align="right">(<a href="#compactobject">back to top</a>)</p>



  * **Chun Huang** - [chun.h@wustl.edu](mailto:chun.h@wustl.edu)

  **Documentation Link:** [CompactObject Documentation](https://chunhuangphy.github.io/CompactObject/)

  [![DOI](https://zenodo.org/badge/doi/10.5281/zenodo.8145167.svg)](http://dx.doi.org/10.5281/zenodo.8145167)

  <p align="right">(<a href="#compactobject">back to top</a>)</p>



  We would like to acknowledge the support of the Code/Astro workshop, which was instrumental in the development of this project. Special thanks to Professor Anna Watts, Dr. Geert Raaijmakers, and Jeannie Kuijper for their assistance with coding and providing foundational strategies to address the research challenges.

  * [Code Astro](https://github.com/semaphoreP/codeastro)
  * [Choose an Open Source License](https://choosealicense.com)
  * [Read Me Template](https://github.com/othneildrew/Best-README-Template)

  <p align="right">(<a href="#compactobject">back to top</a>)</p>
  ```


pkgId: 630b23d13b85b86a5754a18674ff7010e601b324c0f25b6a4d54a85634b4dc23
name: python-Comprehensive-RAG-Evaluation-Metrics
arch: src
version: 0.12.0
epoch: 0
release: 1
url: https://github.com/beekash222/RAG_EVAL
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Comprehensive-RAG-Evaluation-Metrics-0.12.0-1.src.rpm
checksum_type: sha256
summary:
  This library provides a comprehensive suite of metrics to evaluate the performance of Retrieval-Augmented Generation (RAG) systems. RAG systems, which combine information retrieval with text generation, present unique evaluation challenges beyond those found in standard language generation tasks

description:
  RAG Evaluator
  Overview
  RAG Evaluator is a Python library for evaluating Retrieval-Augmented Generation (RAG) systems. It provides various metrics to evaluate the quality of generated text against reference text.

  Installation
  You can install the library using pip:

  pip install Comprehensive_RAG_Evaluation_Metrics
  Usage
  Here's how to use the RAG Evaluator library:

  from Comprehensive_RAG_Evaluation_Metrics import RAGEvaluator


  evaluator = RAGEvaluator()


  question = "What are the causes of difficulty in learning a new topic?"
  response = "Difficulty in learning a new topic is often caused by a lack of understanding of the subject's structure."
  reference = "Not knowing how to explain a topic to others can make it harder to learn, as it requires a deeper understanding of the subject's structure."


  metrics = evaluator.evaluate_all(question, response, reference)


  print(metrics)
  Streamlit Web App
  To run the web app:

  cd into streamlit app folder.
  Create a virtual env
  Activate the virtual env
  Install all dependencies
  Run the app:
  streamlit run app.py
  Metrics
  The RAG Evaluator provides the following metrics:

  BLEU (0-100): Measures the overlap between the generated output and reference text based on n-grams.

  0-20: Low similarity, 20-40: Medium-low, 40-60: Medium, 60-80: High, 80-100: Very high
  ROUGE-1 (0-1): Measures the overlap of unigrams between the generated output and reference text.

  0.0-0.2: Poor overlap, 0.2-0.4: Fair, 0.4-0.6: Good, 0.6-0.8: Very good, 0.8-1.0: Excellent
  BERT Score (0-1): Evaluates the semantic similarity using BERT embeddings (Precision, Recall, F1).

  0.0-0.5: Low similarity, 0.5-0.7: Moderate, 0.7-0.8: Good, 0.8-0.9: High, 0.9-1.0: Very high
  Perplexity (1 to âˆž, lower is better): Measures how well a language model predicts the text.

  1-10: Excellent, 10-50: Good, 50-100: Moderate, 100+: High (potentially nonsensical)
  Diversity (0-1): Measures the uniqueness of bigrams in the generated output.

  0.0-0.2: Very low, 0.2-0.4: Low, 0.4-0.6: Moderate, 0.6-0.8: High, 0.8-1.0: Very high
  Racial Bias (0-1): Detects the presence of biased language in the generated output.

  0.0-0.2: Low probability, 0.2-0.4: Moderate, 0.4-0.6: High, 0.6-0.8: Very high, 0.8-1.0: Extreme
  METEOR (0-1): Calculates semantic similarity considering synonyms and paraphrases.

  0.0-0.2: Poor, 0.2-0.4: Fair, 0.4-0.6: Good, 0.6-0.8: Very good, 0.8-1.0: Excellent
  CHRF (0-1): Computes Character n-gram F-score for fine-grained text similarity.

  0.0-0.2: Low, 0.2-0.4: Moderate, 0.4-0.6: Good, 0.6-0.8: High, 0.8-1.0: Very high
  Flesch Reading Ease (0-100): Assesses text readability.

  0-30: Very difficult, 30-50: Difficult, 50-60: Fairly difficult, 60-70: Standard, 70-80: Fairly easy, 80-90: Easy, 90-100: Very easy
  Flesch-Kincaid Grade (0-18+): Indicates the U.S. school grade level needed to understand the text.

  1-6: Elementary, 7-8: Middle school, 9-12: High school, 13+: College level
  Testing
  To run the tests, use the following command:

  Semantic Similarity Evaluates similarity in meaning between two texts using word embeddings and cosine similarity for accurate context.

  Factual Consistency Verifies factual accuracy in responses using entity recognition and knowledge graph-based methods for trustworthiness.

  Question Relevance Measures response relevance to user queries using keyword extraction and intent detection for effective answers.

  Context Relevance Assesses response appropriateness in a given situation using topic modeling and semantic role labeling for contextual fit.

  Answer Relevance Evaluates response clarity and directness in answering user queries using named entity recognition and dependency parsing.

  Toxicity Detects hate speech, profanity, and toxic content in responses using sentiment analysis and machine learning-based classification.

  python -m unittest discover -s rag_evaluator -p "test_*.py"


pkgId: 1a55bd6b72cc2a97d89a513f2da749cb8c62e440b372e667883971962810a543
name: python-ComradeAI
arch: src
version: 0.18.28
epoch: 0
release: 1
summary: A protocol and SDK for unified AI service interaction
url: https://github.com/SergeiKarulin/ComradeAI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ComradeAI-0.18.28-1.src.rpm
checksum_type: sha256
description:
  Comrade AI is an open source framework to assemble AI services like Claude, Gemini Pro, GPT 3.5/4, Yandex GPT, LLaMa v2 and many more into unified intelligent agents to build a collaborative network.

  Comrade AI advances true multimodality and decentralization, using a unified protocol and a digital currency for transactions, alongside supporting independent AI service providers. This streamlined approach not only makes integrating various AI services simpler but also promotes an open, competitive AI marketplace. By commoditizing AI machine time with our digital currency, we make AI resources more accessible, driving innovation and broadening access to cutting-edge technology.

  As for Feb 23, 2024 the framework has agents for Meta LLaMa v2, OpenAI DALLE-3, OpenAI GPT4/Vision, Vertex AI/Google Gemini Pro/Pro Vision, Yandex GPT v2 Async, OpenAI Whisper Large v3, Anthropic Claude 2.1, Meta MBART many-to-many, Mindsimulation SteosVoice. We are working on Mixtral, and fast OCR model.


pkgId: 7622c1f1a8084b55a4078aa6017737047eb073e6263ccb9aa4bd7cd33e27340b
name: python-ConSReg
arch: src
version: 1.1.7
epoch: 0
release: 1
summary: condition-specific regulation
url: https://github.com/LiLabAtVT/ConSReg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConSReg-1.1.7-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  Condition-specific regulations
  - [ConSReg 1.1.4](#consreg-114)
  - [Getting Started](#getting-started)
    * [1. Installation](#1-installation)
      + [1.1 Required packages](#11-required-packages)
        - [1.1.1 Python](#111-python)
        - [1.1.2 R](#112-r)
      + [1.2 Easy installation by Anaconda (recommended)](#12-easy-installation-by-anaconda--recommended-)
      + [1.3 Manual installation (Skip this section if 1.2 is successful)](#13-manual-installation--skip-this-section-if-12-is-successful-)
      + [1.3.1 R installation](#131-r-installation)
        - [install R](#install-r)
        - [install R packages](#install-r-packages)
      + [1.3.2 Python installation](#132-python-installation)
    * [2. Sample datasets](#2-sample-datasets)
    * [3. Analysis](#3-analysis)
    * [4. Publication](#4-publication)

  <small><i><a href='http://ecotrust-canada.github.io/markdown-toc/'>Table of contents generated with markdown-toc</a></i></small>





  - python = 3.6
  - numpy == 1.16.2
  - scipy == 1.1.0
  - pandas == 0.21.1
  - joblib >= 0.11
  - rpy2==2.8.6
  - networkx >= 2
  - sklearn >= 0.19.1
  - intervaltree == 2.1.0

  - ChIPSeeker == 1.16.1
  - CoReg == 1.0.1
  - gglasso == 1.4
  - RRF == 1.9
  - R >= 3.5.1

  Since ConSReg is dependent on both Python and R packages, we recommend installing ConSReg by Anaconda to easily set up the running environment. You may retrive Anaconda from [here](https://www.anaconda.com/) and install the version corresponding to your OS.
  Once Anaconda is installed in your OS, run the following commands to create an new environment and install ConSReg and all its dependencies into the new environment:
  ```bash
  conda create -y -n consreg python=3.6 # The new environment name is 'consreg'. You may use other name instead.
  conda activate consreg
  conda install -y -c bioconda --no-channel-priority bioconductor-chipseeker
  conda install -y --no-channel-priority r-base r-essentials
  conda install -y --no-channel-priority -c conda-forge r-gglasso r-rrf r-devtools
  pip install ConSReg
  ```
  Then ConSReg environment can be activated by `conda activate consreg` and disabled by `conda deactivate`



  If R is not already installed， you may follow these steps to build R from source code. Otherwise, you may skip this section and start from 1.2.2

  First, disable any conda environment, if there is an active one.
  ```shell
  conda deactivate
  ```
  Download R source code from CRAN (https://cran.r-project.org/). You may use any version you like. It is recommended to use R version > 3.0.0. This ensures that rpy2 works correctly with R.
  ```shell

  wget https://cran.r-project.org/src/base/R-3/R-3.6.1.tar.gz
  ```
  Decompress the downloaded file
  ```shell
  tar -zvxf R-3.6.1
  ```
  In the decompressed folder, configure R by:
  ```shell
  ./configure prefix=path_to_install_R --enable-R-shlib
  ```
  `--prefix=` specifies a writeable directory to install R into. `--enable-R-shlib` flag was added to build R shared libraries.

  In the decompressed folder, compile R
  ```shell
  make
  ```
  Install R into the specified directory:
  ```shell
  make install
  ```
  Add a line to ~/.bashrc to tell the OS where to look for R
  ```shell
  export PATH=path_to_R_bin_directory:$PATH
  ```
  Add the following line to ~/.bashrc. This is for telling rpy2 where to look for dynamic libraries.
  ```shell
  export LD_LIBRARY_PATH=/home/alexsong/R/3.6.1/lib64/R/lib:$LD_LIBRARY_PATH
  ```
  Apply the changes to environment variables `PATH` and `LD_LIBRARY_PATH`:
  ```shell
  source ~/.bashrc
  ```

  ConSReg requires several R packages: `ChIPseeker`, `CoReg`, `gglasso` and `RRF`.

  It is recommended to deactivate any conda environment when installing R packages, as it may add the environment-specific path which may fail the installation. If any conda environment is active, you may deactivate it by:
  ```shell
  conda deactivate
  ```
  To install `ChIPSeeker` from bioconductor, type the following commands in R (for R 3.6 or higher version):
  ```R
  if (!requireNamespace("BiocManager", quietly = TRUE))
      install.packages("BiocManager")

  BiocManager::install("ChIPseeker")
  ```
  For older version of R, type the following commands in R:
  ```R
  source("https://bioconductor.org/biocLite.R")
  biocLite("ChIPseeker")
  ```
  Please refer to the instructions described [here](https://www.bioconductor.org/packages/release/bioc/html/ChIPseeker.html) for more details.

  To install `CoReg` pakcage from GitHub, type the following commands in R environment:
  ```R
  install.packages("devtools")
  library(devtools)
  install_github("LiLabAtVT/CoReg")
  ```
  Please refer to the GitHub page of `CoReg` project for more details:
  [link](https://github.com/LiLabAtVT/CoReg)

  To install `gglasso` package from CRAN, type the following commands in R environment:
  ```R
  install.pacakges("gglasso")
  ```
  Please refer to the link [here](https://cran.r-project.org/web/packages/gglasso/index.html) for more details.

  To install `RRF` package from CRAN, type the following commands in R environment:
  ```R
  install.pacakges("RRF")
  ```
  Please refer to the link [here](https://cran.r-project.org/web/packages/RRF/index.html) for more details.

  ConSReg can be installed by pip:
  ```shell
  pip install ConSReg
  ```
  Sometime rpy2 may throw out error message when imported in Python. This problem may arise because rpy2 was built with the R version that is different from the one it is linked to when imported in Python. To fix this, you may remove rpy2 package then reinstall it with 'no-cache-dir' flag:

  ```shell
  pip install ConSReg --no-cache-dir
  ```

  Alternatively, you may want to install ConSReg in development mode to be able to edit the package by yourself. To do so, simply `git clone` this repository and then under the directory that contains `setup.py`, type in:
  ```shell
  pip install -e .
  ```

  Sample datasets can be found in `data` folder.


  We provide code for analyzing the sample datasets in two jupyter notebooks located in the root folder of this project: **bulk_analysis.ipynb** (for bulk RNA-seq data) and **single_cell_analysis.ipynb** (for single cell RNA-seq data).


  Please cite the followint paper if you use ConSReg in your research:
  Qi Song, Jiyoung Lee, Shamima Akter, Ruth Grene, Song Li. "Prediction of condition-specific regulatory genes using machine learning." Nucleic acids research 48.11 (2020): e62-e62.


pkgId: 16e0b5b1ac4d557f44ae8826e543fb057ac9a8ef190e7bd4df4b74df327347d7
name: python-Concern
arch: src
version: 27
epoch: 0
release: 1
summary: Control pym2149 (via Lurlene) or FoxDot using Vim
url: https://github.com/combatopera/Concern
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Concern-27-1.src.rpm
checksum_type: sha256
description:
  Control pym2149 (via Lurlene) or FoxDot using Vim


  These are generic installation instructions.


  The quickest way to get started is to install the current release from PyPI:
  ```

  pip3 install --user Concern
  ```
  You will also need one of the following backends.


  ```

  pip3 install --user FoxDot
  ```


  ```

  pip3 install --user pym2149


  echo Concern consumerName = pym2149 | tee -a ~/.settings.arid
  ```


  If you prefer to keep .local clean, install to a virtualenv:
  ```
  python3 -m venv venvname
  venvname/bin/pip install Concern
  . venvname/bin/activate
  ```
  To add a backend, substitute `pip install` for `pip3 install --user` above.




  Vim-based live coding environment.




  ```

  Concern "$(python3 -c 'from pkg_resources import resource_filename; print(resource_filename("FoxDot", "demo"))' | tail -1)"
  ```
  * FoxDot is running in the right hand third of the screen
  * Send code to FoxDot by typing backslash followed by `]`
      * This will send the smallest top-level suite under the cursor
      * The backslash is actually your Vim leader key
  * Use visual mode to send multiple top-level suites at once
  * Use backslash enter instead of backslash `]` to send from cursor to the end of the file
  * Use backslash `q` to quit all of Vim, FoxDot and GNU Screen


  ```

  svn export https://github.com/combatopera/pym2149/trunk/contrib


  Concern 'contrib/Lemmings 2 Tune 6.py'
  ```
  * Once pym2149 has initialised, type backslash enter at the top of the file to send the whole program


pkgId: 5f50ed7058c2afd72cb86c28cc6db02e4b99bbd61c39058f09f4e15e3c785622
name: python-ConcurrentDatabase
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: A SQLite wrapper that allows for object oriented database access.
url: https://pypi.org/project/ConcurrentDatabase/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConcurrentDatabase-0.0.11-1.src.rpm
checksum_type: sha256
description:
  [![Build Checks](https://github.com/JayFromProgramming/ConcurrentDatabase/actions/workflows/python-package.yml/badge.svg)](https://github.com/JayFromProgramming/ConcurrentDatabase/actions/workflows/python-package.yml)
  [![Upload Python Package](https://github.com/JayFromProgramming/ConcurrentDatabase/actions/workflows/python-publish.yml/badge.svg)](https://github.com/JayFromProgramming/ConcurrentDatabase/actions/workflows/python-publish.yml)


  A simple sql wrapper for making a database be object oriented


  ```bash
  pip install ConcurrentDatabase
  ```


  ```python
  from ConcurrentDatabase.Database import Database

  db = Database("test.db")

  table = db.create_table("example_table", {
      "id": "INTEGER PRIMARY KEY",
      "name": "TEXT",
      "location": "TEXT"
  }, primary_keys=["id"])

  ```


  ```python

  table = db.get_table("example_table")

  table.add(name="Jay", location="USA")
  table.add(name="John", location="USA")
  ```


  ```python
  table = db.get_table("example_table")

  row = table.get_row(name="Jay")
  row["name"] = "JayFromProgramming"  # Changes are saved in memory until you call row.flush()
  row.flush()

  row.set(name="JayFromProgramming")  # Flushes immediately
  ```


  ```python
  table = db.get_table("example_table")

  row = table.get_row(name="Jay")
  row.delete()

  table.delete(name="Jay")
  ```


pkgId: 7ae45841fb09f1ed22feee92806ee85cefdf41cafcbf7a17a3aaa7ecccb68d10
name: python-ConfMerge
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Configuration file merge utility
url: https://github.com/Aisbergg/python-confmerge
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConfMerge-0.2.0-1.src.rpm
checksum_type: sha256
description:
  To install *ConfMerge* directly from Github:
  ```
  pip install git+https://github.com/Aisbergg/python-confmerge@v0.2.0
  ```

  ```
  usage: confmerge [-d] [-f] [-h] [-m MODE] [-t FILE_TYPE] [--debug] [--version]
                   src [src ...] dest
  Merge multiple configuration files into one file
  positional arguments:
    src                   The source files
    dest                  The destination file
  optional arguments:
    -d, --dry-run         Print the merged content on stdout instead of writing
                          it to the destination file
    -f, --force           Force overwriting of any existing destination file
    -h, --help            Show this help message and exit
    -m MODE, --mode MODE  File mode for newly created files
    -t FILE_TYPE, --type FILE_TYPE
                          Type of file can be one of 'ini', 'json' or 'yaml'. If
                          not specified the type will be guessed from the file
                          extension
    --debug               Print debug trace on error
    --version             Print the program version and exit
  ```

  Merge multiple INI files and write result into `res.ini`
  ```
  confmerge -f 1.ini 2.ini 3.ini res.ini
  ```
  Merge different types of configuration files:
  ```
  confmerge -f 1.yml 2.json 3.ini res.yml
  ```
  Perform a dry run (don't write output file but print result on stdout):
  ```
  confmerge --dry-run 1.yml 2.yml not-touched.yml
  ```

  ConfMerge is released under the LGPL v3 License. See [LICENSE.txt](LICENSE.txt) for more information.


pkgId: 82e05e04c720b7897dac35396b9316db1a8e67a0ffc88a5092aeea6d366431a9
name: python-ConfigArgParse
arch: src
version: 1.7
epoch: 0
release: 1
url: https://github.com/bw2/ConfigArgParse
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConfigArgParse-1.7-1.src.rpm
checksum_type: sha256
summary:
  A drop-in replacement for argparse that allows options to also be set via config files and/or environment variables.

description:
  Overview
  ~~~~~~~~
  Applications with more than a handful of user-settable options are best
  configured through a combination of command line args, config files,
  hard-coded defaults, and in some cases, environment variables.
  Python's command line parsing modules such as argparse have very limited
  support for config files and environment variables, so this module
  extends argparse to add these features.
  Available on PyPI: http://pypi.python.org/pypi/ConfigArgParse
  Features
  ~~~~~~~~
  -  command-line, config file, env var, and default settings can now be
     defined, documented, and parsed in one go using a single API (if a
     value is specified in more than one way then: command line >
     environment variables > config file values > defaults)
  -  config files can have .ini or .yaml style syntax (eg. key=value or
     key: value)
  -  user can provide a config file via a normal-looking command line arg
     (eg. -c path/to/config.txt) rather than the argparse-style @config.txt
  -  one or more default config file paths can be specified
     (eg. ['/etc/bla.conf', '~/.my_config'] )
  -  all argparse functionality is fully supported, so this module can
     serve as a drop-in replacement (verified by argparse unittests).
  -  env vars and config file keys & syntax are automatically documented
     in the -h help message
  -  new method :code:`print_values()` can report keys & values and where
     they were set (eg. command line, env var, config file, or default).
  -  lite-weight (no 3rd-party library dependencies except (optionally) PyYAML)
  -  extensible (:code:`ConfigFileParser` can be subclassed to define a new
     config file format)
  -  unittested by running the unittests that came with argparse but on
     configargparse, and using tox to test with Python 3.5+
  Example
  ~~~~~~~
  *config_test.py*:
  Script that defines 4 options and a positional arg and then parses and prints the values. Also,
  it prints out the help message as well as the string produced by :code:`format_values()` to show
  what they look like.
     import configargparse
     p = configargparse.ArgParser(default_config_files=['/etc/app/conf.d/*.conf', '~/.my_settings'])
     p.add('-c', '--my-config', required=True, is_config_file=True, help='config file path')
     p.add('--genome', required=True, help='path to genome file')  # this option can be set in a config file because it starts with '--'
     p.add('-v', help='verbose', action='store_true')
     p.add('-d', '--dbsnp', help='known variants .vcf', env_var='DBSNP_PATH')  # this option can be set in a config file because it starts with '--'
     p.add('vcf', nargs='+', help='variant file(s)')
     options = p.parse_args()
     print(options)
     print("----------")
     print(p.format_help())
     print("----------")
     print(p.format_values())    # useful for logging where different settings came from
  *config.txt:*
  Since the script above set the config file as required=True, lets create a config file to give it:
      
      genome = HCMV     # cytomegalovirus genome
      dbsnp = /data/dbsnp/variants.vcf
  *command line:*
  Now run the script and pass it the config file:
      DBSNP_PATH=/data/dbsnp/variants_v2.vcf python config_test.py --my-config config.txt f1.vcf f2.vcf
  *output:*
  Here is the result:


pkgId: 7b6cd5f153b162c526734b2b2a98ce2923625789edb7eb7ea8f17debb80816e8
name: python-ConfigByLmdb
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: lmdb 自定义封装
url: https://github.com/jnwatson/py-lmdb/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConfigByLmdb-0.0.10-1.src.rpm
checksum_type: sha256
rpm_license:
  The OpenLDAP Public License Version 2.8, 17 August 2003  Redistribution and use of this software and associated documentation ("Software"), with or without modification, are permitted provided that the following conditions are met:  1. Redistributions in source form must retain copyright statements and notices,  2. Redistributions in binary form must reproduce applicable copyright statements and notices, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution,  3. Redistributions must contain a verbatim copy of this document.  The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number.  You may use this Software under terms of this license revision or under the terms of any subsequent revision of the license.  THIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OPENLDAP FOUNDATION, ITS CONTRIBUTORS, OR THE AUTHOR(S) OR OWNER(S) OF THE SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  The names of the authors and copyright holders must not be used in advertising or otherwise to promote the sale, use or other dealing in this Software without specific, written prior permission.  Title to copyright in this Software shall at all times remain with copyright holders.  OpenLDAP is a registered trademark of the OpenLDAP Foundation.  Copyright 1999-2003 The OpenLDAP Foundation, Redwood City, California, USA.  All Rights Reserved.  Permission to copy and distribute verbatim copies of this document is granted.


pkgId: 9e3038deb648f58b33a7e81ea272e31d79f5131840dffd1a501d91fe5e711fd7
name: python-ConfigSpace
arch: src
version: 1.2.0
epoch: 0
release: 1
url: https://pypi.org/project/ConfigSpace/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConfigSpace-1.2.0-1.src.rpm
checksum_type: sha256
summary:
  Creation and manipulation of parameter configuration spaces for automated algorithm configuration and hyperparameter tuning.

description:
  A simple Python module implementing a domain specific language to manage
  configuration spaces for algorithm configuration and hyperparameter optimization tasks.
  Distributed under BSD 3-clause, see LICENSE except all files in the directory
  ConfigSpace.nx, which are copied from the networkx package and licensed
  under a BSD license.

  The documentation can be found at [https://automl.github.io/ConfigSpace/main/](https://automl.github.io/ConfigSpace/main/).
  Further examples can be found in the [SMAC documentation](https://automl.github.io/SMAC3/main/examples/index.html).




  ```python
  from ConfigSpace import ConfigurationSpace

  cs = ConfigurationSpace(
      name="myspace",
      space={
          "a": (0.1, 1.5),  # UniformFloat
          "b": (2, 10),  # UniformInt
          "c": ["mouse", "cat", "dog"],  # Categorical
      },
  )

  configs = cs.sample_configuration(2)
  ```




  ```bibtex
  @article{
      title   = {BOAH: A Tool Suite for Multi-Fidelity Bayesian Optimization & Analysis of Hyperparameters},
      author  = {M. Lindauer and K. Eggensperger and M. Feurer and A. Biedenkapp and J. Marben and P. Müller and F. Hutter},
      journal = {arXiv:1908.06756 {[cs.LG]}},
      date    = {2019},
  }
  ```

rpm_license:
  # ConfigSpace  Copyright (c) 2014-2021, ConfigSpace developers Matthias Feurer Katharina Eggensperger and others (see commit history). All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the <organization> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  # networkx (nx subpackage)  Copyright (C) 2004-2014, NetworkX Developers Aric Hagberg <hagberg@lanl.gov> Dan Schult <dschult@colgate.edu> Pieter Swart <swart@lanl.gov> All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the NetworkX Developers nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 3dca8fa0d6366b996696664076bfddf98b88d73c2dee4beb08460ef3f3e6d014
name: python-ConfigSpace
arch: src
version: 1.2.1
epoch: 0
release: 1
url: https://pypi.org/project/ConfigSpace/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConfigSpace-1.2.1-1.src.rpm
checksum_type: sha256
summary:
  Creation and manipulation of parameter configuration spaces for automated algorithm configuration and hyperparameter tuning.

description:
  A simple Python module implementing a domain specific language to manage
  configuration spaces for algorithm configuration and hyperparameter optimization tasks.
  Distributed under BSD 3-clause, see LICENSE except all files in the directory
  ConfigSpace.nx, which are copied from the networkx package and licensed
  under a BSD license.

  The documentation can be found
  at [https://automl.github.io/ConfigSpace/latest/](https://automl.github.io/ConfigSpace/latest/).
  Further examples can be found in the [SMAC documentation](https://automl.github.io/SMAC3/main/examples/index.html).



  ```python
  from ConfigSpace import ConfigurationSpace

  cs = ConfigurationSpace(
      name="myspace",
      space={
          "a": (0.1, 1.5),  # UniformFloat
          "b": (2, 10),  # UniformInt
          "c": ["mouse", "cat", "dog"],  # Categorical
      },
  )

  configs = cs.sample_configuration(2)
  ```



  ```bibtex
  @article{
      title   = {BOAH: A Tool Suite for Multi-Fidelity Bayesian Optimization & Analysis of Hyperparameters},
      author  = {M. Lindauer and K. Eggensperger and M. Feurer and A. Biedenkapp and J. Marben and P. Müller and F. Hutter},
      journal = {arXiv:1908.06756 {[cs.LG]}},
      date    = {2019},
  }
  ```

rpm_license:
  # ConfigSpace  Copyright (c) 2014-2021, ConfigSpace developers Matthias Feurer Katharina Eggensperger and others (see commit history). All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the <organization> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  # networkx (nx subpackage)  Copyright (C) 2004-2014, NetworkX Developers Aric Hagberg <hagberg@lanl.gov> Dan Schult <dschult@colgate.edu> Pieter Swart <swart@lanl.gov> All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the NetworkX Developers nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 7495a52661564a38237bc28d14ec538711ec81a936f0b114769021170085bcc6
name: python-ConfigTree
arch: src
version: 0.6
epoch: 0
release: 1
summary: Is a configuration management tool
url: https://github.com/Cottonwood-Technology/ConfigTree
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConfigTree-0.6-1.src.rpm
checksum_type: sha256
description:
  Configuration files behave like cancer tumor.  As soon as one is created with a
  handful of parameters, it starts to grow.  And in a couple of month it becomes
  huge hardly supportable monster with dozens of parameters, which affects on
  different subsystems of the project like metastasis.
  The goal of ConfigTree project is to restrain the monster, but without
  overkill for small projects.  It can be used in Python programs as well as in
  programs written in other languages.
  ConfigTree will be useful for you, if you want to:
  *   keep default configuration options and environment-specific ones
      separated;
  *   fine-tune files to load for each environment;
  *   validate configuration;
  *   have templates and automation in your configuration files.
  The full documentation is available at `Read the Docs`_.


pkgId: 33fff326057e489f729e9c20eb83cc4dba905043e9ecfaca0adb17ce55c239af
name: python-ConfigUpdater
arch: src
version: 3.2
epoch: 0
release: 1
summary: Parser like ConfigParser but for updating configuration files
url: https://github.com/pyscaffold/configupdater
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConfigUpdater-3.2-1.src.rpm
checksum_type: sha256
description:
  The key differences to `ConfigParser`_ are:
  * minimal invasive changes in the update configuration file,
  * proper handling of comments,
  * only a single config file can be updated at a time,
  * the original case of sections and keys are kept,
  * control over the position of a new section/key
  Following features are **deliberately not** implemented:
  * interpolation of values,
  * propagation of parameters from the default section,
  * conversions of values,
  * passing key/value-pairs with ``default`` argument,
  * non-strict mode allowing duplicate sections and keys.


pkgId: c8fadaf71770925056228541073b01845aa96d4883be81b6c2f427117bf7c990
name: python-CongressLib
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A Python wrapper for the Congress.gov API.
url: https://pypi.org/project/CongressLib/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CongressLib-0.1.1-1.src.rpm
checksum_type: sha256
description:
  - Retrieve lists and detailed information about:
    - Bills
    - Amendments
    - Committees
    - Communications
    - Congressional records (daily and bound)
    - Members of Congress
    - Nominations
    - Summaries
    - Treaties
  - Easily handle API authentication with your Congress.gov API key.


pkgId: 23b78598445bf7b2ff864f44ad3f451e876ec3dd46b206b23552f867ca75c931
name: python-ConsLoadingBar
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Easy to make progress bars
url: https://github.com/flamechain/ConsLoadingBar
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConsLoadingBar-3.0.2-1.src.rpm
checksum_type: sha256
description:
  ![pypi](https://shields.io/pypi/v/consloadingbar.svg)

  <img src="demo.gif" alt="demo" width="600"/>





  Backwards Compatible Since 3.0.0

  > ### Note: Please report bugs, give feedback, and make suggestions on my github page



  Imported simply:

  ```python
  import consloadingbar, time # time import is not required, but will be used for eta calculation later
  ```



  You can use [demo.py](https://github.com/flamechain/ConsLoadingBar/blob/main/demo.py), or call SimulateTasks() to see another bult-in demo class. You can read more about how this class works in the full docs [here](https://github.com/flamechain/ConsLoadingBar/blob/main/Documentation.md).

  ```python
  clb = consloadingbar.SimulateTasks()
  ```



  There are 4 indicators to choose from:

  - ``progressBar``
  - ``progressChar``
  - ``spinner``
  - ``counter``





  | Name | Description | Type | Default |
  |-|-|:-:|-|
  | barLength | Length of bar in characters | int | 20 |
  | useETACalculation | Stall bar depending on current eta | boolean | False |
  | taskCount | Total amount of tasks displayed | int | None |
  | mainBarChar | Character of the filled-in bar | string | '█' |
  | progressPointBarChar | Last character of the filled-in bar | string | None |
  | endPointChars | Suffix and prefix of the bar | list | ['&#124;', '&#124;'] |
  | title | Title to show when the bar is running | string | 'Running...' |
  | emptyBarChar | Character for the non-filled-in bar | string | ' ' |
  | maxValue | Max value the bar reaches | float | 100 |
  | maxValueLabel | Unit for the current value | string | '%' |



  | Name | Description | Type | Default |
  |-|-|:-:|-|
  | percentage | Current percentage complete | int | |
  | time_ | Current time passed since start, used for eta calculations | float | None |
  | tasksDone | How many tasks done to display | int | 0 |
  | lazyLoad | If used, only updates when needed, no tasks or eta displayed | int-bool | None |
  | returnString | Return a string value of the bar instead of printing to the console | boolean | False |

  You can use the params from Bar() to customize the look of the bar (see demo) and the params from the method for iter-specific things like current percentage.

  ```python
  clb = consloadingbar.Bar(useColor=True, taskCount=10)

  start = time.time()

  for i in range(101):
      currentTime = time.time() - start
      
      clb.progressBar(i, time_=currentTime, tasksDone=i//10)
  ```

  This will display tasks and eta. You can also call the start() method for multiline titles:

  ```python
  clb.start()
  ```

  ```txt
  Running...
          |                    |   0%  [tasks=0/10]
  ```

  Or you can use the end() method to show a full bar. This example has useColor enabled.

  ```python
  clb.end()
  ```

  <pre>
  <span style="color:green">Finished</span>
          |████████████████████| <span style="color:green">100%  [tasks=10/10]</span>
  </pre>



  | Name | Description | Type | Default |
  |-|-|:-:|-|
  | index | Index of phases to print | integer | |
  | phases | List of characters that the index calls from | list | [' ', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'] |
  | title | Title to show while running | string | 'Loading' |

  This shows a character for progress. Like spinner but has a sense of completion.

  ```python
  clb = consloadingbar.Bar()

  clb.progressChar(1) # Will run for 2 seconds
  ```

  ```txt
  Loading ▁
  ```



  | Name | Description | Type | Default |
  |-|-|:-:|-|
  | stop() | Used if on a seperate thread to call on main to stop | func-bool | False |
  | time_ | Instead you can hardcode how long it should take | float | None |
  | title | Title to display while running | string | 'Loading' |
  | phases | A list of values to loop through to display | list | ['|', '/', '-', '\\'] | False |
  | returnString | Used if you want to return the string value instead of print | boolean | False |

  As seen in the demo, you can do lots. Here are a couple examples that are shown in the demo:

  ```python
  clb = consloadingbar.Bar()

  clb.spinner(time_=2)
  ```

  ```python
  clb.spinner(time_=4.7, phases='preset')
  ```

  This last one uses a preset, and the preset takes about 4.7 seconds to complete once.



  | Name | Description | Type | Default |
  |-|-|:-:|-|
  | totalTime | Total time for completion | float | |
  | start | Start number | float | |
  | end | End number | float | |
  | title | Title to display | string | 'Loading' |

  Here is how to count up and count down in 2 seconds each:

  ```python
  clb = consloadingbar.Bar()

  clb.counter(2, start=0, end=100)
  clb.counter(2, start=100, end=0)
  ```

  This will count up to 100, then back down to 0

  ___



  Install via pip using `pip install ConsLoadingBar`.

  ```bash
  pip install ConsLoadingBar
  ```

  To make sure you have the current version you can use this command instead:

  ```bash
  pip install --upgrade ConsLoadingBar
  ```

  You can also directly call the module from python:

  ```bash
  python3 -m pip install ConsLoadingBar
  ```

  ___



  ConsLoadingBar is licensed under the MIT License


pkgId: a1e1ec1810fc114dfc29a9fcd82f81a13a754c435eb8a736b30972aa70b9f381
name: python-ConservedWaterSearch
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Conserved water search is a tool for finding conserved water molecules from MD trajectories.
url: https://github.com/JecaTosovic/ConservedWaterSearch
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConservedWaterSearch-0.4.1-1.src.rpm
checksum_type: sha256
description:
  The ConservedWaterSearch (CWS) Python library uses density based clustering approach to detect conserved waters from simulation trajectories. First, positions of water molecules are determined based on clustering of oxygen atoms belonging to water molecules(see figure below for more information). Positions on water molecules can be determined using Multi Stage Re-Clustering (MSRC) approach or Single Clustering (SC) approach (see for more `information on clustering procedures <https://doi.org/10.1021/acs.jcim.2c00801>`_).
  Conserved water molecules can be classified into 3 distinct conserved water types based on their hydrogen orientation: Fully Conserved Waters (FCW), Half Conserved Waters (HCW) and Weakly Conserved Waters (WCW) - see figure below for examples and more information or see `CWS docs <https://conservedwatersearch.readthedocs.io/en/latest/conservedwaters.html>`_.
  Both, MSRC and SC can be used with either OPTICS (via `sklearn <https://scikit-learn.org/stable/modules/generated/sklearn.cluster.OPTICS.html>`_) and `HDBSCAN <https://hdbscan.readthedocs.io/en/latest/index.html>`_. MSRC approach using either of the two algorithms produces better quality results at the cost of computational time, while SC approach produces lowe quality results at a fraction of the computational cost.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2022, Jelena Tosovic All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: bb7ceadb0032caab2c63a8b77b468d3dd8952742585ec1f066b2b7bc3c60378d
name: python-ConsoleHelp
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: For all of your console needs!
url: https://github.com/darkdarcool/ConsoleHelp/blob/master/MyApp/setup.py
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConsoleHelp-0.5.0-1.src.rpm
checksum_type: sha256
description:
  We all have used the console before at one time or another to make text adventures, or even test out functions a what not.

  But sometimes, it can be a real hassle. Having to get a typing animation, but not at the right speed.

  Wait no more! The ConsoleHelp pip package makes all of that so much easier! Use the installation table to get started with installing the package!!

  |Manager          |Command                                       |
  |:----------------|:---------------------------------------------|
  |**pip**          |`pip install ConsoleHelp`                          |
  |**poetry**       |`python -m poetry add ConsoleHelp`                 |
  |**Repl.it**      |Search `ConsoleHelp` in the package tab and add it.(coming soon)|     |



  Printing in python is nice an all, but sometimesI just looks so premade. To solve this, you need to make it look like someone is typing out text, **LIVE**. But how do you do that. Well, we may not show the code, but we sure can show you how to use in in console help! Here is a demonstration:

  ``` python
  import ConsoleHelp as window # We recomend you change the name to something that is not ConsoleHelp
  window.sp("Hello World")
  ```

  This will simulate typing. Cool right! Try it out!

  But while this works, maybe you want color? Maybe you need important text to stand out so the user will pay more attantion to it. Well, we took that into account too!

  First, we have printing with the colored text. We allow you to use this by doing:
  ```python
  import ConsoleHelp as window # We recomend you change the name to something that is not ConsoleHelp
  window.printred("This will be red")
  ```

  It will then log your string into the terminal to be printed as red text. You can get a full list of them here:

  * `printred(`
  * `printgreen(`
  * `printorange(`
  * `printcyan(`
  * `printblue(`
  * `printmagenta(`

  That is a full list of them now, but there will be so many more coming to you in the future! And most likely they will be moved to another class function, so make sure to follow our readme's to make sure you have the latest updates!

  Now, I'm sure that some of you are asking, "But how do I get the sp function to have color". We also took the liberty of designing that too! It is in the color class function right now, it is small, but many things will be moved there and there is more to be developed there. But, here is how the sp function can have color in it:
  ``` python
  import ConsoleHelp as window # We recomend you change the name to something that is not ConsoleHelp
  window.color.spc("This will be red", 'red')
  ```

  Let's break down how this function works. The window is our import(duh), and color is the class it is apart of. The color class is small curently, but will grow in time! After that, is spc. The the sp in spc stands for slow print, and the c in there stands for color. So, it means slow print color. Cool right! Then in quotation marks, you can put in your text, after that, put a comma and in quots put in your color. We have the same colors as the print func, so to find the colors, go there!.



  The math module is made to make your math needs easier, and faster! A lot of people are bad at math, and this class function will make it easier. We have addition, subtraction, division, and mulitplacation. To use this, do:

  ``` python
  import ConsoleHelp as window # We recomend you change the name to something that is not ConsoleHelp
  window.math.add(1, 2)
  ```
  This will return the number `3`. We also have

  * `window.math.add(1, 2)`
  * `window.math.subtract(4, 1)`
  * `window.math.multiply(1, 3)`
  * `window.math.divide(6, 2)`

  But there is one very special math function. It is called `window.math.rand(num1, num2)`.


pkgId: f8dd7b86356694cfec44b7fbdb6451cddb1f864b91132e4c6b3eea26b7244de0
name: python-ConsoleMasterPy
arch: src
version: 1.0.7.1
epoch: 0
release: 1
summary: Console/Terminal functionality
url: https://pypi.org/project/ConsoleMasterPy/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConsoleMasterPy-1.0.7.1-1.src.rpm
checksum_type: sha256
description:
  ConsoleMasterPy is a Python library that simplifies console manipulation on Windows systems. It provides functionalities for changing console colors, hiding/showing the cursor, setting console window size, and more.


  You can install ConsoleMasterPy using pip:
  ```bash
  pip install ConsoleMasterPy
  ```


  ```python
  from ConsoleMasterPy import ConsoleMaster
  ```

  ```python
  console = ConsoleMaster(title="My Console", font_size=17, window_width=30, window_height=25)
  ```

  ```python
  console.change_console_color(background_color=(0, 0, 0), foreground_color=(255, 255, 255))
  ```

  ```python
  console.print_with_color(rgb_background=(0, 0, 0), rgb_foreground=(255, 255, 255), element_to_print="Hello, World!")
  ```

  ```python
  console.change_windows_size(width=40, height=30)
  ```

  ```python
  console.hide_cursor()
  ```

  ```python
  console.pause()
  ```

  ```python
  console.go_xy(x=10, y=5)
  ```

  ```python
  console.change_pixel_size(size=20)
  ```

  ```python
  console.clean_zone(x_coord_init=5, y_coord_init=5, x_coord_end=15, y_coord_end=10)
  ```

  ```python
  console.clean_windows()
  ```

  ```python
  console.pause()
  ```



  This function generates a random name with a mix of vowels and consonants.
  ```python
  from ConsoleMasterPy import generate_name

  name = generate_name()
  print(name)
  ```



  The `exception_handler` function is a decorator used to handle exceptions within functions. It catches any exceptions that occur during the execution of the decorated function and logs the error message, along with a timestamp, to a file named `log.txt`. This decorator ensures that the program can continue running smoothly even if an exception occurs, providing better error handling and debugging.



  - `func`: The function to be decorated with exception handling.



  ```python
  @exception_handler
  def my_function():
      
      pass
  ```


  ```python
  from ConsoleMasterPy import ConsoleMaster, exception_handler
  import random
  from time import sleep

  def copy_matrix(matrix):
      return [row[:] for row in matrix]

  width, height = 35, 35
  console_manager = ConsoleMaster("GAME OF LIFE", 13, width, height)

  @exception_handler
  def main():
      generation_counter = 0

      while True:
          if generation_counter == 0:
              current_matrix = [[0 for x in range(width)] for y in range(height)]
              next_matrix = copy_matrix(current_matrix)
              cell_color = [random.randint(0, 255) for _ in range(3)]

              live_cell_rules = [random.randint(0, 1) for _ in range(9)]
              birth_rules = [random.randint(0, 1) for _ in range(9)]

              for x in range(width):
                  next_matrix[x][0] = 0
                  next_matrix[x][height - 1] = 0
                  next_matrix[x][1] = 1
                  next_matrix[x][height - 2] = 1

              for y in range(height):
                  next_matrix[0][y] = 0
                  next_matrix[width - 1][y] = 0
                  next_matrix[1][y] = 1
                  next_matrix[width - 2][y] = 1

              for x in range(1, width - 1):
                  for y in range(1, height - 1):
                      cell_value = next_matrix[x][y]
                      console_manager.go_xy(x, y)
                      color = cell_color if cell_value else [0, 0, 0]
                      console_manager.print_with_color(color, [0, 0, 0], " ")
              generation_counter = 300

          generation_counter -= 1

          current_matrix = copy_matrix(next_matrix)
          for x in range(1, width - 1):
              for y in range(1, height - 1):
                  neighbors = [(x + i, y + j) for i in range(-1, 2) for j in range(-1, 2) if not (i == 0 and j == 0)]
                  count = sum(1 for i, j in neighbors if 0 <= i < width and 0 <= j < height and current_matrix[i][j] == 1)

                  if current_matrix[x][y] == 1:
                      if not live_cell_rules[count]:
                          next_matrix[x][y] = 0
                          console_manager.go_xy(x, y)
                          console_manager.print_with_color([0, 0, 0], [0, 0, 0], " ")
                      else:
                          next_matrix[x][y] = 1
                  else:
                      if birth_rules[count]:
                          next_matrix[x][y] = 1
                          console_manager.go_xy(x, y)
                          console_manager.print_with_color(cell_color, [0, 0, 0], " ")
                      else:
                          next_matrix[x][y] = 0
          sleep(0.05)

  main()
  ```


pkgId: 58a0a68bd588c0b3712cb16de758e68a1be309a7e8ee29ded3d4de131e620bda
name: python-Contentstack
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: Contentstack is a headless CMS with an API-first approach.
url: https://github.com/contentstack/contentstack-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Contentstack-1.10.0-1.src.rpm
checksum_type: sha256
description:
  <!-- ![Python package](https://github.com/contentstack/contentstack-python/workflows/Python%20package/badge.svg?branch=master) -->

  ![build](https://img.shields.io/badge/build-passing-green?style=plastic)
  ![Coverage](https://raw.githubusercontent.com/contentstack/contentstack-python/b4edf799276f586dce3e57fa5502036cd5fd8da3/coverage.svg) ![pip](https://img.shields.io/badge/pip-v1.8.0-blue?style=plastic) ![python](https://img.shields.io/badge/python-3.5|3.6|3.7|3.8-blue?style=plastic) [![GitHub license](https://img.shields.io/github/license/contentstack/contentstack-python?style=plastic)](https://github.com/contentstack/contentstack-python/blob/master/LICENSE) [![GitHub stars](https://img.shields.io/github/stars/contentstack/contentstack-python?style=plastic)](https://github.com/contentstack/contentstack-python/stargazers)



  Contentstack is a headless CMS with an API-first approach. It is a CMS that developers can use to build powerful
  cross-platform applications in their favorite languages. Build your application frontend, and Contentstack will take
  care of the rest. [Read More](https://www.contentstack.com/).

  Contentstack provides Python SDK to build application on top of Python. Given below is the detailed guide and helpful
  resources to get started with our Python SDK.



  You will need python 3 installed on your machine. You can install it
  from [here](https://www.python.org/ftp/python/3.7.4/python-3.7.4-macosx10.9.pkg).



  To use the Contentstack Python SDK to your existing project, perform the steps given below:



  ```pyhton
  pip install contentstack
  ```

  Install latest [contentstack](https://pypi.org/project/Contentstack) package from the [PyPI](https://pypi.org)

  This is the preferred method to install contentstack, as it will always install the most recent stable release. If you
  don't have [pip](https://pip.pypa.io/) installed,
  this [Python installation guide](http://docs.python-guide.org/en/latest/starting/installation/) can guide you through
  the process





  A stack is like a container that holds the content of your app. Learn more
  about [Stacks](https://www.contentstack.com/docs/developers/set-up-stack).



  Content type lets you define the structure or blueprint of a page or a section of your digital property. It is a
  form-like page that gives Content Managers an interface to input and upload
  content. [Read more](https://www.contentstack.com/docs/developers/create-content-types).



  An entry is the actual piece of content created using one of the defined content types. Learn more
  about [Entries](https://www.contentstack.com/docs/content-managers/work-with-entries).



  Assets refer to all the media files (images, videos, PDFs, audio files, and so on) uploaded to Contentstack. These files
  can be used in multiple entries. Read more
  about [Assets](https://www.contentstack.com/docs/content-managers/work-with-assets).



  A publishing environment corresponds to one or more deployment servers or a content delivery destination where the
  entries need to be published. Learn how to work
  with [Environments](https://www.contentstack.com/docs/developers/set-up-environments).





  To initialize the SDK, specify application API key, access token, and environment name of the stack as shown in the
  snippet given below, You can provide optional parameters for config:

  ```python
  stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
  ```

  To get the API credentials mentioned above, log in to your Contentstack account and then in your top panel navigation,
  go to Settings &gt; Stack to view the API Key and Access Token.



  To retrieve a single entry from a content type use the code snippet given below:

  ```python
  stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
  content_type = stack.content_type("content_type_uid")
  entry = content_type.entry("entry_uid")
  result = entry.fetch()
  ```



  To retrieve multiple entries of a particular content type, use the code snippet given below:

  ```python
  stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
  query = stack.content_type("content_type_uid").query()
  result = query.find()
  ```



  You can query for content types, entries, assets and more using our Python API Reference.

  [Python API Reference Doc](https://www.contentstack.com/docs/platforms/python/api-reference/)



  We have introduced Image Delivery APIs that let you retrieve images and then manipulate and optimize them for your
  digital properties. It lets you perform a host of other actions such as crop, trim, resize, rotate, overlay, and so on.

  For example, if you want to crop an image (with width as 300 and height as 400), you simply need to append query
  parameters at the end of the image URL, such as, `https://images.contentstack.io/v3/assets/download?crop=300,400`. There
  are several more parameters that you can use for your images.

  [Read Image Delivery API documentation](https://www.contentstack.com/docs/platforms/python/api-reference/).

  You can use the Image Delivery API functions in this SDK as well. Here are a few examples of its usage in the SDK.

  ```python
  image = stack.image_transform(url, {'quality': 100}).get_url()
  image = stack.image_transform(url, {'width': 100, 'height': 100}).get_url()
  image = stack.image_transform(url, {'auto': 'webp'}).get_url()
  ```



  The Sync API takes care of syncing your Contentstack data with your application and ensures that the data is always
  up-to-date by providing delta updates. Contentstack’s Python SDK supports Sync API, which you can use to build powerful
  applications.

  ```python
  stack = contentstack.Stack('api_key', 'delivery_token', 'environment')  # initialize sync
  response = stack.sync_init()  # sycn using sync token
  response = stack.sync_token('sync_token')  # sycn using pagination token
  response = stack.pagination('pagination_token')  # sync using multiple parameters
  response = stack.sync_init(publish_type='entry_published', content_type_uid='content_type_uid')
  ```

  Read through to understand how to use the Sync API with Contentstack Python SDK.

  [Using the Sync API with Python SDK](https://www.contentstack.com/docs/developers/python/using-the-sync-api-with-python-sdk)



  - [Contentstack Website](https://www.contentstack.com)
  - [Official Documentation](https://contentstack.com/docs)
  - [Content Delivery API Docs](https://www.contentstack.com/docs/developers/apis/content-delivery-api/)



  Copyright © 2012-2023 [Contentstack](https://www.contentstack.com/). All Rights Reserved

  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.

  - [Content Delivery API Docs](https://contentstack.com/docs/apis/content-delivery-api/)


pkgId: f6a51ba92639013f70293c6f57a1715de3448c4191645dbd1513084a535ff63a
name: python-Context-Aware-Jenkins-Job-Transfers
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Transfers Jobs b/w Jenkins Servers with relevant Views & Plugins
url: https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/index.html
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Context-Aware-Jenkins-Job-Transfers-1.0.3-1.src.rpm
checksum_type: sha256
description:
  **Context Aware Jenkins Job Transfers** provides a pythonic way of transferring jobs between two Jenkins Servers. It is essentially a Python wrapper for the Jenkins REST API, allowing users to transfer jobs along with their associated views and plugins, resulting in a **Context Aware Jenkins Job Transfer**.



  - **Transfer Job(s)**
  - **Transfer View(s)**
  - **Check for Plugin Dependencies** of Jobs/Views
  - **Clean Up Jenkins Servers**
  - **Visualize all functionalities** in a well-crafted terminal screen


  For more details, check out the [**Supported Functionalities**](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html) section, including information on how to install the project.





  - [Installation](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/installation.html)
  - [Supported Functionalities](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html)
      - [Connect to Jenkins Servers](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html#connect-to-jenkins-servers)
      - [Transfer Jobs or Views](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html#transfer-jobs-or-views)
      - [Check Publish Standards](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html#check-publish-standards)
      - [Check Plugin Dependencies](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html#check-plugin-dependencies)
      - [Check and Install Plugin Dependencies](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html#check-and-install-plugin-dependencies)
      - [Clean Up Production](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html#clean-up-production)
      - [Clean Up Interim](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html#clean-up-interim)
      - [Set Console Size](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/usage.html#set-console-size)
  - [known Issues](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/knownIssues.html)
  - [Change Log](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/changeLog.html)
  - [Contributions](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/contribution.html)
  - [Apache License](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/license.html)
  - [FAQs](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/FAQs.html)
  - [Contributors](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/contributors.html)
  - [Contact the Author](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/contact.html)
  - [Acknowledgements](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/acknowledgement.html)




  The current available methods of moving jobs among jenkins servers are described [here](https://medium.com/@rajinikanthvadla9/jenkins-moving-from-one-server-to-another-server-methods-39437733b1e0)

  | **Feature**                | **Context Aware Jenkins Job Transfers**                                                | **Other Jenkins Transfer Tools**                           |
  |----------------------------|----------------------------------------------------------------------------------------|------------------------------------------------------------|
  | **Job Transfer**            | Seamless transfer of jobs between Jenkins servers with associated views and plugins.    | Basic job transfer functionality; often lacks comprehensive job context. |
  | **View Transfer**           | Transfers views (all jobs in views) in a single operation.                                    | No support for transfering views |
  | **Plugin Dependency Check** | Automatically checks for plugin dependencies and resolves them during the transfer.     | Requires manual handling of plugin dependencies.            |
  | **Terminal Visualization**  | Full visualization of transfer steps in the terminal for better user interaction.       | Often lacks terminal-level feedback or logging.             |
  | **Python Integration**      | Written in Python for easy integration with other Python projects.                      | Often script-heavy or requires additional configuration files. |
  | **Scope for Workflows to be Built Pythonically**      | Written in Python for easy integration with other Python projects.                      | Often script-heavy or requires additional configuration files. |




  Kindly check out the [known Issues](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/knownIssues.html) to keep track of known Issues. If the Issue is NOT found, kindly create a new ID at the [Issues](https://github.com/joelkariyalil/Jenkins-Transfers/issues) page!



  Check out the [List of Contributors](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/contributors.html) who have helped build this project.



  Feel free to reach out via [Social Media Handles](https://context-aware-jenkins-transfers-documentation.readthedocs.io/en/latest/contact.html#social-media-handles) for any questions or feedback.



  Consider supporting the author through [Buy Me a Coffee](https://buymeacoffee.com/joelkariyalil).


pkgId: b311dbe48fde9427a52cbbeccf1cc1c0798fb6330574b2dd27232cd530f3124f
name: python-ContrastGCN
arch: src
version: 0.1.3
epoch: 0
release: 1
url: https://pypi.org/project/ContrastGCN/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ContrastGCN-0.1.3-1.src.rpm
checksum_type: sha256
summary:
  ContrastGCN: An interpretable ensemble framework for automatic cell type annotation in single-cell chromatin accessibility data

description:
  ContrastGCN is an interpretable ensemble framework that integrates contrastive learning and Graph Convolutional Networks (GCN) to efficiently and automatically annotate cell types in scCAS data. Through extensive experiments across diverse datasets, ContrastGCN has demonstrated superior performance not only in accurately annotating known cell types but also in effectively identifying novel cell types absent in the training set. ContrastGCN also shows robustness across scCAS datasets with varying levels of imbalance and cell counts. Notably, ContrastGCN excels in cross-batch and cross-tissue annotations, indicating its broad applicability in scCAS data analysis. Moreover, comprehensive downstream analyses further reveal that ContrastGCN can deliver valuable cell-type-specific biological insights, thereby greatly enhancing our understanding of intricate biological mechanisms.


pkgId: 9229d9e4f0b3d5503a3265b6fc38820b162d7bf2efce56088c5378e819f20933
name: python-ControlBurn
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Feature Selection by Sparse Forests
url: https://github.com/brianliu12437/ControlBurnPackage
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ControlBurn-0.1.3-1.src.rpm
checksum_type: sha256
description:
  This package implements ControlBurn in python. ControlBurn is a feature selection algorithm that uses a weighted LASSO-based feature selection to prune unnecessary features from tree ensembles. The algorithm is efficient and only requires a single training iteration to run.

  Tree ensembles distribute feature importance scores evenly amongst groups of correlated features. The average feature ranking of the correlated group is suppressed, which reduces interpretability and complicates feature selection. Like the linear LASSO, ControlBurn assigns all the feature importance of a correlated group of features to a single feature. The algorithm is able to quickly select a subset of important independent features for further analysis.




  The easiest way to install ControlBurn is through pip.
  ```sh
  !pip install ControlBurn==0.1.3
  ```




  ControlBurn works on python 3.7 or above. The following packages are required.

  -   numpy (1.20.1)
  -   pandas (1.2.4)
  -   sklearn (0.24.1)
  -   mosek (9.2.47)
  -   cvxpy (1.1.13)


  ```python
  from ControlBurn.ControlBurnModel import ControlBurnClassifier
  cb = ControlBurnClassifier(alpha = 0.1)
  cb.fit(X,y)
  print(cb.features_selected_) #print selected features
  print(cb.feature_importances_) #print feature importances

  pred = cb.predict(X) #return predictions of polished model using selected features
  ```


  ControlBurn: Feature Selection by Sparse Forests B. Liu, M. Xie, and M. Udell
  ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD), 2021


pkgId: dabef1bdc707e38d2673d31fba265bdf126fb5fc227dae9d8a33ce3d52ce79bd
name: python-ControlManual
arch: src
version: 0.0.4.0
epoch: 0
release: 1
summary: A universal console-like interface
url: https://github.com/ZeroIntensity/ControlManual
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ControlManual-0.0.4.0-1.src.rpm
checksum_type: sha256
description:
  ![https://pypi.org/project/ControlManual/](https://img.shields.io/pypi/v/ControlManual)
  ![https://pypi.org/project/ControlManual/](https://img.shields.io/pypi/dm/ControlManual)
  ![https://github.com/ZeroIntensity/ControlManual/blob/main/LICENSE](https://img.shields.io/github/license/ZeroIntensity/ControlManual)
  ![https://github.com/ZeroIntensity/ControlManual](https://img.shields.io/github/last-commit/ZeroIntensity/ControlManual)
  ![https://github.com/ZeroIntensity/ControlManual](https://img.shields.io/github/issues/ZeroIntensity/ControlManual)
  ![https://libraries.io/pypi/ControlManual](https://img.shields.io/librariesio/release/pypi/ControlManual)
  ![https://python.org](https://img.shields.io/pypi/pyversions/ControlManual)







  To run via downloading the source, use the following commands.

  ```
  $ git clone https://github.com/ZeroIntensity/ControlManual && cd ControlManual
  $ python3 -m pip install -r requirements.txt
  $ python3 run.py
  ```



  ```
  $ pip3 install ControlManual
  $ python3 -m ControlManual
  ```



  If you have [pipx](https://pypa.github.io/pipx/) installed, you can easily run using the following command:

  ```
  $ pipx run ControlManual
  ```


pkgId: 5714f2247f277872c085eaf02a371500b347d88962b645e77d94a51d62cd5930
name: python-Convertly-LINE
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/Convertly-LINE/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Convertly-LINE-0.1.2-1.src.rpm
checksum_type: sha256
description:
  The general idea of this library called Convertly is to provide an easy tool to convert various units such as measures, currency and time.

  To develop this library and create a converter, a set of functions was created. These functions allow for the conversion of various measurements and currencies, as well as the ability to convert time between different countries.


  * Measure converter
      - It will be possible to convert measures in the International System of Units, in the imperial and US customary measurement systems and in between both of them.
      - Measurements of length (m), mass (kg), time (s), thermodynamic temperature (K), etc. can be converted.
  * Time converter
      - Convert the time of one country to another.
  * Currency converter
  	You can convert currencies around the world.


pkgId: 01bcd500ca4fc5d82d7546f4f7f7472d59d3758cd179da3438914f607629b627
name: python-ConvexTrader
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: A package for portfolio optimization using convex optimization
url: https://github.com/ACquantclub/Applications-of-Convex-Optimization
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ConvexTrader-0.0.0-1.src.rpm
checksum_type: sha256
description:
  Fall 2024 Project: Applications of Convex Optimization





  1. **Clone the repository**:
      ```bash
      git clone https://github.com/yourusername/Applications-of-Convex-Optimization.git
      cd Applications-of-Convex-Optimization
      ```

  2. **Create a virtual environment**:
      ```bash
      python3 -m venv env
      ```

  3. **Activate the virtual environment**:
      - On macOS and Linux:
          ```bash
          source env/bin/activate
          ```
      - On Windows:
          ```bash
          .\env\Scripts\activate
          ```



  1. **Install the required packages**:
      ```bash
      pip install -r requirements.txt
      ```



  1. **Navigate to the tests directory**:
      ```bash
      cd tests
      ```

  2. Follow the instructions in the README located in the tests directory to run the tests.

rpm_license:
  MIT License  Copyright (c) 2024 Amherst College Quant Club  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: a3c9e7b709ba53c2b8a2cee89c7074449ca549997f7ca4129690ca89b457ce0a
name: python-CoolAMQP
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Very fast pure-Python AMQP client
url: https://github.com/smok-serwis/coolamqp
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CoolAMQP-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![license](https://img.shields.io/github/license/mashape/apistatus.svg)]()
  **Warning!!** Since v1.3.1 development has been moved
  from [GitHub](https://github.com/smok-serwis/coolamqp) to this GitLab.
  To install CoolAMQP please use
  ```bash
  pip install --extra-index-url https://git.dms-serwis.com.pl/api/v4/groups/330/-/packages/pypi/simple coolamqp
  ```
  Or state it at the beginning of your `requirements.txt`:
  ```python
  --extra-index-url https://git.dms-serwis.com.pl/api/v4/groups/330/-/packages/pypi/simple
  coolamqp
  ```


pkgId: 92eef201e65e600373999950795bb322a31bffc1e68dbf8b932bd63f4061d38a
name: python-CoolDB
arch: src
version: 0.2
epoch: 0
release: 1
url: https://github.com/enelfo/CoolDB
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CoolDB-0.2-1.src.rpm
checksum_type: sha256
summary:
  CoolDB - это модуль для удобного использования баз данных, таких как sqlite3 и aiosqlite - для синхронного и асинхронного взаимодействия с базами данных

description:
  <h1 align="center">CoolDB</h1>
  <h3 align="center">CoolDB - это модуль для удобного использования баз данных на основе sqlite3 - для синхронного и асинхронного взаимодействия с базами данных.</h3>
  <h1></h1>


  <h4>SyncDataBaseRequests - это надстройка над sqlite3, призванная ускорить работу с базами данных sqlite в синхронном режиме.</h4>

  > <h5>Пример синхронного использования</h5>
  > Прелесть синхронного режима функций в том, что мы можем вызывать их, как в синхронном режиме, так и в асинхронном из кроутин, либо блокируя их действие, либо прокидывая их в асинхронный режим, по средствам asyncio.to_thread().
  > И все таки более предпочтительным будет использовать асинхнонные варианты функций, чтобы попросту экономить мощности.



  ```python3

  from CoolDB.SyncDataBaseRequests import RegRequests



  def main():
  	if RegRequests.get_db(
  		dataBase="path/filename",
  		table_name="your_table_name",
  		columns="(name TEXT, age INTEGER, sex TEXT)"
  	) is False:
  		return 1

  	if RegRequetsts.insert_to_db(
  		dataBase="path/filename",
  		table_name="your_table_name",
  		parameters=["Игорь", 41, "Боевой вертолет СУ-34"]
  	) is False:
  		return 1

  	print(RegRequests.fetch_all(
  			dataBase="path/filename",
  			table_name="your_table_name"
  		))



  if __name__ == "__main__":
  	main()

  ```

  <h1></h1>



  <h4>AsyncDataBaseRequests - это надстройка над aiosqlite, призванная ускорить работу с базами данных sqlite в асинхронном режиме.</h4>

  > <h5>Пример асинхронного использования</h5>
  > При асинхронном режиме все точно также, только функции вызываются из кроутин.



  ```python3

  import asyncio
  from CoolDB.AsyncDataBaseRequests import RegRequests



  async def main():
  	if await RegRequests.get_db(
  		dataBase="path/filename",
  		table_name="your_table_name",
  		columns="(name TEXT, age INTEGER, sex TEXT)"
  	) is False:
  		return 1

  	if await RegRequetsts.insert_to_db(
  		dataBase="path/filename",
  		table_name="your_table_name",
  		parameters=["Игорь", 41, "Боевой вертолет СУ-34"]
  	) is False:
  		return 1

  	print(await RegRequests.fetch_all(
  			dataBase="path/filename",
  			table_name="your_table_name"
  		))



  if __name__ == "__main__":
  	asyncio.run(main())

  ```
  <h1></h1>



  <h4>Разница между синхронном и асинхронным режимами в импортруемых модулях и в том, что в асинхронном режими функции вызываются из кроутин с добавлением ключевого слова await.</h4>
  <h1></h1>



  <h3 align="center">Документация</h3>
  <h6 align="center">В CoolDB собраны регулярные функции взаимодействия с базами данных и помещены в класс RegRequest модуля SyncDataBaseRequests или AsyncDataBaseRequests и начиная с версии 0.2 ряд функция был дополнен классом MultiConditiionsRequests, далее в документации функции, которые вошли в этот класс будут помечены:</h6>
  <h1></h1>





  <h5 align="center">Функция get_db()</h5>
  <h6 align="center">Функция get_db() используется для создания таблицы в базе данных, если такой еще не существует. Попутно создает и базу данных, если ее еще не существует.</h6>


  ```python3

  get_db(dataBase: str, table_name: str, columns: str) -> bool


  ```

  Функция get_db() принимает три аргумента:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.

  3. columns - столбцы, с которыми необходимо будет создать базу данных, если она еще не была создана. Должны передаваться в формате строки формата: "(SQL_VARS)".
  > <h5>Пример</h5>
  > parameters = "(name TEXT, age INTEGER, sex TEXT)"

  Пример использования:

  ```python3

  if RegRequests.get_db(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	columns="(name TEXT, age INTEGER, sex TEXT)"
  ) is False:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция insert_to_db()</h5>
  <h6 align="center">Функция insert_to_db() используется для добавления элементов во все столбцы таблицы. Попутно создает и базу данных, если ее еще не существует.</h6>


  ```python3

  insert_to_db(dataBase: str, table_name: str, parameters: list) -> bool


  ```

  Функция insert_to_db() принимает три аргумента:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.

  3. parameters - параметры, которые необходимо будет поместить в базу данных. Должны передаваться в формате списка из переменных или значений.


  Пример использования:

  ```python3

  if RegRequests.insert_to_db(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	parameters=[X, Y, N, 42]
  ) is False:
  	return 1

  ```
  > <h5>Примечания</h5>
  > insert_to_db() записывает значения во все существующие столбцы, поэтому количество передаваемых параметров, должно быть равным количеству существующих столбцов.
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция insert_to_db_one_par()</h5>
  <h6 align="center">Функция insert_to_db_one_par() используется для добавления элемента или элементов в определенный столбец или столбцы таблицы. Попутно создает и базу данных, если ее еще не существует.</h6>


  ```python3

  insert_to_db_one_par(dataBase: str, table_name: str, column_name: str, parameter: str) -> bool


  ```

  Функция insert_to_db_one_par() принимает четыре аргумента:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.

  3. column_name - названия столбца или столбцов, куда необходимо записать значения. Названия столбцов должны передаваться списком из названий в формате строки.

  4. parameter - параметр, который необходимо будет поместить в базу данных или несколько параметров для определенных столбцов. Должны передаваться в формате строки формата "'X', 'Y', 'N'".


  Пример использования:

  ```python3

  if RegRequests.insert_to_db_one_par(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	column_name="forX, forY, forN"
  	parameter="'X', 'Y', 'N'"
  ) is False:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция fetch_all_where()</h5>
  <h6 align="center">Функция fetch_all_where() используется для извлечения элементов из всех столбцов всех строк, в которых параметр поиска равен значению параметра поиска - условно, извлечь все столбцы всех строк, где айди=13.</h6>


  ```python3


  fetch_all_where(dataBase: str, table_name: str, condition: str, condition_value: str | int) -> list[dict] | None


  fetch_all_where(dataBase: str, table_name: str, condition: list, condition_value: list) -> list[dict] | None


  ```

  Функция fetch_all_where() принимает четыре аргумента:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.

  3. condition - параметер, по которому будет производится поиск в таблице.

  4. condition_value - значение параметра, по которому будет производится поиск в таблице.


  Пример использования:

  ```python3


  if RegRequests.fetch_all_where(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	condition="id_",
  	condition_value="121212"
  ) is None:
  	return 1


  if MultiConditionsRequests.fetch_all_where(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	condition=[
  		"id_",
  		"time"
  	],
  	condition_value=[
  		"121212",
  		"145353"
  	]
  ) is None:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция fetch_all()</h5>
  <h6 align="center">Функция fetch_all() используется для извлечения всех элементов таблицы.</h6>


  ```python3

  fetch_all(dataBase: str, table_name: str) -> list[dict] | None


  ```

  Функция fetch_all() принимает два аргумента:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.


  Пример использования:

  ```python3

  if RegRequests.fetch_all(
  	dataBase="path/filename",
  	table_name="your_table_name"
  ) is None:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция fetch_one()</h5>
  <h6 align="center">Функция fetch_one() используется для извлечения одного элемента таблицы.</h6>



  ```python3


  fetch_one(dataBase: str, table_name: str, column_name: str, condition: str, condition_value: str | int) -> Any | None


  fetch_one(dataBase: str, table_name: str, column_name: str, condition: list, condition_value: list) -> Any | None


  ```

  Функция fetch_one() принимает пять аргументов:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.

  3. column_name - названия столбца, откуда необходимо извлечь значение.

  4. condition - параметер, по которому будет производится поиск в таблице.

  5. condition_value - значение параметра, по которому будет производится поиск в таблице.


  Пример использования:

  ```python3


  if RegRequests.fetch_one(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	column_name="XYN",
  	condition="id_",
  	condition_value="121212"
  ) is None:
  	return 1


  if MultiConditionsRequests.fetch_one(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	column_name="XYN",
  	condition=[
  		"id_",
  		"time"
  	],
  	condition_value=[
  		"121212",
  		"145353"
  	]
  ) is None:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция fetch_one_column()</h5>
  <h6 align="center">Функция fetch_one_column() используется для извлечения всех элементов одного столбца таблицы.</h6>



  ```python3


  fetch_one_column(dataBase: str, table_name: str, column_name: str, condition: str, condition_value: str | int) -> tuple | None



  fetch_one_column(dataBase: str, table_name: str, column_name: str, condition: list, condition_value: list) -> tuple | None

  ```

  Функция fetch_one_column() принимает пять аргументов:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.

  3. column_name - названия столбца, откуда необходимо извлечь значение.

  4. condition - параметер, по которому будет производится поиск в таблице.

  5. condition_value - значение параметра, по которому будет производится поиск в таблице.


  Пример использования:

  ```python3


  if RegRequests.fetch_one(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	column_name="XYN",
  	condition="id_",
  	condition_value="121212"
  ) is None:
  	return 1


  if MultiConditionsRequests.fetch_one(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	column_name="XYN",
  	condition=[
  		"id_",
  		"time"
  	],
  	condition_value=[
  		"121212",
  		"145353"
  	]
  ) is None:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция exists_test()</h5>
  <h6 align="center">Функция exists_test() используется для проверки существования таблицы.</h6>


  ```python3

  exists_test(dataBase: str, table_name: str) -> bool


  ```

  Функция exists_test() принимает два аргумента:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.


  Пример использования:

  ```python3

  if RegRequests.exists_test(
  	dataBase="path/filename",
  	table_name="your_table_name"
  ) is False:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция update_table()</h5>
  <h6 align="center">Функция update_table() используется для обновления определенного элемента определенного столбца.</h6>



  ```python3


  update_table(dataBase: str, table_name: str, column_name: str, new_meaning: str | int, condition: str, condition_value: str | int) -> bool


  update_table(dataBase: str, table_name: str, column_name: str, new_meaning: str | int, condition: list, condition_value: list) -> bool


  ```

  Функция update_table() принимает шесть аргументов:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.

  3. column_name - названия столбца, откуда необходимо извлечь значение.

  4. new_meaning - новое значение выбранного столбца

  5. condition - параметер, по которому будет производится поиск в таблице.

  6. condition_value - значение параметра, по которому будет производится поиск в таблице.


  Пример использования:

  ```python3


  if RegRequests.update_table(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	column_name="XYN",
  	new_meaning="URAURAURAURAURA"
  	condition="id_",
  	condition_value="121212"
  ) is False:
  	return 1


  if MultiConditionsRequests.update_table(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	column_name="XYN",
  	new_meaning="URAURAURAURAURA"
  	condition=[
  		"id_",
  		"time"
  	],
  	condition_value=[
  		"121212",
  		"145353"
  	]
  ) is False:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция delete_from_table()</h5>
  <h6 align="center">Функция delete_from_table() используется для удаления строки, в столбце которой есть совпадения с условием.</h6>


  ```python3


  delete_from_table(dataBase: str, table_name: str, condition: str, condition_value: str | int) -> bool


  delete_from_table(dataBase: str, table_name: str, condition: list, condition_value: list) -> bool


  ```

  Функция delete_from_table() принимает четыре аргумента:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.

  3. condition - параметер, по которому будет производится поиск в таблице.

  4. condition_value - значение параметра, по которому будет производится поиск в таблице.


  Пример использования:

  ```python3


  if RegRequests.delete_from_table(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	condition="id_",
  	condition_value="121212"
  ) is False:
  	return 1


  if MultiConditionsRequests.delete_from_table(
  	dataBase="path/filename",
  	table_name="your_table_name",
  	condition=[
  		"id_",
  		"time"
  	],
  	condition_value=[
  		"121212",
  		"145353"
  	]
  ) is False:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>





  <h5 align="center">Функция delete_table()</h5>
  <h6 align="center">Функция delete_table() используется для удаления всех таблицы избазы данных.</h6>


  ```python3

  delete_table(dataBase: str, table_name: str) -> bool


  ```

  Функция delete_table() принимает два аргумента:

  1. dataBase - путь до файла базы данных. Должен передаваться в формате строки формата: "path/filename".
  > <h5>Примечания</h5>
  > Предпочтительно хранить файл базы данных не глубже одной поддиректории от main файла

  2. table_name - название таблицы в базе данных. Должен передаваться в формате строки.


  Пример использования:

  ```python3

  if RegRequests.delete_table(
  	dataBase="path/filename",
  	table_name="your_table_name"
  ) is False:
  	return 1

  ```
  > <h5>Примечания</h5>
  > В асинхронном режиме должна вызываться из кроутины и должно присутствовать ключевое слово await.
  <h1></h1>


pkgId: a2fcf349defebb01d6209b2fb6b987699a606f52cd5294ea34e827189d0810fa
name: python-Coolcalci
arch: src
version: 3.0.8
epoch: 0
release: 1
summary: This will you to do Arithmetic operations very fast.
url: https://pypi.org/project/Coolcalci/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Coolcalci-3.0.8-1.src.rpm
checksum_type: sha256
description:
  This module is created by python rohan or coolduderohan to make arithmetic operations by a simple command. There is 5 types created in this version of calci, this module will contain calculate and print and calculate but not print only save it like this commands you will find in this module. As if you want decrease the time to do arithmetic operations.


pkgId: 4f629f7860d3d3032f21c7cddafe2ec3848b94940a53e16b7f772b2d2724d91c
name: python-CopaData
arch: src
version: 14.0.0
epoch: 0
release: 1
summary: Read metadata and online data from Report Engine Server
url: https://www.copadata.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CopaData-14.0.0-1.src.rpm
checksum_type: sha256
description:
  This package contains data connectivity modules developed by COPA-DATA.


  - pyZAN


  pyZAN is a module to connect with a Report Engine metadata database. It provides:
  - read access to metadata tables
  - access to connector functions for reading historic variable values, alarms, events, lots, shifts and context lists
  - option to execute SQL Stored Procedures and SQL Userdefined Functions

  Data is returned as pandas DataFrames and can be used in all common data science libraries.


  - pyodbc (requires Microsoft Visual C++ Build Tools)
  - pandas


  - Report Engine 10 or higher OR zenon Analyzer 3.30 or higher
  - Report Engine metadada database including at least one project
  - valid connection to the Report Engine metadata database
  - valid configuration to receive data from at least one of the following connectors:
    - SCADA Service Engine Connector
    - SCADA SQL Connector
    - 3rd Party Database Connector
    - IIoT Services Data Storage Connector


  https://github.com/COPA-DATA/pyZAN


pkgId: 53c233ba22eb31982bacb456bee385c407fb4a1842cd56e8e9d0fa72af541c7b
name: python-CopperUI
arch: src
version: 3.5.2
epoch: 0
release: 1
summary: a TUI helper package
url: https://github.com/Copperhead-software/CopperUI/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CopperUI-3.5.2-1.src.rpm
checksum_type: sha256
description:
  CopperUI is a python package, which is designed to fix my personal grievances. it changes and shortens syntax to be easier to read, and makes TUI applications easier to write.


  CopperUI is a python package made for making simple applications and tools in the command line.


  CopperUI uses shortcuts to change syntax, but comes with extra packages that I find absolutley necessary for most TUI projects.



  **all** projects that use project copperhead features (for now just copperUI) will be featured on this repo. you can be featured by @ing [Morgandri1](https://twitter.com/Morgandri1dev), or [Copperhead Software](https://twitter.com/CopperSoftware) on twitter, making an issue, or creating a discussion on github.


  a simple command line text editor by Morgandri1: [SnakeSkin](https://github.com/Morgandri1/SnakeSkin)
  <br>[![img1.png](https://i.postimg.cc/v8qLgxJL/img1.png)](https://postimg.cc/5jzFDyN6)



  CopperUI makes it easier to make TUI applications, starting with personalization. **all** textual functions include a color, background, and text option. this lets you change the color to match everything.

  CopperApp is a wrapper to help make organizing your apps more easily



  Through pip:
      <br>``pip install CopperUI``

  [LEGACY] Manual build:
      <br>    run setup.py
      <br>    add copperhead.py to root directory of project. (or wherever you want it.)


pkgId: 64a959066ed456c3ec32e94466c070ea5993e5e5942c9c012c1ef936761f343f
name: python-Coquille
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Coquille is a library that wraps terminal escape sequences as convenient functions.
url: https://pypi.org/project/Coquille/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Coquille-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Coquille (IPA: `/kɔ.kij/`, english: 'shell' or 'typo') is a library that wraps terminal escape sequences to easily apply them to a stream.



  Requires Python 3.9 or higher.

  This library attempts to cover as many escape sequences as possible ; but it is not an exhaustive list, some might be missing. Also, you might find that few have no effect on your terminal emulator.

  This library is based on the following resources:

  - The Wikipedia page: <https://en.m.wikipedia.org/wiki/ANSI_escape_code>
  - Some Microsoft documentation about console virtual terminal sequences: <https://learn.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences>



  Even though the examples are mostly showcasing [SGR escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters) (because they are pretty visible), Coquille can do more! See the [documentation](#documentation).



  ```py
  from coquille import Coquille

  print("Hello World!")


  with Coquille.new("fg_magenta", "italic") as coquille:
      print("Hello World, but in magenta and italic!")
      coquille.apply("bold")
      print("Now, with a touch of bold :D")

  print("Oh, we are back to normal now...")

  ```

  ![screenshot.png](https://raw.githubusercontent.com/qexat/Coquille/main/examples/coquille_context/screenshot.png)

  Source code: [examples/coquille_context/](https://github.com/qexat/Coquille/blob/main/examples/coquille_context/__main__.py)



  ```py
  from coquille import write

  print("Hello World!")

  write("Hello World, but in magenta and italic!", "fg_magenta", "italic")

  with open("examples/write/output.txt", "w") as my_file:
      write("A pretty Hello World in a file!", "fg_blue", "bold", file=my_file)

  ```

  ![screenshot.png](https://raw.githubusercontent.com/qexat/Coquille/main/examples/write/screenshot.png)

  Source code: [examples/write/](https://github.com/qexat/Coquille/blob/main/examples/write/__main__.py)



  ```py
  from coquille import Coquille
  from coquille.sequences import fg_truecolor

  print("Normal Hello World!")

  coquille = Coquille.new(fg_truecolor(128, 255, 0))
  coquille.write("Colorful Hello World!")

  ```

  ![screenshot.png](https://raw.githubusercontent.com/qexat/Coquille/main/examples/coquille_write/screenshot.png)

  Source code: [examples/coquille_write/](https://github.com/qexat/Coquille/blob/main/examples/coquille_write/__main__.py)





  ```sh
  pip install coquille
  ```



  ```sh
  pip install coquille[dev]
  ```

  This allows you to run the tests:

  ```sh
  coverage run -m pytest
  ```

  Then check the coverage:

  ```sh
  coverage report -m
  ```



  Coming soon! 🚧



  If you like Coquille, you might want to check these projects as well:

  - [Colorama](https://github.com/tartley/colorama): a simple cross-platform colored terminal text in Python, by [Jonathan Hartley](https://github.com/tartley)
  - [Rich_](https://github.com/Textualize/rich): a Python library for rich text and beautiful formatting in the terminal, by [Will McGugan](https://github.com/willmcgugan)
  - [Dahlia](https://github.com/dahlia-lib/dahlia): a simple text formatting package, inspired by the game Minecraft, by [trag1c](https://github.com/trag1c/)

rpm_license:
  MIT License  Copyright (c) 2023 Qexat  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: 07b275904afc84ad0cbba7a0871a4f525fa8b5426a6df8584ca69a2819730ff8
name: python-CoreMS
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Mass Spectrometry Framework for Small Molecules Analysis
url: https://github.com/EMSL-Computing/CoreMS
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CoreMS-3.1.0-1.src.rpm
checksum_type: sha256
description:
  ![CoreMS Logo](https://github.com/EMSL-Computing/CoreMS/blob/master/docs/CoreMS.COLOR_small.png?raw=true)

  <div align="left">

  <br>
  <br>
  <a href="https://doi.org/10.5281/zenodo.14009575"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.14009575.svg" alt="DOI"></a>
  <br>
  </div>


  - Introduction
    - [CoreMS](#CoreMS)
    - [Current Version](#current-version)
    - [Contact Information](#main-developers/contact )
    - [Documentation](#documentation)
    - [Contribution Information](#contributing)
    - [Data Input](#data-input-formats)
    - [Data Output](#data-output-formats)
    - [Data Structure](#data-structure-types)
    - [Features](#available-features)
  - Installation
    - [Installation](#corems-installation)
    - [Thermo Raw File on Mac and Linux](#thermo-raw-file-access)
  - Execution
    - [Jupyter Notebook and Docker containers](#docker-stack)
    - [Example for FT-ICR Data Processing](#simple-script-example)
    - [Python Examples](examples/scripts)
    - [Jupyter Notebook Examples](examples/notebooks)
  - Sibling Projects
      - [EnviroMS](https://github.com/EMSL-Computing/EnviroMS)
      - [MetaMS](https://github.com/EMSL-Computing/MetaMS)

  ***



  **CoreMS** is a comprehensive mass spectrometry framework for software development and data analysis of small molecules analysis.

  Data handling and software development for modern mass spectrometry (MS) is an interdisciplinary endeavor requiring skills in computational science and a deep understanding of MS. To enable scientific software development to keep pace with fast improvements in MS technology, we have developed a Python software framework named CoreMS. The goal of the framework is to provide a fundamental, high-level basis for working with all mass spectrometry data types, allowing custom workflows for data signal processing, annotation, and curation. The data structures were designed with an intuitive, mass spectrometric hierarchical structure, thus allowing organized and easy access to the data and calculations. Moreover, CoreMS supports direct access for almost all vendors’ data formats, allowing for the centralization and automation of all data processing workflows from the raw signal to data annotation and curation.

  CoreMS aims to provide
  - logical mass spectrometric data structure
  - self-containing data and metadata storage
  - modern molecular formulae assignment algorithms
  - dynamic molecular search space database search and generator

  ***



   `3.1.0`

  ***


  - [Yuri. E. Corilo](mailto:corilo@pnnl.gov)
  - [William Kew](mailto:william.kew@pnnl.gov)
  - [Katherine Heal](mailto:katherine.heal@pnnl.gov)

  ***



  API documentation can be found [here](https://emsl-computing.github.io/CoreMS/corems.html).

  Overview slides can be found [here](https://github.com/EMSL-Computing/CoreMS/blob/master/examples/CoreMS-Overview.pdf).

  ***



  As an open source project, CoreMS welcomes contributions of all forms. Before contributing, please see our [Dev Guide](./CONTRIBUTING.md)

  ***




  - Bruker Solarix (CompassXtract)
  - Bruker Solarix transients, ser and fid (FT magnitude mode only)
  - ThermoFisher (.raw)
  - Spectroswiss signal booster data-acquisition station (.hdf5)
  - MagLab ICR data-acquisition station (FT and magnitude mode) (.dat)
  - ANDI NetCDF for GC-MS (.cdf)
  - mzml for LC-MS (.mzml)
  - Generic mass list in profile and centroid mde (include all delimiters types and Excel formats)
  - CoreMS exported processed mass list files(excel, .csv, .txt, pandas dataframe as .pkl)
  - CoreMS self-containing Hierarchical Data Format (.hdf5)
  - Pandas Dataframe
  - Support for cloud Storage using s3path.S3path



  - Pandas data frame (can be saved using pickle, h5, etc)
  - Text Files (.csv, tab separated .txt, etc)
  - Microsoft Excel (xlsx)
  - Automatic JSON for metadata storage and reuse
  - Self-containing Hierarchical Data Format (.hdf5) including raw data and time-series data-point for processed data-sets with all associated metadata stored as json attributes



  - LC-MS
  - GC-MS
  - Transient
  - Mass Spectra
  - Mass Spectrum
  - Mass Spectral Peak
  - Molecular Formula

  ***





  - Apodization, Zerofilling, and Magnitude mode FT
  - Manual and automatic noise threshold calculation
  - Peak picking using apex quadratic fitting
  - Experimental resolving power calculation
  - Frequency and m/z domain calibration functions:
  - LedFord equation
  - Linear equation
  - Quadratic equation
  - Automatic search most abundant **Ox** homologue series
  - Automatic local (SQLite) or external (PostgreSQL) database check, generation, and search
  - Automatic molecular formulae assignments algorithm for ESI(-) MS for natural organic matter analysis
  - Automatic fine isotopic structure calculation and search for all isotopes
  - Flexible Kendrick normalization base
  - Kendrick filter using density-based clustering
  - Kendrick classification
  - Heteroatoms classification and visualization



  - Baseline detection, subtraction, smoothing
  - m/z based Chromatogram Peak Deconvolution,
  - Manual and automatic noise threshold calculation
  - First and second derivatives peak picking methods
  - Peak Area Calculation
  - Retention Index Calibration
  - Automatic local (SQLite) or external (MongoDB or PostgreSQL) database check, generation, and search
  - Automatic molecular match algorithm with all spectral similarity methods



  - Peak shape (Lorentz,  Gaussian, Voigt, and pseudo-Voigt)
  - Peak fitting for peak shape definition
  - Peak position in function of data points, signal to noise and resolving power (Lorentz and Gaussian)
  - Prediction of mass error distribution
  - Calculated ICR Resolving Power based on magnetic field (B), and transient time(T)


  - Two dimensional (m/z and retention time) peak picking using persistent homology
  - Smoothing, cetroid detection, and integration of extracted ion chromatograms
  - Peak shape metric calculations including half peak height, tailing factor, and dispersity index
  - MS1 deconvolution of mass features
  - Idenfitication of <sup>13</sup>C isotopes within the mass features
  - Compatibility with molecular formula searching on MS1 or MS2 spectra
  - Spectral search capability using entropy similarity

  ***



  ```bash
  pip install corems
  ```

  By default the molecular formula database will be generated using SQLite

  To use Postgresql the easiest way is to build a docker container:

  ```bash
  docker-compose up -d
  ```

  -  Change the url_database on MSParameters.molecular_search.url_database to: "postgresql+psycopg2://coremsappdb:coremsapppnnl@localhost:5432/coremsapp"
  -  Set the url_database env variable COREMS_DATABASE_URL to: "postgresql+psycopg2://coremsappdb:coremsapppnnl@localhost:5432/coremsapp"



  To be able to open thermo file a installation of pythonnet is needed:
  - Windows:
      ```bash
      pip install pythonnet
      ```

  - Mac and Linux:
      ```bash
      brew install mono
      pip install pythonnet
      ```

  ***



  Another option to use CoreMS is to run the docker stack that will start the CoreMS containers



  A docker container containing:
  - A custom python distribution will all dependencies installed
  - A Jupyter notebook server with workflow examples
  - A PostgreSQL database for the molecular formulae assignment

  If you don't have docker installed, the easiest way is to [install docker for desktop](https://hub.docker.com/?overlay=onboarding)

  1. Start the containers using docker-compose (easiest way):

      On docker-compose-jupyter.yml there is a volume mapping for the tests_data directory with the data provided for testing, to change to your data location:

      - locate the volumes on docker-compose-jupyter.yml:

      ```bash
      volumes:
        - ./tests/tests_data:/home/CoreMS/data
      ```
      - change "./tests/tests_data" to your data directory location

      ```bash
      volumes:
        - path_to_your_data_directory:/home/corems/data
      ```
      - save the file and then call:

      ```bash
      docker-compose -f docker-compose-jupyter.yml up
      ```

  2. Another option is to manually build the containers:

      - Build the corems image:
          ```bash
          docker build -t corems:local .
          ```
      - Start the database container:
          ```bash
          docker-compose up -d
          ```
      - Start the Jupyter Notebook:
          ```bash
          docker run --rm -v ./data:/home/CoreMS/data corems:local
          ```

      - Open your browser, copy and past the URL address provided in the terminal: `http://localhost:8888/?token=<token>.`

      - Open the CoreMS-Tutorial.ipynb


  ***



  More examples can be found under the directory examples/scripts, examples/notebooks

  - Basic functionality example

  ```python
  from corems.transient.input.brukerSolarix import ReadBrukerSolarix
  from corems.molecular_id.search.molecularFormulaSearch import SearchMolecularFormulas
  from corems.mass_spectrum.output.export import HighResMassSpecExport
  from matplotlib import pyplot

  file_path= 'tests/tests_data/ftms/ESI_NEG_SRFA.d'


  bruker_reader = ReadBrukerSolarix(file_path)


  bruker_transient_obj = bruker_reader.get_transient()


  T =  bruker_transient_obj.transient_time


  mass_spectrum_obj = bruker_transient_obj.get_mass_spectrum(plot_result=False, auto_process=True)







  SearchMolecularFormulas(mass_spectrum_obj, first_hit=False).run_worker_mass_spectrum()


  for mspeak in mass_spectrum_obj.sort_by_abundance():

      
      if  mspeak:

          
          molecular_formula = mspeak.molecular_formula_lowest_error

          
          pyplot.plot(mspeak.mz_exp, mspeak.abundance, 'o', c='g')

          
          for molecular_formula in mspeak:

              
              if molecular_formula.is_isotopologue:

                  
                  print (molecular_formula.string)

                  
                  print (molecular_formula['13C'])
      else:
          
          print(mspeak.mz_exp,mspeak.abundance)



  mass_spectrum_obj.to_csv("filename")
  mass_spectrum_obj.to_hdf("filename")

  mass_spectrum_obj.to_pandas("filename")


  df = mass_spectrum_obj.to_dataframe()
  ```

  ***



  UML (unified modeling language) diagrams for Direct Infusion FT-MS and GC-MS classes can be found [here](docs/uml).

  ***



  If you use CoreMS in your work, please use the following citation:

  Version [3.1.0 Release on GitHub](https://github.com/EMSL-Computing/CoreMS/releases/tag/v3.1.0), archived on Zenodo:

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

  Yuri E. Corilo, William R. Kew, Lee Ann McCue, Katherine R . Heal, James C. Carr (2024, October 29). EMSL-Computing/CoreMS: CoreMS 3.1.0 (Version v3.1.0), as developed on Github. Zenodo. http://doi.org/10.5281/zenodo.14009575

  ```

  ***


  This material was prepared as an account of work sponsored by an agency of the
  United States Government.  Neither the United States Government nor the United
  States Department of Energy, nor Battelle, nor any of their employees, nor any
  jurisdiction or organization that has cooperated in the development of these
  materials, makes any warranty, express or implied, or assumes any legal
  liability or responsibility for the accuracy, completeness, or usefulness or
  any information, apparatus, product, software, or process disclosed, or
  represents that its use would not infringe privately owned rights.

  Reference herein to any specific commercial product, process, or service by
  trade name, trademark, manufacturer, or otherwise does not necessarily
  constitute or imply its endorsement, recommendation, or favoring by the United
  States Government or any agency thereof, or Battelle Memorial Institute. The
  views and opinions of authors expressed herein do not necessarily state or
  reflect those of the United States Government or any agency thereof.

                   PACIFIC NORTHWEST NATIONAL LABORATORY
                                operated by
                                  BATTELLE
                                  for the
                     UNITED STATES DEPARTMENT OF ENERGY
                      under Contract DE-AC05-76RL01830


pkgId: 491bb929cabac6543b60683db7948c9bd66cba21b595684e55f720dc8a0a2f4d
name: python-CoreNLG
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/societe-generale/core-nlg.git
rpm_license: Apache v2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CoreNLG-2.2.0-1.src.rpm
checksum_type: sha256
description:
  CoreNLG is an easy to use and productivity oriented Python library for Natural Language Generation.\
  It aims to provide the essential tools for developers to structure and write NLG projects.\
  Auto-agreement tools based on extra-resources are <b>not provided</b> in this library.

  [Have a look at our documentation](https://societe-generale.github.io/core-nlg/)


  Happy coding !


pkgId: 4f6713fea4bad9f3c4b72e94904b314b2d2960867eaf289ad9b671511f443bf0
name: python-CorePost
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: A Twisted Web REST micro-framework
url: https://github.com/jacek99/corepost
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CorePost-0.0.16-1.src.rpm
checksum_type: sha256
description:
  Based on *Flask* API, with plans for integrated multiprocessing support for full usage of all CPUs.
  Provides a more Flask/Sinatra-style API on top of the core *twisted.web* APIs.
  Integrates FormEncode for path, form and query argument validation.
  An example of a multi--module twisted.web CorePost REST application
  which exposes two separate REST services (for a Customer and Customer Address entities):
      class CustomerRESTService():
          path = "/customer"
          @route("/")
          def getAll(self,request):
              return DB.getAllCustomers()
          @route("/<customerId>")
          def get(self,request,customerId):
              return DB.getCustomer(customerId)
          @route("/",Http.POST)
          def post(self,request,customerId,firstName,lastName):
              customer = Customer(customerId, firstName, lastName)
              DB.saveCustomer(customer)
              return Response(201)
          @route("/<customerId>",Http.PUT)
          def put(self,request,customerId,firstName,lastName):
              c = DB.getCustomer(customerId)
              (c.firstName,c.lastName) = (firstName,lastName)
              return Response(200)
          @route("/<customerId>",Http.DELETE)
          def delete(self,request,customerId):
              DB.deleteCustomer(customerId)
              return Response(200)
          @route("/",Http.DELETE)
          def deleteAll(self,request):
              DB.deleteAllCustomers()
              return Response(200)
      class CustomerAddressRESTService():
          path = "/customer/<customerId>/address"
          @route("/")
          def getAll(self,request,customerId):
              return DB.getCustomer(customerId).addresses
          @route("/<addressId>")
          def get(self,request,customerId,addressId):
              return DB.getCustomerAddress(customerId, addressId)
          @route("/",Http.POST)
          def post(self,request,customerId,addressId,streetNumber,streetName,stateCode,countryCode):
              c = DB.getCustomer(customerId)
              address = CustomerAddress(streetNumber,streetName,stateCode,countryCode)
              c.addresses[addressId] = address
              return Response(201)
          @route("/<addressId>",Http.PUT)
          def put(self,request,customerId,addressId,streetNumber,streetName,stateCode,countryCode):
              address = DB.getCustomerAddress(customerId, addressId)
              (address.streetNumber,address.streetName,address.stateCode,address.countryCode) = (streetNumber,streetName,stateCode,countryCode)
              return Response(200)
          @route("/<addressId>",Http.DELETE)
          def delete(self,request,customerId,addressId):
              DB.getCustomerAddress(customerId, addressId) #validate address exists
              del(DB.getCustomer(customerId).addresses[addressId])
              return Response(200)
          @route("/",Http.DELETE)
          def deleteAll(self,request,customerId):
              c = DB.getCustomer(customerId)
              c.addresses = {}
              return Response(200)
      def run_rest_app():
          app = RESTResource((CustomerRESTService(),CustomerAddressRESTService()))
          app.run(8080)
      if __name__ == "__main__":
          run_rest_app()
  And the BDD showing off its different features
  https://github.com/jacek99/corepost/blob/master/corepost/test/feature/rest_app.feature
  Links
  `````
  * `Website <http://github.com/jacek99/corepost>`_
  * `Twisted <http://twistedmatrix.com>`_
  * `FormEncode <http://www.formencode.org/>`_
  Changelog
  `````````
  * 0.0.16:
      - minor bug fix for issue #4 (serializing object graphs to XML), removed Jinja2 as dependency:
          https://github.com/jacek99/corepost/issues/4
  * 0.0.15:
      - minor bug fixes in auto-converting responses to JSON and parsing arguments/paths with unexpectec characters
  * 0.0.14:
      - automatic parsing of query, form, JSON, YAML and XML arguments:
        http://jacek99.github.com/corepost/argument_parsing.html
  * 0.0.13:
      - perf fix to avoid unnecessary string concatenation when doing URL routing, after code review (thanks to Gerald Tremblay)
  * 0.0.12:
      - backwards incompatible change: added advanced URL routing for nested REST services.
        CorePost object is gone, REST services are now just standard classes.
        They get wrapped in a RESTResource object (see sample above) when exposed
  * 0.0.11:
      - added support for request/response filters
  * 0.0.10:
      - removed dependency on txZMQ which was not needed at this point (yet)
  * 0.0.9:
       - fix for issue #3 (wrong class passes as 'self' to router method):
           https://github.com/jacek99/corepost/issues/3
  * 0.0.8:
      - support for serializing of classes to JSON,XML,YAML based on caller's Accept header
      - separate routing functionality from CorePost Resource object, in preparation for future multicore support
  * 0.0.7:
      - automatic parsing of incoming content (JSON, YAML, XML)
      - routing by incoming content type
      - automatic response conversion based on caller's Accept header (JSON/YAML
      - support for defer.returnValue() in @inlineCallbacks route methods
  * 0.0.6 - redesigned API around classes and methods, rather than functions and global objects (after feedback from Twisted devs)
  * 0.0.5 - added FormEncode validation for arguments
  * 0.0.4 - path argument extraction, mandatory argument error checking


pkgId: 52d40925d71a5fb0b0d929dd0dbc0034f708c5d4f56a17b63b9d36fb99861b93
name: python-Corporal
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Companion Back-end for CORE-POS
url: https://rattailproject.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Corporal-0.2.4-1.src.rpm
checksum_type: sha256
description:
  <!-- -*- mode: markdown; -*- -->



  This is a starter Rattail project.  See the
  [Rattail website](https://rattailproject.org/)
  for more info.


pkgId: 96ae791647c487eed590cca0171c2d57c33e81198c4c4a6af7490fd0509a237f
name: python-CosRayModifiedISO
arch: src
version: 1.2.8
epoch: 0
release: 1
url: https://github.com/ssc-maire/CosRayModifiedISO
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CosRayModifiedISO-1.2.8-1.src.rpm
checksum_type: sha256
summary:
  A Python library for acquiring galactic cosmic ray spectra at Earth from the ISO model as modified by DLR. All the details and equations about this model can be found in Matthiae et al., A ready-to-use galactic cosmic ray model, Advances in Space Research 51.3 (2013): 329-338, https://doi.org/10.1016/j.asr.2012.09.022 .

description:
  A simple library for running the ISO galactic cosmic ray spectrum model as modified by DLR.

  All the details and equations about this model can be found in Matthiä et al.,
  "A ready-to-use galactic cosmic ray model", Advances in Space Research 51.3 (2013): 329-338, https://doi.org/10.1016/j.asr.2012.09.022 . This model only requires
  a single parameter, *W*, which describes the modulation of the Sun at a given date and time, to calculate the flux of cosmic rays hitting Earth.

  If you use this software for scientific research, please reference the above paper, and this software appropriately according to the appropriate journal publication rules.



  You can either install directly from PyPi using

  ```
  pip install CosRayModifiedISO
  ```

  Or clone CosRayModifiedISO from https://github.com/ssc-maire/CosRayModifiedISO, and then from the cloned directory, run

  ```
  sudo python setup.py install
  ```



  to import this module, use

  ```
  from CosRayModifiedISO import CosRayModifiedISO
  ```

  unless otherwise stated, all of the quantities specified in this library use the following units:
  * Energies are always in units of **MeV**
  * Rigidities are always in units of **GV**
  * Differential energy fluxes are always in units of **cts / cm<sup>2</sup> / s / sr / (MeV/n)**
  * Differential rigidity fluxes are always in units of **cts / cm<sup>2</sup> / s / sr / (GV/n)**

  It should be noted that in the field of space radiation, "energy" is frequently generally used specifically as a shorthand for "kinetic energy" rather than
  the total energy of a particle (rest mass energy + kinetic energy), and all references to "energy" in this library should be assumed to be kinetic energy
  unless otherwise specified.

  All users should be always be careful to remember which differential flux type they are using for their application, as differential
  energy flux and differential rigidity flux are different quantities which have a non-linear conversion between them. In general, differential
  energy flux should always be used when working with energies, and differential rigidity flux should be used when working with particle rigidities.
  If you're trying to create something like a particle 'kinetic energy spectrum' for instance, you should use particle kinetic energy on the x-axis, and the differential
  energy flux on the y-axis (here using energy as a shorthand for kinetic energy).

  Unit description:

  | Symbol      | name |
  | ----------- | ----------- |
  | cm      | centimeter       |
  | s   | seconds        |
  | sr  | steradian |
  | MeV    | Megaelectronvolts |
  | GV | Gigavolts |
  | n | nucleons |



  to get a single differential flux value for a particle value of solar modulation, and for a particular particle with a given atomic number and kinetic energy
  (or range of kinetic energies), the appropriate method for `CosRayModifiedISO` is
  ```
  CosRayModifiedISO.getEnergyFluxesFromEnergies(solarModulationWparameter, atomicNumber, energyListInMeV)
  ```

  For example, the script
  ```
  from CosRayModifiedISO import CosRayModifiedISO

  solarModulationWparameter = 19.25 # the solar modulation at a specific point in the solar cycle
  atomicNumber = 1 # the atomic number of the particle in question - in this case a proton/hydrogen ion, which has an atomic number of 1
  energyListInMeV = 945.2 # kinetic energy of particle in MeV

  print(CosRayModifiedISO.getEnergyFluxesFromEnergies(solarModulationWparameter, atomicNumber, energyListInMeV))
  ```
  gives
  ```
  [0.00012419]
  ```
  as output.

  The argument `energyListInMeV` can be supplied as either a single float or as a list of floats to give either a single differential flux as output,
  or a range of differential fluxes corresponding to each supplied kinetic energy.

  If you instead want to acquire differential rigidity fluxes rather than differential energy fluxes, you can use
  ```
  CosRayModifiedISO.getRigidityFluxesFromRigidities(solarModulationWparameter, atomicNumber, rigidityListInGV)
  ```
  which has exactly the same syntax and usage as the `getEnergyFluxesFromEnergies` method, but where rigidities in GV must be supplied instead
  of kinetic energies in MeV.



  Instead of directly needing to input the solar modulation and required kinetic energies or rigidities for each calculation, methods are available to return
  differential fluxes automatically based on neutron monitor data and a default set of kinetic energies designed to cover a range corresponding to particles
  that are relevant specifically for radiation dose rate calculations in Earth's atmosphere.

  The method
  ```
  CosRayModifiedISO.getSpectrumUsingTimestamp(timestamp, atomicNumber)
  ```
  method can be used to output the differential fluxes for a given date and time, for example,

  ```
  from CosRayModifiedISO import CosRayModifiedISO
  import datetime as dt

  datetimeToUse = dt.datetime(
    year = 2001,
    month = 10,
    day = 27,
    hour = 0,
    minute = 10,
    second = 35
    )

  print(CosRayModifiedISO.getSpectrumUsingTimestamp(datetimeToUse,atomicNumber=1))
  ```
  returns the output
  ```
      Energy (MeV/n)  d_Flux / d_E (cm-2 s-1 sr-1 (MeV/n)-1)  Rigidity (GV/n)  d_Flux / d_R (cm-2 s-1 sr-1 (GV/n)-1)
  0        11.294627                            2.290835e-07         0.146022                           3.522790e-05
  1        14.219093                            3.785376e-07         0.163966                           6.516322e-05
  2        17.900778                            6.157642e-07         0.184152                           1.185919e-04
  3        22.535744                            9.848618e-07         0.206875                           2.120539e-04
  4        28.370820                            1.546788e-06         0.232474                           3.719962e-04
  ...
  ```
  `getSpectrumUsingTimestamp` returns output in the form of a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html).

  This method uses historic values from the [OULU neutron monitor](https://cosmicrays.oulu.fi/) to determine values of solar modulation for input into
  the model, using the method described in [Matthiä et al., (2013)](https://doi.org/10.1016/j.asr.2012.09.022). Currently only dates between 1964/04/01 00:00
  and 2021/01/31 00:00 can be used.

  Count rates from the OULU neutron monitor (or representative values) can be supplied directly into the model using the
  ```
  CosRayModifiedISO.getSpectrumUsingOULUcountRate(OULUcountRatePerSecond, atomicNumber)
  ```
  method, where `OULUcountRatePerSecond` is a single float representing the count rate per second of the OULU neutron monitor at a given instance of time.
  The solar modulation parameter can also be supplied directly using
  ```
  CosRayModifiedISO.getSpectrumUsingSolarModulation(solarModulationWparameter, atomicNumber)
  ```
  This function can be identically supplied with the monthly averaged sunspot number instead of the solar modulation parameter, which the solar modulation parameter
  is essentially a proxy for. Alternatively the identical function

  ```
  CosRayModifiedISO.getSpectrumUsingSSN(sunspotNumber, atomicNumber)
  ```
  can be used instead for code understandability.

  Each of these three methods output Pandas DataFrames in the same format as outputted by `getSpectrumUsingTimestamp`. The value of the solar modulation parameter
  as a function of OULU neutron monitor monitor count rate can also be outputted by running

  ```
  CosRayModifiedISO.getWparameterFromOULUcountRate(OULUcountRateInSeconds)
  ```



  In addition to the above spectrum calculation methods, there are also several methods for performing conversion between different quantities for input and output.

  The methods
  ```
  CosRayModifiedISO.convertParticleRigidityToEnergy(particleRigidityInGV,
                                              particleMassAU,
                                              particleChargeAU)
  ```
  and
  ```
  CosRayModifiedISO.convertParticleRigidityToEnergy(particleRigidityInGV,
                                              particleMassAU,
                                              particleChargeAU)
  ```
  can be used to convert particle rigidities to kinetic energies and vice versa, respectively. Currently particle rigidities and energy *must* be supplied
  as [Pandas Series objects](https://pandas.pydata.org/docs/reference/api/pandas.Series.html). Particle masses and charges here must be inputted as single numbers
  and in atomic units.

  The methods
  ```
  CosRayModifiedISO.convertParticleRigiditySpecToEnergySpec(particleRigidityInGV,
                                                      fluxInRigidityGVform,
                                                      particleMassAU,
                                                      particleChargeAU)
  ```
  and
  ```
  CosRayModifiedISO.convertParticleEnergySpecToRigiditySpec(particleKineticEnergyInMeV,
                                                      fluxInEnergyMeVform,
                                                      particleMassAU,
                                                      particleChargeAU)
  ```
  can be used to convert differential rigidity flux to differential energy flux and vice versa, respectively. Both the particle rigidity values and their
  respective differential flux values must be inputted as [Pandas Series objects](https://pandas.pydata.org/docs/reference/api/pandas.Series.html).

  The particle mass for all of these methods can be acquired directly from atomic number using
  ```
  CosRayModifiedISO.getAtomicMass(atomicNumber)
  ```



  Thank you to Daniel Matthiä and others at DLR for allowing us to test their model initially using their own scripts.

  This package contains and for certain functions uses data from the OULU neutron monitor, as acquired from https://www.nmdb.eu/ , where data can also be found at https://cosmicrays.oulu.fi/ . We therefore acknowledge the NMDB database www.nmdb.eu, founded under the European Union's FP7 programme (contract no. 213007) for providing data.


pkgId: af55eef06d675789ebc3fd2ef045b54e75d7a20be02d1f5cc87e61e1b0b317eb
name: python-CouchDB
arch: src
version: 1.2
epoch: 0
release: 1
summary: Python library for working with CouchDB
url: https://github.com/djc/couchdb-python/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CouchDB-1.2-1.src.rpm
checksum_type: sha256
description:
  This is a Python library for CouchDB. It provides a convenient high level
  interface for the CouchDB server.


pkgId: 98ec2a3d711046edcb5f4345119cfb8703aad57be4acd2fa7b77b52985737c48
name: python-Countrydetails
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: A python package for retrieving data of all the countries in the world.
url: https://github.com/manumanoj0010/countrydetails
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Countrydetails-1.0.8-1.src.rpm
checksum_type: sha256
description:
  A python package for retrieving data from all the countries in the world.

  ![](https://raw.githubusercontent.com/manumanoj0010/countrydetails/master/Readme_Images/cd.jpeg)



  ```python
  pip install countrydetails
  ```



  There are 2 modules -
  1. Retrieving data of all countries **(Module Countries)**
  2. Retrieving data of a single country **(Module Country)**





  - [countries()](#countries)
  - [phone_code()](#phone_code)
  - [currencies()](#currencies)
  - [capitals()](#capitals)
  - [continents()](#continents)
  - [countries_in_continents()](#countries_in_continents)
  - [regions()](#regions)
  - [countries_in_region()](#countries_in_region)
  - [states()](#states)



  - [info()](#info)
  - [name()](#name)
  - [states()](#states)
  - [cities()](#cities)
  - [states_and_cities()](#states_and_cities)
  - [iso()](#iso)
  - [alt_spelling()](#alt_spellings)
  - [area()](#area)
  - [borders()](#borders)
  - [capital()](#capital)
  - [calling_codes()](#calling_codes)
  - [independence()](#independence)
  - [currency()](#currency)
  - [capital_latlng()](#capital_latlng)
  - [demonym()](#demonym)
  - [flag()](#flag)
  - [languages()](#languages)
  - [latlang()](#latlng)
  - [native_name()](#native_name)
  - [population()](#population)
  - [timezones()](#timezones)
  - [tld()](#tld)
  - [translations()](#translations)
  - [continents()](#continent)
  - [temperature()](#temperature)
  - [government()](#government)
  - [expectancy()](#expectancy)
  - [dish()](#dish)
  - [symbol()](#symbol)
  - [desnity()](#density)
  - [region()](#region)
  - [religion()](#religion)
  - [total_states()](#total_states)
  - [total_cities()](#total_cities)
  - [wiki()](#wiki)
  - [gei_json()](#geo_json)
  - [all()](#all)




  > For the sake of simplicity, I will be showing less data in outputs here.


  Returns the list of all available countries in the world

  ``` python
  from Countrydetails import countries

  data = countries.all_countries()
  data.countries()

  ```

  ``` python
  ['Afghanistan', 'Aland Islands', 'Albania', 'Algeria', 'American Samoa', 'Andorra', 'Angola', 'Anguilla', 'Antarctica', 'Antigua And Barbuda', 'Argentina', 'Armenia', 'Aruba', 'Australia', 'Austria', 'Azerbaijan', 'Bahamas The',  'Vietnam', 'Virgin Islands (British)', 'Virgin Islands (US)', 'Wallis And Futuna Islands', 'Western Sahara', 'Yemen', 'Zambia', 'Zimbabwe']

  ```


  Returns phone codes of each country in a dictionary

  ``` python
  from countrydetails import countries

  country = countries.all_countries()
  print(country.phone_code())

  ```

  ``` python
  {'Afghanistan': '93', 'Aland Islands': '+358-18', 'Albania': '355', 'Algeria': '213', 'American Samoa': '+1-684', 'Andorra': '376', 'Angola': '244', 'Anguilla': '+1-264', 'Antarctica': '', 'Antigua And Barbuda': '+1-268', 'Argentina': '54', 'Armenia': '374', 'Aruba': '297', 'Australia': '61', 'Austria': '43', 'Azerbaijan': '994', 'Bahamas The': '+1-242', 'Bahrain': '973', 'Bangladesh': '880',

  ```


  Returns currencies of each country in a dictionary

  ```python
  from countrydetails import countries

  country = countries.all_countries()
  print(country.currencies())

  ```

  ```python
  {'Afghanistan': 'AFN', 'Aland Islands': 'EUR', 'Albania': 'ALL', 'Algeria': 'DZD', 'American Samoa': 'USD', 'Andorra': 'EUR', 'Angola': 'AOA', 'Anguilla': 'XCD', 'Antarctica': '', 'Antigua And Barbuda': 'XCD', 'Argentina': 'ARS', 'Belgium': 'EUR', 'Belize': 'BZD', 'Benin': 'XOF', 'Bermuda': 'BMD', 'Bhutan': 'BTN', 'Bolivia': 'BOB', 'Bosnia and Herzegovina': 'BAM', 'Botswana': 'BWP',

  ```


  Returns captial cities of each country in a dictionary
  ```python
  from countrydetails import countries

  country = countries.all_countries()
  print(country.capitals())
  ```
  ```python
  {'Afghanistan': 'Kabul', 'Aland Islands': 'Mariehamn', 'Albania': 'Tirana', 'Algeria': 'Algiers', 'American Samoa': 'Pago Pago', 'Andorra': 'Andorra la Vella', 'Angola': 'Luanda', 'Anguilla': 'The Valley', 'Antarctica': '', 'Antigua And Barbuda': "St. John's",  'Bahamas The': 'Nassau', 'Bahrain': 'Manama', 'Bangladesh': 'Dhaka', 'Barbados': 'Bridgetown', 'Belarus': 'Minsk', 'Belgium': 'Brussels', 'Belize': 'Belmopan',
  ```


  Returns continents of each country
  ```python
  from countrydetails import countries

  country = countries.all_countries()
  print(country.continents())
  ```

  ```
  [{'country': 'Afghanistan', 'continent': 'Asia'}, {'country': 'Albania', 'continent': 'Europe'}, {'country': 'Algeria', 'continent': 'Africa'}, {'country': 'American Samoa', 'continent': 'Oceania'}, {'country': 'Andorra', 'continent': 'Europe'}, {'country': 'Angola', 'continent': 'Africa'}, {'country': 'Anguilla', 'continent': 'North America'},{'country': 'Antarctica', 'continent': 'Antarctica'}],

  ```


  Returns a list of countries present in a continent
  ```python
  from countrydetails import countries

  country = countries.all_countries()
  print(country.countries_in_continents())
  ```

  ```python
  {'Asia': ['Afghanistan', 'Armenia', 'Azerbaijan', 'Bahrain', 'Bangladesh', 'Bhutan', 'Brunei', 'Cambodia', 'China', 'Cyprus', 'East Timor', 'Georgia', 'Hong Kong', 'India', 'Indonesia', 'Iran', 'Iraq', 'Israel', 'Japan', 'Jordan', 'Kazakhstan', 'Kuwait', 'Kyrgyzstan', 'Laos', 'Lebanon',   'Tajikistan', 'Thailand', 'Turkey', 'Turkmenistan', 'United Arab Emirates', 'Uzbekistan', 'Vietnam', 'Yemen']
  ```


  Returns countries with its region
  ```python
  from countrydetails import countries

  country = countries.all_countries()
  print(country.regions())
  ```

  ```python
  [{'country': 'Afghanistan', 'location': 'Southern and Central Asia'}, {'country': 'Albania', 'location': 'Southern Europe'}, {'country': 'Algeria', 'location': 'Northern Africa'}, {'country': 'American Samoa', 'location': 'Polynesia'}, {'country': 'Andorra', 'location': 'Southern Europe'}, {'country': 'Aruba', 'location': 'Caribbean'}, {'country': 'Australia', 'location': 'Australia and New Zealand'},
  ```


  Returns list of countries present in its region
  ```python
  from countrydetails import countries

  country = countries.all_countries()
  print(country.countries_in_region())
  ```

  ```python
  {'Antarctica': ['Antarctica', 'Heard Island and McDonald Islands', 'South Georgia and the South Sandwich Islands'], 'Eastern Europe': ['Belarus', 'Hungary', 'Moldova', 'Poland', 'Romania', 'Ukraine'], 'Southern Europe': ['Albania', 'Andorra',   'Italy', 'North Macedonia', 'Yugoslavia'], 'Western Europe': ['Austria', 'Belgium', 'France', 'Germany', 'Liechtenstein',  'Switzerland'], 'North America': ['Bermuda',  'United States'],
  ```


  Returns all the available states in the world with its state code
  ```python
  from countrydetails import countries

  country = countries.all_countries()
  print(country.states())
  ```
  ```python
  {'id': 1836, 'name': 'Nenets Autonomous Okrug', 'state_code': 'NEN'}, {'id': 1857, 'name': 'Nizhny Novgorod Oblast', 'state_code': 'NIZ'}, {'id': 1834, 'name': 'Novgorod Oblast', 'state_code': 'NGR'}, {'id': 1888, 'name': 'Novosibirsk', 'state_code': 'NVS'}, {'id': 1846, 'name': 'Omsk Oblast', 'state_code': 'OMS'}, {'id': 1886, 'name': 'Orenburg Oblast', 'state_code': 'ORE'}, {'id': 1908, 'name': 'Oryol Oblast', 'state_code': 'ORL'}, {'id': 1909, 'name': 'Penza Oblast', 'state_code': 'PNZ'}, {'id': 1871, 'name': 'Perm Krai', 'state_code': 'PER'}, {'id': 1833, 'name': 'Primorsky Krai', 'state_code': 'PRI'}, {'id': 1863, 'name': 'Pskov Oblast', 'state_code': 'PSK'}, {'id': 1852, 'name': 'Republic of Adygea', 'state_code': 'AD'}
  ```







  ```python
  from Countrydetails import country

  country = country.country_details('India')  #you can give your desired country
  print(country.info())
  ```
  ```

  ```


  Returns the name of the country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.name())

  ```

  ```
  India
  ```



  Returns all available in a  states list
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.states())

  ```
  ```python
  ['Andaman and Nicobar Islands', 'Andhra Pradesh', 'Arunachal Pradesh', 'Assam', 'Bihar', 'Chandigarh', 'Chhattisgarh', 'Dadra and Nagar Haveli', 'Daman and Diu', 'Delhi', 'Goa', 'Gujarat', 'Haryana', 'Himachal Pradesh', 'Jammu and Kashmir', 'Jharkhand', 'Karnataka', 'Kerala', 'Ladakh', 'Lakshadweep', 'Madhya Pradesh', 'Maharashtra', 'Manipur', 'Meghalaya', 'Mizoram', 'Nagaland', 'Odisha', 'Puducherry', 'Punjab', 'Rajasthan', 'Sikkim', 'Tamil Nadu', 'Telangana', 'Tripura',
  'Uttar Pradesh', 'Uttarakhand', 'West Bengal']
  ```



  Returns all available cities in a list
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.cities())

  ```

  ```python

  ['Bamboo Flat', 'Nicobar', 'Port Blair', 'South Andaman', 'Addanki', 'Ādoni', 'Akasahebpet', 'Akivīdu', 'Akkarampalle', 'Amalāpuram', 'Amudālavalasa', 'Anakāpalle', 'Anantapur', 'Atmakūr', 'Attili', 'Avanigadda', 'Badvel', 'Banganapalle', 'Bāpatla', 'Betamcherla', 'Bhattiprolu', 'Bhīmavaram', 'Bhīmunipatnam', 'Bobbili', 'Challapalle', 'Chemmumiahpet', 'Chilakalūrupet', 'Chinnachowk', 'Chīpurupalle', 'Chīrāla', 'Chittoor',  'Diguvametta', 'East Godāvari', 'Elamanchili', 'Puttaparthi', 'Puttūr', 'Rājahmundry',  'Takdah', 'Taki', 'Tamluk', 'Tarakeswar', 'Titagarh', 'Tufanganj', 'Tulin', 'Uchalan', 'Ula', 'Uluberia', 'Uttar Dinajpur district', 'Uttarpara Kotrung']
  ```


  Returns states and cities in a dict
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.states_and_cities())
  ```

  ```python

  [{'id': 142095, 'name': 'South 24 Parganas district', 'latitude': '22.16197000', 'longitude': '88.43170000'}, {'id': 142096, 'name': 'Srikhanda', 'latitude': '23.60000000', 'longitude': '88.08330000'}, {'id': 142097, 'name': 'Srirampur', 'latitude': '23.35000000', 'longitude': '88.12000000'}, {'id': 142098, 'name': 'Suri', 'latitude': '23.91666667', 'longitude': '87.53333333'}, {'id': 142099, 'name': 'Swarupnagar community development block', 'latitude': '22.83330000', 'longitude': '88.86670000'}, {'id': 142100, 'name': 'Takdah', 'latitude': '27.03330000', 'longitude': '88.36670000'}, ]}]
  ```



  Returns ISO codes for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.iso())

  ```

  ```
  {'alpha2': 'IN', 'alpha3': 'IND'}
  ```

  ```python
  Returns alternate spellings for the name of a specified country
  from Countrydetails import country

  country = country.country_details('India')
  print(country.alt_spellings())

  ```

  ```
  ['IN', 'Bhārat', 'Republic of India', 'Bharat Ganrajya']
  ```

  Returns area (km²) for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.area())

  ```

  ```
  3287590
  ```

  Returns bordering countries (ISO3) for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.borders())

  ```

  ```
  ['AFG', 'BGD', 'BTN', 'MMR', 'CHN', 'NPL', 'PAK', 'LKA']
  ```

  Returns capital city for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.capital())

  ```

  ```
  New Delhi
  ```


  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.calling_codes())

  ```

  ```
   ["91"]
  ```

  Returns independence year for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.independence())

  ```

  ```
  1947
  ```

  Returns official currency for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.currency())

  ```

  ```
  ['INR']
  ```

  Returns capital city latitude and longitude for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.capital_latlng())

  ```

  ```
  [28.614179, 77.202266]
  ```

  Returns the demonyms for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.demonym())

  ```

  ```
  Indian
  ```

  Returns SVG link of the official flag for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.flag())

  ```

  ```
  Sorry there is no link for indain flag :(
  ```


  Returns all spoken languages for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.languages())

  ```

  ```
  ['Asami', 'Bengali', 'Gujarati', 'Hindi', 'Kannada', 'Malayalam', 'Marathi', 'Odia', 'Punjabi', 'Tamil', 'Telugu', 'Urdu', 'Sanskrit', 'English', 'Konkani', 'Nepali', 'Bodo', 'Kashmiri', 'Maithili', 'Santali', 'Sindhi']
  ```

  Returns approx latitude and longitude for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.latlng())

  ```

  ```
   [20, 77]
  ```

  Returns the name of the country in its native tongue
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.native_name())

  ```

  ```
  भारत
  ```

  Returns the population of the specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.population())

  ```

  ```
  1263930000
  ```

  Returns the timezones of a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.timezones())

  ```

  ```
  ['UTC+05:30']
  ```

  Returns the domain extension of a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.tld())

  ```

  ```
  ['.in']
  ```

  Returns translations of a given country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.translations())

  ```

  ```
  {'de': 'Indien', 'es': 'India', 'fr': 'Inde', 'ja': 'インド', 'it': 'India'}
  ```

  Returns the continent of a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.continent())

  ```

  ```
  Asia
  ```

  Returns the average temperature for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.temperature())

  ```

  ```
  23.65
  ```

  Returns the type of government for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.government())

  ```

  ```
  Federal Republic
  ```

  Returns the life expectancy of a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.expectancy())

  ```

  ```
  62.5
  ```

  Returns the national dish of a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.dish())

  ```

  ```
  No officially announced national dish
  ```

  Returns the national symbol of a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.symbol())

  ```

  ```
  animal
  ```

  Returns the density of a specified country in sq km
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.density())

  ```

  ```
  454.9380726
  ```

  Returns the region of a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.region())

  ```

  ```
  Southern and Central Asia
  ```

  Returns the religion of the specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.religion())

  ```

  ```
  Hinduism
  ```

  Returns the total number of states for the specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.total_states())

  ```

  ```
  37 #including union territories
  ```

  Return total numnber of cities for the specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.total_cities())

  ```

  ```
  3865
  ```

  Returns the Wikipedia page link for the specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.wiki())

  ```

  ```
  http://en.wikipedia.org/wiki/india
  ```

  Returns the every available data of all the countries in the world
  ```python
  from Countrydetails import country

  country = country.country_details()
  print(country.all())

  ```

  ```python

  ```


  Returns geoJSON for a specified country
  ```python
  from Countrydetails import country

  country = country.country_details('India')
  print(country.geo_json())

  ```

  ```
  {
          "type": "FeatureCollection",
          "features": [
              {
                  "type": "Feature",
                  "id": "IND",
                  "properties": {
                      "name": "India"
                  },
                  "geometry": {
                      "type": "Polygon",
                      "coordinates": [
                          [
                              [
                                  77.837451,
                                  35.49401
                              ],
                              [
                                  78.912269,
                                  34.321936
                              ],
                              [
                                  78.811086,
                                  33.506198
                              ],
                              [
                                  77.837451,
                                  35.49401
                              ]
                          ]
                      ]
                  }
              }
          ]
      },
  ```





  A Passionate Python & Full Stack Developer

  <a href="https://www.linkedin.com/in/manumanoj0010/" target="_blank"><img src="https://github.com/aritraroy/social-icons/blob/master/linkedin-icon.png?raw=true" width="60"></a>

  [![GitHub stars](https://img.shields.io/github/stars/manumanoj0010/countrydetails.svg?style=social&label=Star)](https://github.com/manumanoj0010/countrydetails) [![GitHub forks](https://img.shields.io/github/forks/manumanoj0010/countrydetails.svg?style=social&label=Fork)](https://github.com/manumanoj0010/countrydetails/fork) [![GitHub watchers](https://img.shields.io/github/watchers/manumanoj0010/countrydetails?style=social&label=Watch)](https://github.com/manumanoj0010/countrydetails) [![GitHub followers](https://img.shields.io/github/followers/manumanoj0010.svg?style=social&label=Follow)](https://github.com/manumanoj0010)


pkgId: 8e0eec3000cfe4f62666defc7a72376c71613786262be3338068df77ee764040
name: python-CoverGPT
arch: src
version: 1.3.3
epoch: 0
release: 1
url: https://github.com/mahfoozm/CoverGPT
rpm_license: gpl-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CoverGPT-1.3.3-1.src.rpm
checksum_type: sha256
summary:
  Generate a personalized and formatted cover letter for a given job position, using your resume to add personalized details. Utilizes ChatGPT.


pkgId: 2d492bed05e3ad30592127426aef60dd9e5684c4139f9c1bc8073de810a41d12
name: python-CovidPyLib
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Simple Python library to work with DCCs (Digital Covid Certificates)
url: https://github.com/CovidPyLib
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CovidPyLib-0.1.4-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/340c661b7668410b977e42a2c351cffa)](https://app.codacy.com/gh/CovidPyLib/CovidPy?utm_source=github.com&utm_medium=referral&utm_content=CovidPyLib/CovidPy&utm_campaign=Badge_Grade_Settings)

  CovidPy is a python library to work with DCCs (Digital Covid Certificates).
  Using this library you can:

  - Decode the content of a DCC and get the raw json
  - Encode a VALID json and create a recognizable DCC (it will only work with a json containing a valid DCC's info and will still be marked as invalid since it's not signed with a valid european private key)
  - Verify a DCC it will verify the validity of a DCC also checking if it's not revoked

  Please remember that this library is in it's early stages and it's not complete, there could be some bugs or missing features, if you find any, please report in an issue
  if you have any question you can open an issue or ask me on [telegram](https://t.me/cagavo)
  if you know how to improve this library, please send me a pull request, you can find a list of things to do [here](#TODO)



  ``` bash
  pip install covidpylib
  ```

  or

  ``` bash
  pip install git+https://github.com/covidpylib/covidpy
  ```


  If you are searching for an example you can try [GreenPassValidator](https://github.com/CovidPyLib/GreenPassValidator), a very simple telegram bot that shows how to use this library



  - Files used to encode DCCs were generated using [this](https://github.com/ehn-dcc-development/ehn-sign-verify-python-trivial/blob/main/gen-csca-dsc.sh)
  - To get Public Keys we use [this API](https://verifier-api.coronacheck.nl/v4/verifier/public_keys)
  - To get the revoked DCCs we use [this API](https://get.dgc.gov.it/v1/dgc/settings)



  - Update verificaton to use the italian API (https://get.dgc.gov.it/v1/) instead of the old one (https://verifier-api.coronacheck.nl/v4/)
  - Support verification rules
  - Docs
  - Examples




  ![GPLV3.0LATERLOGO](https://www.gnu.org/graphics/gplv3-or-later.png "Licensed under GPL v3.0 or later")



  - https://forum.italia.it/t/verifica-green-pass-api/25190/85?page=5
  - https://github.com/ministero-salute/dcc-utils/issues/1
  - https://ec.europa.eu/health/system/files/2021-04/digital-green-certificates_dt-specifications_en_0.pdf
  - https://ec.europa.eu/health/documents/community-register/html/
  - https://github.com/ehn-dcc-development/ehn-dcc-schema


pkgId: b14d7978aada72d3dffe1f3e5ae230c7018018e5faa7f414afd113d8ad297e25
name: python-Cp2kData
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: A Small Package to Postprocess Cp2k Output
url: https://pypi.org/project/Cp2kData/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cp2kData-0.7.1-1.src.rpm
checksum_type: sha256
description:
  ![Python package](https://github.com/robinzyb/cp2kdata/actions/workflows/ci.yml/badge.svg)
  ![Coverage Status](https://img.shields.io/codecov/c/github/robinzyb/cp2kdata)
  ![pythonv](https://img.shields.io/pypi/pyversions/cp2kdata)
  ![pypiv](https://img.shields.io/pypi/v/cp2kdata)
  ![PyPI - pip install](https://img.shields.io/pypi/dm/cp2kdata?logo=pypi&label=pip%20install)
  ![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/cp2kdata?label=conda-forge)

  Python Package to postprocess cp2k data, including cube, pdos, output files




  ```bash
  pip install cp2kdata
  ```


  One can download the source code of cp2kdata by
  ```bash
  git clone https://github.com/robinzyb/cp2kdata.git cp2kdata
  ```
  then use `pip` to install the module from source

  ```bash
  cd cp2kdata
  pip install .
  ```


  - [Manipulate CP2K Output/Log Files](./docs/output.md)
  - [Manipulate CP2K Cube Files](./docs/cube/README.md)
  - [Manipulate CP2K Pdos Files](./docs/pdos/README.md)


  - [Plug in for dpdata](./docs/dpdata_plugin.md)


  Any advice is welcome. If you would like to request a new feature, please open an issue in github and upload example input and output files.


  set environment variable CP2KDATA_LOG_LEVEL to DEBUG to get the complete information.

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


pkgId: 928fa213cd4bdde22ca75b3aaa644c7260abef177690d7ceff0d4b35a273a615
name: python-Crawl4AI
arch: src
version: 0.3.731
epoch: 0
release: 1
summary: 🔥🕷️ Crawl4AI: Open-source LLM Friendly Web Crawler & scraper
url: https://github.com/unclecode/crawl4ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Crawl4AI-0.3.731-1.src.rpm
checksum_type: sha256
description:
  <a href="https://trendshift.io/repositories/11716" target="_blank"><img src="https://trendshift.io/api/badge/repositories/11716" alt="unclecode%2Fcrawl4ai | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

  [![GitHub Stars](https://img.shields.io/github/stars/unclecode/crawl4ai?style=social)](https://github.com/unclecode/crawl4ai/stargazers)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/Crawl4AI)
  [![GitHub Forks](https://img.shields.io/github/forks/unclecode/crawl4ai?style=social)](https://github.com/unclecode/crawl4ai/network/members)
  [![GitHub Issues](https://img.shields.io/github/issues/unclecode/crawl4ai)](https://github.com/unclecode/crawl4ai/issues)
  [![GitHub Pull Requests](https://img.shields.io/github/issues-pr/unclecode/crawl4ai)](https://github.com/unclecode/crawl4ai/pulls)
  [![License](https://img.shields.io/github/license/unclecode/crawl4ai)](https://github.com/unclecode/crawl4ai/blob/main/LICENSE)

  Crawl4AI simplifies asynchronous web crawling and data extraction, making it accessible for large language models (LLMs) and AI applications. 🆓🌐



  Use the [Crawl4AI GPT Assistant](https://tinyurl.com/crawl4ai-gpt) as your AI-powered copilot! With this assistant, you can:

  - 🧑‍💻 Generate code for complex crawling and extraction tasks
  - 💡 Get tailored support and examples
  - 📘 Learn Crawl4AI faster with step-by-step guidance



  - 🐳 Docker Ready: Full API server with seamless deployment & scaling
  - 🎯 Browser Takeover: Use your own browser with cookies & history intact (CDP support)
  - 📝 Mockdown+: Enhanced tag preservation & content extraction
  - ⚡️ Parallel Power: Supercharged multi-URL crawling performance
  - 🌟 And many more exciting updates...



  ✨ Play around with this [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1SgRPrByQLzjRfwoRNq1wSGE9nYY_EE8C?usp=sharing)

  ✨ Visit our [Documentation Website](https://crawl4ai.com/mkdocs/)



  - 🆓 Completely free and open-source
  - 🚀 Blazing fast performance, outperforming many paid services
  - 🤖 LLM-friendly output formats (JSON, cleaned HTML, markdown)
  - 🌐 Multi-browser support (Chromium, Firefox, WebKit)
  - 🌍 Supports crawling multiple URLs simultaneously
  - 🎨 Extracts and returns all media tags (Images, Audio, and Video)
  - 🔗 Extracts all external and internal links
  - 📚 Extracts metadata from the page
  - 🔄 Custom hooks for authentication, headers, and page modifications
  - 🕵️ User-agent customization
  - 🖼️ Takes screenshots of pages with enhanced error handling
  - 📜 Executes multiple custom JavaScripts before crawling
  - 📊 Generates structured output without LLM using JsonCssExtractionStrategy
  - 📚 Various chunking strategies: topic-based, regex, sentence, and more
  - 🧠 Advanced extraction strategies: cosine clustering, LLM, and more
  - 🎯 CSS selector support for precise data extraction
  - 📝 Passes instructions/keywords to refine extraction
  - 🔒 Proxy support with authentication for enhanced access
  - 🔄 Session management for complex multi-page crawling
  - 🌐 Asynchronous architecture for improved performance
  - 🖼️ Improved image processing with lazy-loading detection
  - 🕰️ Enhanced handling of delayed content loading
  - 🔑 Custom headers support for LLM interactions
  - 🖼️ iframe content extraction for comprehensive analysis
  - ⏱️ Flexible timeout and delayed content retrieval options



  Crawl4AI offers flexible installation options to suit various use cases. You can install it as a Python package or use Docker.



  Choose the installation option that best fits your needs:



  For basic web crawling and scraping tasks:

  ```bash
  pip install crawl4ai
  ```

  By default, this will install the asynchronous version of Crawl4AI, using Playwright for web crawling.

  👉 Note: When you install Crawl4AI, the setup script should automatically install and set up Playwright. However, if you encounter any Playwright-related errors, you can manually install it using one of these methods:

  1. Through the command line:

     ```bash
     playwright install
     ```

  2. If the above doesn't work, try this more specific command:

     ```bash
     python -m playwright install chromium
     ```

  This second method has proven to be more reliable in some cases.



  If you need the synchronous version using Selenium:

  ```bash
  pip install crawl4ai[sync]
  ```



  For contributors who plan to modify the source code:

  ```bash
  git clone https://github.com/unclecode/crawl4ai.git
  cd crawl4ai
  pip install -e .
  ```



  Crawl4AI is available as Docker images for easy deployment. You can either pull directly from Docker Hub (recommended) or build from the repository.



  ```bash

  docker pull unclecode/crawl4ai:basic    # Basic crawling features
  docker pull unclecode/crawl4ai:all      # Full installation (ML, LLM support)
  docker pull unclecode/crawl4ai:gpu      # GPU-enabled version


  docker run -p 11235:11235 unclecode/crawl4ai:basic  # Replace 'basic' with your chosen version
  ```



  ```bash

  git clone https://github.com/unclecode/crawl4ai.git
  cd crawl4ai


  docker build -t crawl4ai:local \
    --build-arg INSTALL_TYPE=basic \  # Options: basic, all
    .


  docker run -p 11235:11235 crawl4ai:local
  ```

  Quick test (works for both options):
  ```python
  import requests


  response = requests.post(
      "http://localhost:11235/crawl",
      json={"urls": "https://example.com", "priority": 10}
  )
  task_id = response.json()["task_id"]


  result = requests.get(f"http://localhost:11235/task/{task_id}")
  ```

  For advanced configuration, environment variables, and usage examples, see our [Docker Deployment Guide](https://crawl4ai.com/mkdocs/basic/docker-deployment/).




  ```python
  import asyncio
  from crawl4ai import AsyncWebCrawler

  async def main():
      async with AsyncWebCrawler(verbose=True) as crawler:
          result = await crawler.arun(url="https://www.nbcnews.com/business")
          print(result.markdown)

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





  ```python
  import asyncio
  from crawl4ai import AsyncWebCrawler

  async def main():
      async with AsyncWebCrawler(verbose=True) as crawler:
          js_code = ["const loadMoreButton = Array.from(document.querySelectorAll('button')).find(button => button.textContent.includes('Load More')); loadMoreButton && loadMoreButton.click();"]
          result = await crawler.arun(
              url="https://www.nbcnews.com/business",
              js_code=js_code,
              css_selector=".wide-tease-item__description",
              bypass_cache=True
          )
          print(result.extracted_content)

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



  ```python
  import asyncio
  from crawl4ai import AsyncWebCrawler

  async def main():
      async with AsyncWebCrawler(verbose=True, proxy="http://127.0.0.1:7890") as crawler:
          result = await crawler.arun(
              url="https://www.nbcnews.com/business",
              bypass_cache=True
          )
          print(result.markdown)

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



  The `JsonCssExtractionStrategy` allows for precise extraction of structured data from web pages using CSS selectors.

  ```python
  import asyncio
  import json
  from crawl4ai import AsyncWebCrawler
  from crawl4ai.extraction_strategy import JsonCssExtractionStrategy

  async def extract_news_teasers():
      schema = {
          "name": "News Teaser Extractor",
          "baseSelector": ".wide-tease-item__wrapper",
          "fields": [
              {
                  "name": "category",
                  "selector": ".unibrow span[data-testid='unibrow-text']",
                  "type": "text",
              },
              {
                  "name": "headline",
                  "selector": ".wide-tease-item__headline",
                  "type": "text",
              },
              {
                  "name": "summary",
                  "selector": ".wide-tease-item__description",
                  "type": "text",
              },
              {
                  "name": "time",
                  "selector": "[data-testid='wide-tease-date']",
                  "type": "text",
              },
              {
                  "name": "image",
                  "type": "nested",
                  "selector": "picture.teasePicture img",
                  "fields": [
                      {"name": "src", "type": "attribute", "attribute": "src"},
                      {"name": "alt", "type": "attribute", "attribute": "alt"},
                  ],
              },
              {
                  "name": "link",
                  "selector": "a[href]",
                  "type": "attribute",
                  "attribute": "href",
              },
          ],
      }

      extraction_strategy = JsonCssExtractionStrategy(schema, verbose=True)

      async with AsyncWebCrawler(verbose=True) as crawler:
          result = await crawler.arun(
              url="https://www.nbcnews.com/business",
              extraction_strategy=extraction_strategy,
              bypass_cache=True,
          )

          assert result.success, "Failed to crawl the page"

          news_teasers = json.loads(result.extracted_content)
          print(f"Successfully extracted {len(news_teasers)} news teasers")
          print(json.dumps(news_teasers[0], indent=2))

  if __name__ == "__main__":
      asyncio.run(extract_news_teasers())
  ```

  For more advanced usage examples, check out our [Examples](https://crawl4ai.com/mkdocs/extraction/css-advanced/) section in the documentation.



  ```python
  import os
  import asyncio
  from crawl4ai import AsyncWebCrawler
  from crawl4ai.extraction_strategy import LLMExtractionStrategy
  from pydantic import BaseModel, Field

  class OpenAIModelFee(BaseModel):
      model_name: str = Field(..., description="Name of the OpenAI model.")
      input_fee: str = Field(..., description="Fee for input token for the OpenAI model.")
      output_fee: str = Field(..., description="Fee for output token for the OpenAI model.")

  async def main():
      async with AsyncWebCrawler(verbose=True) as crawler:
          result = await crawler.arun(
              url='https://openai.com/api/pricing/',
              word_count_threshold=1,
              extraction_strategy=LLMExtractionStrategy(
                  provider="openai/gpt-4o", api_token=os.getenv('OPENAI_API_KEY'),
                  schema=OpenAIModelFee.schema(),
                  extraction_type="schema",
                  instruction="""From the crawled content, extract all mentioned model names along with their fees for input and output tokens.
                  Do not miss any models in the entire content. One extracted model JSON format should look like this:
                  {"model_name": "GPT-4", "input_fee": "US$10.00 / 1M tokens", "output_fee": "US$30.00 / 1M tokens"}."""
              ),
              bypass_cache=True,
          )
          print(result.extracted_content)

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



  Crawl4AI excels at handling complex scenarios, such as crawling multiple pages with dynamic content loaded via JavaScript. Here's an example of crawling GitHub commits across multiple pages:

  ```python
  import asyncio
  import re
  from bs4 import BeautifulSoup
  from crawl4ai import AsyncWebCrawler

  async def crawl_typescript_commits():
      first_commit = ""
      async def on_execution_started(page):
          nonlocal first_commit
          try:
              while True:
                  await page.wait_for_selector('li.Box-sc-g0xbh4-0 h4')
                  commit = await page.query_selector('li.Box-sc-g0xbh4-0 h4')
                  commit = await commit.evaluate('(element) => element.textContent')
                  commit = re.sub(r'\s+', '', commit)
                  if commit and commit != first_commit:
                      first_commit = commit
                      break
                  await asyncio.sleep(0.5)
          except Exception as e:
              print(f"Warning: New content didn't appear after JavaScript execution: {e}")

      async with AsyncWebCrawler(verbose=True) as crawler:
          crawler.crawler_strategy.set_hook('on_execution_started', on_execution_started)

          url = "https://github.com/microsoft/TypeScript/commits/main"
          session_id = "typescript_commits_session"
          all_commits = []

          js_next_page = """
          const button = document.querySelector('a[data-testid="pagination-next-button"]');
          if (button) button.click();
          """

          for page in range(3):  # Crawl 3 pages
              result = await crawler.arun(
                  url=url,
                  session_id=session_id,
                  css_selector="li.Box-sc-g0xbh4-0",
                  js=js_next_page if page > 0 else None,
                  bypass_cache=True,
                  js_only=page > 0
              )

              assert result.success, f"Failed to crawl page {page + 1}"

              soup = BeautifulSoup(result.cleaned_html, 'html.parser')
              commits = soup.select("li")
              all_commits.extend(commits)

              print(f"Page {page + 1}: Found {len(commits)} commits")

          await crawler.crawler_strategy.kill_session(session_id)
          print(f"Successfully crawled {len(all_commits)} commits across 3 pages")

  if __name__ == "__main__":
      asyncio.run(crawl_typescript_commits())
  ```

  This example demonstrates Crawl4AI's ability to handle complex scenarios where content is loaded asynchronously. It crawls multiple pages of GitHub commits, executing JavaScript to load new content and using custom hooks to ensure data is loaded before proceeding.

  For more advanced usage examples, check out our [Examples](https://crawl4ai.com/mkdocs/tutorial/episode_12_Session-Based_Crawling_for_Dynamic_Websites/) section in the documentation.
  </details>




  Crawl4AI is designed with speed as a primary focus. Our goal is to provide the fastest possible response with high-quality data extraction, minimizing abstractions between the data and the user.

  We've conducted a speed comparison between Crawl4AI and Firecrawl, a paid service. The results demonstrate Crawl4AI's superior performance:

  ```bash
  Firecrawl:
  Time taken: 7.02 seconds
  Content length: 42074 characters
  Images found: 49

  Crawl4AI (simple crawl):
  Time taken: 1.60 seconds
  Content length: 18238 characters
  Images found: 49

  Crawl4AI (with JavaScript execution):
  Time taken: 4.64 seconds
  Content length: 40869 characters
  Images found: 89
  ```

  As you can see, Crawl4AI outperforms Firecrawl significantly:

  - Simple crawl: Crawl4AI is over 4 times faster than Firecrawl.
  - With JavaScript execution: Even when executing JavaScript to load more content (doubling the number of images found), Crawl4AI is still faster than Firecrawl's simple crawl.

  You can find the full comparison code in our repository at `docs/examples/crawl4ai_vs_firecrawl.py`.



  For detailed documentation, including installation instructions, advanced features, and API reference, visit our [Documentation Website](https://crawl4ai.com/mkdocs/).



  For detailed information on our development plans and upcoming features, check out our [Roadmap](https://github.com/unclecode/crawl4ai/blob/main/ROADMAP.md).


  - [x] 0. Graph Crawler: Smart website traversal using graph search algorithms for comprehensive nested page extraction
  - [ ] 1. Question-Based Crawler: Natural language driven web discovery and content extraction
  - [ ] 2. Knowledge-Optimal Crawler: Smart crawling that maximizes knowledge while minimizing data extraction
  - [ ] 3. Agentic Crawler: Autonomous system for complex multi-step crawling operations


  - [ ] 4. Automated Schema Generator: Convert natural language to extraction schemas
  - [ ] 5. Domain-Specific Scrapers: Pre-configured extractors for common platforms (academic, e-commerce)
  - [ ] 6. Web Embedding Index: Semantic search infrastructure for crawled content


  - [ ] 7. Interactive Playground: Web UI for testing, comparing strategies with AI assistance
  - [ ] 8. Performance Monitor: Real-time insights into crawler operations
  - [ ] 9. Cloud Integration: One-click deployment solutions across cloud providers


  - [ ] 10. Sponsorship Program: Structured support system with tiered benefits
  - [ ] 11. Educational Content: "How to Crawl" video series and interactive tutorials



  We welcome contributions from the open-source community. Check out our [contribution guidelines](https://github.com/unclecode/crawl4ai/blob/main/CONTRIBUTING.md) for more information.



  Crawl4AI is released under the [Apache 2.0 License](https://github.com/unclecode/crawl4ai/blob/main/LICENSE).



  For questions, suggestions, or feedback, feel free to reach out:

  - GitHub: [unclecode](https://github.com/unclecode)
  - Twitter: [@unclecode](https://twitter.com/unclecode)
  - Website: [crawl4ai.com](https://crawl4ai.com)

  Happy Crawling! 🕸️🚀




  Our mission is to unlock the untapped potential of personal and enterprise data in the digital age. In today's world, individuals and organizations generate vast amounts of valuable digital footprints, yet this data remains largely uncapitalized as a true asset.

  Our open-source solution empowers developers and innovators to build tools for data extraction and structuring, laying the foundation for a new era of data ownership. By transforming personal and enterprise data into structured, tradeable assets, we're creating opportunities for individuals to capitalize on their digital footprints and for organizations to unlock the value of their collective knowledge.

  This democratization of data represents the first step toward a shared data economy, where willing participation in data sharing drives AI advancement while ensuring the benefits flow back to data creators. Through this approach, we're building a future where AI development is powered by authentic human knowledge rather than synthetic alternatives.

  ![Mission Diagram](./docs/assets/pitch-dark.svg)

  For a detailed exploration of our vision, opportunities, and pathway forward, please see our [full mission statement](./MISSION.md).



  - **Data Capitalization**: Transform digital footprints into valuable assets that can appear on personal and enterprise balance sheets
  - **Authentic Data**: Unlock the vast reservoir of real human insights and knowledge for AI advancement
  - **Shared Economy**: Create new value streams where data creators directly benefit from their contributions



  1. **Open-Source Foundation**: Building transparent, community-driven data extraction tools
  2. **Data Capitalization Platform**: Creating tools to structure and value digital assets
  3. **Shared Data Marketplace**: Establishing an economic platform for ethical data exchange

  For a detailed exploration of our vision, challenges, and solutions, please see our [full mission statement](./MISSION.md).




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


pkgId: 0fcd2b8ee77fe8f5d8df24874a0e5445d238f7b97f9a78f3ca86801a79e391a4
name: python-Crawl4AI
arch: src
version: 0.3.742
epoch: 0
release: 1
summary: 🔥🕷️ Crawl4AI: Open-source LLM Friendly Web Crawler & scraper
url: https://github.com/unclecode/crawl4ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Crawl4AI-0.3.742-1.src.rpm
checksum_type: sha256
description:
  <a href="https://trendshift.io/repositories/11716" target="_blank"><img src="https://trendshift.io/api/badge/repositories/11716" alt="unclecode%2Fcrawl4ai | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

  [![GitHub Stars](https://img.shields.io/github/stars/unclecode/crawl4ai?style=social)](https://github.com/unclecode/crawl4ai/stargazers)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/Crawl4AI)
  [![GitHub Forks](https://img.shields.io/github/forks/unclecode/crawl4ai?style=social)](https://github.com/unclecode/crawl4ai/network/members)
  [![GitHub Issues](https://img.shields.io/github/issues/unclecode/crawl4ai)](https://github.com/unclecode/crawl4ai/issues)
  [![GitHub Pull Requests](https://img.shields.io/github/issues-pr/unclecode/crawl4ai)](https://github.com/unclecode/crawl4ai/pulls)
  [![License](https://img.shields.io/github/license/unclecode/crawl4ai)](https://github.com/unclecode/crawl4ai/blob/main/LICENSE)

  Crawl4AI simplifies asynchronous web crawling and data extraction, making it accessible for large language models (LLMs) and AI applications. 🆓🌐



  - 🚀 **Blazing Fast Scraping**: Significantly improved scraping speed.
  - 📥 **Download Manager**: Integrated file crawling, downloading, and tracking within `CrawlResult`.
  - 📝 **Markdown Strategy**: Flexible system for custom markdown generation and formats.
  - 🔗 **LLM-Friendly Citations**: Auto-converts links to numbered citations with reference lists.
  - 🔎 **Markdown Filter**: BM25-based content extraction for cleaner, relevant markdown.
  - 🖼️ **Image Extraction**: Supports `srcset`, `picture`, and responsive image formats.
  - 🗂️ **Local/Raw HTML**: Crawl `file://` paths and raw HTML (`raw:`) directly.
  - 🤖 **Browser Control**: Custom browser setups with stealth integration to bypass bots.
  - ☁️ **API & Cache Boost**: CORS, static serving, and enhanced filesystem-based caching.
  - 🐳 **API Gateway**: Run as an API service with secure token authentication.
  - 🛠️ **Database Upgrades**: Optimized for larger content sets with faster caching.
  - 🐛 **Bug Fixes**: Resolved browser context issues, memory leaks, and improved error handling.




  ✨ Play around with this [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1SgRPrByQLzjRfwoRNq1wSGE9nYY_EE8C?usp=sharing)

  ✨ Visit our [Documentation Website](https://crawl4ai.com/mkdocs/)



  - 🆓 Completely free and open-source
  - 🚀 Blazing fast performance, outperforming many paid services
  - 🤖 LLM-friendly output formats (JSON, cleaned HTML, markdown)
  - 🌐 Multi-browser support (Chromium, Firefox, WebKit)
  - 🌍 Supports crawling multiple URLs simultaneously
  - 🎨 Extracts and returns all media tags (Images, Audio, and Video)
  - 🔗 Extracts all external and internal links
  - 📚 Extracts metadata from the page
  - 🔄 Custom hooks for authentication, headers, and page modifications
  - 🕵️ User-agent customization
  - 🖼️ Takes screenshots of pages with enhanced error handling
  - 📜 Executes multiple custom JavaScripts before crawling
  - 📊 Generates structured output without LLM using JsonCssExtractionStrategy
  - 📚 Various chunking strategies: topic-based, regex, sentence, and more
  - 🧠 Advanced extraction strategies: cosine clustering, LLM, and more
  - 🎯 CSS selector support for precise data extraction
  - 📝 Passes instructions/keywords to refine extraction
  - 🔒 Proxy support with authentication for enhanced access
  - 🔄 Session management for complex multi-page crawling
  - 🌐 Asynchronous architecture for improved performance
  - 🖼️ Improved image processing with lazy-loading detection
  - 🕰️ Enhanced handling of delayed content loading
  - 🔑 Custom headers support for LLM interactions
  - 🖼️ iframe content extraction for comprehensive analysis
  - ⏱️ Flexible timeout and delayed content retrieval options



  Crawl4AI offers flexible installation options to suit various use cases. You can install it as a Python package or use Docker.



  Choose the installation option that best fits your needs:



  For basic web crawling and scraping tasks:

  ```bash
  pip install crawl4ai
  ```

  By default, this will install the asynchronous version of Crawl4AI, using Playwright for web crawling.

  👉 Note: When you install Crawl4AI, the setup script should automatically install and set up Playwright. However, if you encounter any Playwright-related errors, you can manually install it using one of these methods:

  1. Through the command line:

     ```bash
     playwright install
     ```

  2. If the above doesn't work, try this more specific command:

     ```bash
     python -m playwright install chromium
     ```

  This second method has proven to be more reliable in some cases.



  If you need the synchronous version using Selenium:

  ```bash
  pip install crawl4ai[sync]
  ```



  For contributors who plan to modify the source code:

  ```bash
  git clone https://github.com/unclecode/crawl4ai.git
  cd crawl4ai
  pip install -e .
  ```



  Deploy your own instance of Crawl4AI with one click:

  [![DigitalOcean Referral Badge](https://web-platforms.sfo2.cdn.digitaloceanspaces.com/WWW/Badge%203.svg)](https://www.digitalocean.com/?repo=https://github.com/unclecode/crawl4ai/tree/0.3.74&refcode=a0780f1bdb3d&utm_campaign=Referral_Invite&utm_medium=Referral_Program&utm_source=badge)

  > 💡 **Recommended specs**: 4GB RAM minimum. Select "professional-xs" or higher when deploying for stable operation.

  The deploy will:
  - Set up a Docker container with Crawl4AI
  - Configure Playwright and all dependencies
  - Start the FastAPI server on port 11235
  - Set up health checks and auto-deployment



  Crawl4AI is available as Docker images for easy deployment. You can either pull directly from Docker Hub (recommended) or build from the repository.



  ```bash

  docker pull unclecode/crawl4ai:basic    # Basic crawling features
  docker pull unclecode/crawl4ai:all      # Full installation (ML, LLM support)
  docker pull unclecode/crawl4ai:gpu      # GPU-enabled version


  docker run -p 11235:11235 unclecode/crawl4ai:basic  # Replace 'basic' with your chosen version


  docker run --platform linux/arm64 -p 11235:11235 unclecode/crawl4ai:basic


  docker run --shm-size=2gb -p 11235:11235 unclecode/crawl4ai:basic
  ```



  ```bash

  git clone https://github.com/unclecode/crawl4ai.git
  cd crawl4ai


  docker build -t crawl4ai:local \
    --build-arg INSTALL_TYPE=basic \  # Options: basic, all
    .


  docker build -t crawl4ai:local \
    --build-arg INSTALL_TYPE=basic \  # Options: basic, all
    --platform linux/arm64 \
    .


  docker run -p 11235:11235 crawl4ai:local
  ```

  Quick test (works for both options):
  ```python
  import requests


  response = requests.post(
      "http://localhost:11235/crawl",
      json={"urls": "https://example.com", "priority": 10}
  )
  task_id = response.json()["task_id"]


  result = requests.get(f"http://localhost:11235/task/{task_id}")
  ```

  For advanced configuration, environment variables, and usage examples, see our [Docker Deployment Guide](https://crawl4ai.com/mkdocs/basic/docker-deployment/).




  ```python
  import asyncio
  from crawl4ai import AsyncWebCrawler

  async def main():
      async with AsyncWebCrawler(verbose=True) as crawler:
          result = await crawler.arun(url="https://www.nbcnews.com/business")
          print(result.markdown)

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





  ```python
  import asyncio
  from crawl4ai import AsyncWebCrawler

  async def main():
      async with AsyncWebCrawler(verbose=True) as crawler:
          js_code = ["const loadMoreButton = Array.from(document.querySelectorAll('button')).find(button => button.textContent.includes('Load More')); loadMoreButton && loadMoreButton.click();"]
          result = await crawler.arun(
              url="https://www.nbcnews.com/business",
              js_code=js_code,
              css_selector=".wide-tease-item__description",
              bypass_cache=True
          )
          print(result.extracted_content)

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



  ```python
  import asyncio
  from crawl4ai import AsyncWebCrawler

  async def main():
      async with AsyncWebCrawler(verbose=True, proxy="http://127.0.0.1:7890") as crawler:
          result = await crawler.arun(
              url="https://www.nbcnews.com/business",
              bypass_cache=True
          )
          print(result.markdown)

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



  The `JsonCssExtractionStrategy` allows for precise extraction of structured data from web pages using CSS selectors.

  ```python
  import asyncio
  import json
  from crawl4ai import AsyncWebCrawler
  from crawl4ai.extraction_strategy import JsonCssExtractionStrategy

  async def extract_news_teasers():
      schema = {
          "name": "News Teaser Extractor",
          "baseSelector": ".wide-tease-item__wrapper",
          "fields": [
              {
                  "name": "category",
                  "selector": ".unibrow span[data-testid='unibrow-text']",
                  "type": "text",
              },
              {
                  "name": "headline",
                  "selector": ".wide-tease-item__headline",
                  "type": "text",
              },
              {
                  "name": "summary",
                  "selector": ".wide-tease-item__description",
                  "type": "text",
              },
              {
                  "name": "time",
                  "selector": "[data-testid='wide-tease-date']",
                  "type": "text",
              },
              {
                  "name": "image",
                  "type": "nested",
                  "selector": "picture.teasePicture img",
                  "fields": [
                      {"name": "src", "type": "attribute", "attribute": "src"},
                      {"name": "alt", "type": "attribute", "attribute": "alt"},
                  ],
              },
              {
                  "name": "link",
                  "selector": "a[href]",
                  "type": "attribute",
                  "attribute": "href",
              },
          ],
      }

      extraction_strategy = JsonCssExtractionStrategy(schema, verbose=True)

      async with AsyncWebCrawler(verbose=True) as crawler:
          result = await crawler.arun(
              url="https://www.nbcnews.com/business",
              extraction_strategy=extraction_strategy,
              bypass_cache=True,
          )

          assert result.success, "Failed to crawl the page"

          news_teasers = json.loads(result.extracted_content)
          print(f"Successfully extracted {len(news_teasers)} news teasers")
          print(json.dumps(news_teasers[0], indent=2))

  if __name__ == "__main__":
      asyncio.run(extract_news_teasers())
  ```

  For more advanced usage examples, check out our [Examples](https://crawl4ai.com/mkdocs/extraction/css-advanced/) section in the documentation.



  ```python
  import os
  import asyncio
  from crawl4ai import AsyncWebCrawler
  from crawl4ai.extraction_strategy import LLMExtractionStrategy
  from pydantic import BaseModel, Field

  class OpenAIModelFee(BaseModel):
      model_name: str = Field(..., description="Name of the OpenAI model.")
      input_fee: str = Field(..., description="Fee for input token for the OpenAI model.")
      output_fee: str = Field(..., description="Fee for output token for the OpenAI model.")

  async def main():
      async with AsyncWebCrawler(verbose=True) as crawler:
          result = await crawler.arun(
              url='https://openai.com/api/pricing/',
              word_count_threshold=1,
              extraction_strategy=LLMExtractionStrategy(
                  provider="openai/gpt-4o", api_token=os.getenv('OPENAI_API_KEY'),
                  schema=OpenAIModelFee.schema(),
                  extraction_type="schema",
                  instruction="""From the crawled content, extract all mentioned model names along with their fees for input and output tokens.
                  Do not miss any models in the entire content. One extracted model JSON format should look like this:
                  {"model_name": "GPT-4", "input_fee": "US$10.00 / 1M tokens", "output_fee": "US$30.00 / 1M tokens"}."""
              ),
              bypass_cache=True,
          )
          print(result.extracted_content)

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



  Crawl4AI excels at handling complex scenarios, such as crawling multiple pages with dynamic content loaded via JavaScript. Here's an example of crawling GitHub commits across multiple pages:

  ```python
  import asyncio
  import re
  from bs4 import BeautifulSoup
  from crawl4ai import AsyncWebCrawler

  async def crawl_typescript_commits():
      first_commit = ""
      async def on_execution_started(page):
          nonlocal first_commit
          try:
              while True:
                  await page.wait_for_selector('li.Box-sc-g0xbh4-0 h4')
                  commit = await page.query_selector('li.Box-sc-g0xbh4-0 h4')
                  commit = await commit.evaluate('(element) => element.textContent')
                  commit = re.sub(r'\s+', '', commit)
                  if commit and commit != first_commit:
                      first_commit = commit
                      break
                  await asyncio.sleep(0.5)
          except Exception as e:
              print(f"Warning: New content didn't appear after JavaScript execution: {e}")

      async with AsyncWebCrawler(verbose=True) as crawler:
          crawler.crawler_strategy.set_hook('on_execution_started', on_execution_started)

          url = "https://github.com/microsoft/TypeScript/commits/main"
          session_id = "typescript_commits_session"
          all_commits = []

          js_next_page = """
          const button = document.querySelector('a[data-testid="pagination-next-button"]');
          if (button) button.click();
          """

          for page in range(3):  # Crawl 3 pages
              result = await crawler.arun(
                  url=url,
                  session_id=session_id,
                  css_selector="li.Box-sc-g0xbh4-0",
                  js=js_next_page if page > 0 else None,
                  bypass_cache=True,
                  js_only=page > 0
              )

              assert result.success, f"Failed to crawl page {page + 1}"

              soup = BeautifulSoup(result.cleaned_html, 'html.parser')
              commits = soup.select("li")
              all_commits.extend(commits)

              print(f"Page {page + 1}: Found {len(commits)} commits")

          await crawler.crawler_strategy.kill_session(session_id)
          print(f"Successfully crawled {len(all_commits)} commits across 3 pages")

  if __name__ == "__main__":
      asyncio.run(crawl_typescript_commits())
  ```

  This example demonstrates Crawl4AI's ability to handle complex scenarios where content is loaded asynchronously. It crawls multiple pages of GitHub commits, executing JavaScript to load new content and using custom hooks to ensure data is loaded before proceeding.

  For more advanced usage examples, check out our [Examples](https://crawl4ai.com/mkdocs/tutorial/episode_12_Session-Based_Crawling_for_Dynamic_Websites/) section in the documentation.
  </details>




  Crawl4AI is designed with speed as a primary focus. Our goal is to provide the fastest possible response with high-quality data extraction, minimizing abstractions between the data and the user.

  We've conducted a speed comparison between Crawl4AI and Firecrawl, a paid service. The results demonstrate Crawl4AI's superior performance:

  ```bash
  Firecrawl:
  Time taken: 7.02 seconds
  Content length: 42074 characters
  Images found: 49

  Crawl4AI (simple crawl):
  Time taken: 1.60 seconds
  Content length: 18238 characters
  Images found: 49

  Crawl4AI (with JavaScript execution):
  Time taken: 4.64 seconds
  Content length: 40869 characters
  Images found: 89
  ```

  As you can see, Crawl4AI outperforms Firecrawl significantly:

  - Simple crawl: Crawl4AI is over 4 times faster than Firecrawl.
  - With JavaScript execution: Even when executing JavaScript to load more content (doubling the number of images found), Crawl4AI is still faster than Firecrawl's simple crawl.

  You can find the full comparison code in our repository at `docs/examples/crawl4ai_vs_firecrawl.py`.



  For detailed documentation, including installation instructions, advanced features, and API reference, visit our [Documentation Website](https://crawl4ai.com/mkdocs/).



  For detailed information on our development plans and upcoming features, check out our [Roadmap](https://github.com/unclecode/crawl4ai/blob/main/ROADMAP.md).


  - [x] 0. Graph Crawler: Smart website traversal using graph search algorithms for comprehensive nested page extraction
  - [ ] 1. Question-Based Crawler: Natural language driven web discovery and content extraction
  - [ ] 2. Knowledge-Optimal Crawler: Smart crawling that maximizes knowledge while minimizing data extraction
  - [ ] 3. Agentic Crawler: Autonomous system for complex multi-step crawling operations


  - [ ] 4. Automated Schema Generator: Convert natural language to extraction schemas
  - [ ] 5. Domain-Specific Scrapers: Pre-configured extractors for common platforms (academic, e-commerce)
  - [ ] 6. Web Embedding Index: Semantic search infrastructure for crawled content


  - [ ] 7. Interactive Playground: Web UI for testing, comparing strategies with AI assistance
  - [ ] 8. Performance Monitor: Real-time insights into crawler operations
  - [ ] 9. Cloud Integration: One-click deployment solutions across cloud providers


  - [ ] 10. Sponsorship Program: Structured support system with tiered benefits
  - [ ] 11. Educational Content: "How to Crawl" video series and interactive tutorials



  We welcome contributions from the open-source community. Check out our [contribution guidelines](https://github.com/unclecode/crawl4ai/blob/main/CONTRIBUTING.md) for more information.



  Crawl4AI is released under the [Apache 2.0 License](https://github.com/unclecode/crawl4ai/blob/main/LICENSE).



  For questions, suggestions, or feedback, feel free to reach out:

  - GitHub: [unclecode](https://github.com/unclecode)
  - Twitter: [@unclecode](https://twitter.com/unclecode)
  - Website: [crawl4ai.com](https://crawl4ai.com)

  Happy Crawling! 🕸️🚀




  Our mission is to unlock the untapped potential of personal and enterprise data in the digital age. In today's world, individuals and organizations generate vast amounts of valuable digital footprints, yet this data remains largely uncapitalized as a true asset.

  Our open-source solution empowers developers and innovators to build tools for data extraction and structuring, laying the foundation for a new era of data ownership. By transforming personal and enterprise data into structured, tradeable assets, we're creating opportunities for individuals to capitalize on their digital footprints and for organizations to unlock the value of their collective knowledge.

  This democratization of data represents the first step toward a shared data economy, where willing participation in data sharing drives AI advancement while ensuring the benefits flow back to data creators. Through this approach, we're building a future where AI development is powered by authentic human knowledge rather than synthetic alternatives.

  ![Mission Diagram](./docs/assets/pitch-dark.svg)

  For a detailed exploration of our vision, opportunities, and pathway forward, please see our [full mission statement](./MISSION.md).



  - **Data Capitalization**: Transform digital footprints into valuable assets that can appear on personal and enterprise balance sheets
  - **Authentic Data**: Unlock the vast reservoir of real human insights and knowledge for AI advancement
  - **Shared Economy**: Create new value streams where data creators directly benefit from their contributions



  1. **Open-Source Foundation**: Building transparent, community-driven data extraction tools
  2. **Data Capitalization Platform**: Creating tools to structure and value digital assets
  3. **Shared Data Marketplace**: Establishing an economic platform for ethical data exchange

  For a detailed exploration of our vision, challenges, and solutions, please see our [full mission statement](./MISSION.md).




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


pkgId: 043a14ad12b80b4d8f07b4c704f068e813bee1a307198ad5b796d74bc9f3474d
name: python-Crawl4AI
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: 🔥🕷️ Crawl4AI: Open-source LLM Friendly Web Crawler & scraper
url: https://github.com/unclecode/crawl4ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Crawl4AI-0.4.0-1.src.rpm
checksum_type: sha256
description:
  The sync version is deprecated and will be removed in future versions. If you need the synchronous version using Selenium:
  ```bash
  pip install crawl4ai[sync]


pkgId: deace49b729e4f1a81e6fb481fec54576d32c951cc596c6c5e294e14d53bb14c
name: python-CrawlFlow
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: An assistant for web crawling
url: https://github.com/am-mohammadi/CrawlFlow
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CrawlFlow-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Dynamic Scraping:
  By setting dynamic = True in Hanlder.run method, you can use dynamic scraping
  "url_list" should contian first url that starts scrping
  ```python
  class TestCrawler(Handler):
      def __init__(self, name):
          super().__init__(name)
          self.type=CrawlTypes.API()
      def data2rows(self, request_data):
          self.data=request_data
          if request_data['data'][0]['link'] is  None:
              self.vars.done=True
              return {}
          self.vars.next_url = f'https://www.aparat.com/api/fa/v1/video/video/search/text/'+self.get(request_data['data'][0], ['link', 'next']).split('text/')[1]
          videoList=self.get(request_data['data'][0], ['video', 'data'])
          tables_rows={'videoList': videoList}
          return tables_rows
  crawler=TestCrawler('aparat')
  crawler.request.params={'type_search': 'search'}
  crawler.init()
  url_list=['https://www.aparat.com/api/fa/v1/video/video/search/text/game']
  crawler.run(url_list, resume=False, dynamic=True)
  crawler.export_tables()
  ```
  Note:
  Hanlder.vars is an object that will be save in every ckeckpoint. so you set your variables here
  ```
  If you set Hanlder.vars.done=True scraping process will be finished after that.
  ```
  Defining response status codes for interrupting the process
  ```
  Handler.request.bypass_status_codes = [204]

  {'status_code': 204}


pkgId: 00a7dd0f4429ba64b357491f8211e928cb9aac1d59563ca8dd163cc194163a80
name: python-CrawlersTools
arch: src
version: 1.4.81
epoch: 0
release: 1
summary: Tools for Crawlers
url: https://github.com/MuggleK/CrawlersTools
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CrawlersTools-1.4.81-1.src.rpm
checksum_type: sha256
description:
  Install CrawlersTools using pip:
  ```shell
  pip install CrawlersTools
  ```
  CrawlersTools requires Python 3.7+.


  With this module,you can extract policy html automatically.

  Usage example:
  ```shell
  from CrawlersTools import ListExtractor
  list_extract = ListExtractor()
  extract_result = list_extract.extract(html)
  print(extract_result)
  ```
  Outputs:
  ```shell
  [{
      'title': '关于对迎泽区2023年乡村振兴项目储备库的公示',
      'url': '/p222/ncjbmxxgk/20221111/30003142.html'
  }, {
      'title': '迎泽区2022年第四批实际种粮农民一次性补贴发放明细公示',
      'url': '/p222/ncjbmxxgk/20221027/1249082.html'
  }, {
      'title': '迎泽区2022年第三批实际种粮农民一次性补贴发放明细公示',
      'url': '/p222/ncjbmxxgk/20221027/1249081.html'
  }, {
      'title': '迎泽区2022年第二批实际种粮农民一次性补贴发放明细公示',
      'url': '/p222/ncjbmxxgk/20221027/1249078.html'
  }, {
      'title': '迎泽区2022年第一批实际种粮农民一次性补贴发放明细公示',
      'url': '/p222/ncjbmxxgk/20221027/1249077.html'
  }, ***]
  ```

  Usage example:
  ```shell
  from CrawlersTools import PolicyExtractor
  detail_extract = PolicyExtractor()
  detail_result = detail_extract.extract(html)
  print(detail_result)
  ```
  Outputs:
  ```shell
  {
    'title': '玉溪市2018年工业经济运行工作指导意见',
    'publish_time': '2018-03-15',
    'content': '2017年，在作为全市工业主要支柱产业的烟草制品业增加值增速持续负增长，虽然全市非烟产业平稳高速增长，但占比小、支撑作用不明显，全市工业稳增长面临严峻困难和挑战的形势下，市委、市政府早谋划、早部署，及时出台稳增长促转型系列政策措施，工业经济运行缓中趋稳，稳中有升，结构调整和转型升级取得积极进展。全年全部工业完成增加值\n662.5\n亿元，增长\n7.1%\n，拉动\nGDP\n增长\n3.6\n个百分点，对经济增长的贡献率为\n38.1%\n，其中：规模以上工业完成增加值\n623.7\n亿元，增长\n7.2%\n。\n2018\n年是贯彻党的十九大精神的开局之年，是改革开放\n40\n周年，也是决胜全面建成小康社会、实施\n“\n十三五\n”\n规划承上启下的关键一年。当前，我国经济正处在转变发展方式、优化经济结构、转换增长动力的攻关期。十九大报告作出这样的判断：我国经济已由高速增长阶段转向高质量发展阶段。\n“\n十三五\n”\n行至一半，\n2018\n年成为承上启下的关键一年，全市工业经济运行调节要全面贯彻党的十九大精神，以习近平新时代中国特色社会主义思想为指导，牢固树立\n“\n四个意识\n”\n和\n“\n四个自信\n”\n，坚持稳中求进工作总基调，坚持新发展理念，紧扣我国社会主要矛盾变化，着眼建设现代化经济体系，立足制造强国、网络强国建设全局，以供给侧结构性改革为主线，以提高制造业供给体系质量为主攻方向，深入实施\n“\n中国制造\n2025”\n，强化创新驱动、改革推动、融合带动，推动质量变革、效率变革、动力变革，加快培育壮大新动能、改造提升传统动能，实现工业及信息化业持续健康发展。\n一、2018年工业经济运行形势研判\n（一）有利条件\n当前，玉溪工业发展正处于工业化中期的前半阶段，资本、技术等要素边际贡献率较高，工业发展空间仍然较大，支撑工业平稳较快增长的有利条件和因素不断增多。\n一是宏观经济运行企稳。\n全球经济\n“\n低增长、低通胀、低利率\n”\n态势将会有所回暖，传统产业负增长的情况会有所改变。同时，随着滇中城市经济圈和\n“\n五大基础设施网络\n”\n等一系列项目实施，国家、省、市出台的稳增长、供给侧结构性改革等系列政策效应逐步释放，经济增长的内生动力不断增强，国内经济稳中向好，全市经济稳中有进，为工业稳增长调结构提供了良好的宏观环境。\n二是面临良好发展机遇和政策环境。\n玉溪地处滇中区域，位于泛亚铁路中线和东线的交汇点，是昆曼高速的重要节点，有助于在更高、更广的平台上深化对内和对外两个开放，辐射带动滇中城市经济圈发展，开创面向南亚、东南亚开放合作的新局面。且玉溪处于多个重大国家战略的交汇点，\n“\n一带一路\n”“\n长江经济带\n”\n创造新战略空间，有望加快面向南亚东南亚辐射中心建设和沿边地区开发开放，同时在基建、能源、金融、贸易合作等方面将获得更为广阔的发展空间。市委市政府高位推进\n“\n五网\n”\n建设，加快培育七大重点产业，实施工业经济攻坚战，将助力补齐工业经济发展短板，打造工业增长新引擎。\n三是工业企业生产经营环境有所改善。\n全市大宗工业品价格稳步回升，工业通缩局面得到缓解。工业企业经营环境逐步改善，将在一定程度上改善企业市场预期，增强库存回补动力和投资意愿。创新驱动发展战略深入实施，大众创业、万众创新成为经济提质增效的新引擎。\n“\n互联网\n+”\n加快跨界融合，将极大提升实体经济的创新力和生产力，企业生产经营环境不断得到创新及改善。\n（二）不利条件\n在内外需求偏弱，周期性和结构性矛盾叠加的背景下，\n2018\n年玉溪工业经济平稳健康运行仍然面临诸多制约因素，主要表现为：\n一是结构性矛盾制约。\n全市工业结构中，\n2017\n年烟草制品业占比达\n62.68%\n，从\n2017\n年运行趋势看，烟草行业仍将面临三个不变，即国家控烟的力度不会改变、对烟草行业的政策调控不会改变、烟草行业运行环境难有较大改变，烟草行业保增长的压力仍较为突出。传统行业中，钢铁行业虽呈现恢复性增长，但受工业增加值率和价格指数影响，对全市工业增长拉动较小。新兴产业中，装备制造、生物医药和电子信息制造产业虽然增速较快，但在全市规上工业增加值中的占比仅分别为\n4.2%\n、\n1.5%\n、\n0.5%\n，占比小，拉动增长较弱，全市工业经济结构性矛盾依然突出。\n二是要素成本制约。\n近年来，资金、用工、土地等要素刚性成本和环保、物流等隐性成本不断上升，给企业生产经营造成较大压力。企业成本上升明显，工业企业融资难、融资贵矛盾仍未有效缓解，金融资本一定程度上\n“\n脱实向虚\n”\n。企业难贷款和银行贷款难\n“\n两难矛盾\n”\n以及慎贷、限贷、抽贷现象仍然不同程度存在。\n三是新增增量制约。\n由于工业企业生产经营困难、效益下滑影响，导致对未来市场的预期和信心不足。民营企业由于缺乏担保，实际资金支付率和到付率偏低，加之投资回报率下降、用地成本高、落地困难等多种因素影响，民间投资意愿下降，新增投资大幅下滑。\n四是新投产项目匮乏。\n全市新建成投产且能纳入规上统计的项目较少，尤其是缺乏大项目形成新的增量。招商优质项目不多，带动性不强，投资额度大的项目不多，跨越发展缺少大项目支撑，工业经济缺乏增量支撑。\n综上所述，\n2018\n年全市工业经济处于新旧动能转换，并将加速向纵深推进期，工业经济将在合理区间稳定运行，工业发展质量将稳步提升。但仍需要密切关注影响工业经济平衡充分发展的一些突出问题：供给体系质量与消费升级需求不匹配、新技术对传统产业的渗透融合不深入、工业领域民间投资意愿不强烈等，经济继续下行的压力和风险较大，延续低速低效运行趋势的可能性较大，完成全年工业经济发展目标任务十分艰巨，全市工信系统的广大干部职工务必高度重视，振奋精神，迎难而上，恪尽职守，竭尽全力，全面完成市委市政府下达各县区的工业经济发展目标。\n二、2018年工业经济运行总体思路和主要指标\n（一）总体思路\n全面贯彻落实十九大、中央经济工作会议、省委十届四次全会、市委五届五次全会，以及\n2018\n年全省工业和信息化工作会议精神，牢固树立\n“\n创新、协调、绿色、开放、共享\n”\n的发展新理念，坚持稳中求进工作总基调，适应新常态，谋划新思路，把稳增长作为首要任务，坚持全局视野、问题导向、创新意识、聚焦目标任务的运行调节原则，强化重点监测、准确定位、分类指导、精准施策，实现将短期需求管理与中长期供给管理相结合、从侧重需求侧向供需两侧并重逐步转变，实施重点行业挖潜、重大项目驱动、产融合作推进、达规企业培育\n“\n四大工程\n”\n，增强工业持续增长动力，促进工业经济平稳增长。\n（二）主要目标\n2018\n年非烟规上工业增加值增长\n21%\n。\n三、主要措施\n（一）压实各县区、工业园区主体责任。\n督促各县区、工业园区要扛起责任使命，压紧压实工业经济发展主体责任，扎实推进工业经济发展工作，着力营造良好的发展环境。实现责任全厘清，层层建立主体责任清单，主要领导带头，以上率下，重视工业、研究工业、推动工业发展。\n（二）提前谋划，实现高开稳走。\n提前谋划部署，科学有序部署，减少工业经济大幅波动，促进全年工业经济平稳发展。抓好节后企业复产复工，确保实现一季度工业经济\n“\n开门红\n”\n。及早部署和安排\n2018\n年工业投资重点项目，促进项目早启动、早投产、早落地，支撑全市工业经济平稳发展。\n（三）抓好成本费用调查工作。\n市工信委和市统计局联合组织对全市\n94\n户成本费用调查工业企业开展业务培训。各级工信、统计部门要深入填报企业开展业务指导，进一步提高全市规模以上工业企业成本费用调查数据质量，客观真实反映工业各行业增加值率情况。\n（四）抓好在库企业生产经营监测工作。\n一是\n组建\n10\n个帮扶督导组，对\n9\n个县区和高新区全覆盖，每月一调研一督导，继续抓好扩销促产、电力市场化交易等措施落实，强化稳增长政策落到实处，激励在库工业企业做好生产经营工作。\n二是\n加强分析预测，认真研究提出工业经济平稳发展的支撑点，以更加有力的措施确保工业经济增长态势。\n三是\n抓好重点企业稳增长工作。对全市工业经济贡献较大，占比较高的重点企业，实行面对面帮、点对点扶，保障重点企业生产经营中的各种生产要素，确保企业满负荷生产，支撑全市工业经济稳定增长。\n（五）抓好负增长企业扭负为正工作。\n以企业帮扶为手段，进一步优化发展环境。创新帮扶工作机制，切实帮助企业解决具体问题，重点排查帮扶企业存在的突出矛盾和问题，采取\n“\n一企一策\n”\n的办法，分类指导，重点帮扶，加大惠企政策落实力度，努力实现负增长企业达产增效。\n（六）创新工业企业纳规培育工作机制。\n依托全市工业企业纳规工作联席会议制度，比对筛选全市符合纳规条件工业企业，做好政策宣传，企业帮扶工作，推动全市工业企业纳规工作。'
  }
  ```

  Font encryption is one of the common scenarios for crawlers.With this module,you can only
  provide font file and encrypted strings to get decrypted strings.
  FreeTypeFont isn`t compatible with bytes, so you must change the source code in advance.
  ```shell
  def load_from_bytes(f):
      if isinstance(f, bytes):    # 直接传入bytes
          self.font_bytes = f
      else:
          self.font_bytes = f.read()
      self.font = core.getfont(
          "", size, index, encoding, self.font_bytes, layout_engine
      )
  if isinstance(font, bytes): # 直接传入bytes
      load_from_bytes(font)
  elif isPath(font):
      ***
  ```
  Usage example:
  ```shell
  from CrawlersTools.js_crawler import FontDecrypt
  str_base64_ = '[encoded data, 26616 characters] '
  font = FontDecrypt(str_base64=str_base64_)
  font.decrypt('𤵼𥙌腐进𤵝防护𥪵𤹩腐蚀𧒄𥉥𥪵𥌙测试𢺔𦰤𤵢𤵩𥤣𥎧𤹩𥤣𥎧')
  ```
  Outputs:
  ```shell
  2022-01-20 17:01:47.932 | SUCCESS  | __main__:decrypt:89 - Out Decrypted Strings：中国腐进与防护学会腐蚀电化学及测试方法专业委员会委员
  ```

  With this module,insert data into database is more conveniently.

  There is no need to care the order of items when insert data.
  Usage example:
  ```shell
  from CrawlersTools import MysqlPipeline
  mysql_client = MysqlPipeline(host='127.0.0.1', username='root', password='', db='project', drop_column=["id"])
  item = {"name": "MuggleK", "age": "18"}
  mysql_client.insert_one(item, table_name='test_table')
  ```
  Outputs:
  ```shell
  2022-11-25 11:25:18.291 | SUCCESS  | pipelines.mysql_pipeline:insert:160 - Success: Insert {"name": "MuggleK", "age": "18"} -> test_table
  ```

  Usage example:
  ```shell
  from CrawlersTools import base_requests
  response = base_requests('https://example.org')
  print(response)
  ```
  Outputs:
  ```shell
  <Response [200 OK]>
  ```

  This concurrent mode will create a child thread for every task below max threads and when children thread less than max threads,the main thread will create child thread for new task.
  Usage example:
  ```shell
  from CrawlersTools import AutoThread
  a_thread = AutoThread(thread_num=20, fun, arg_list)
  a_thread.main_thread()
  ```


  * [面向不规则列表的网页数据抽取技术的研究](http://www.cnki.com.cn/Article/CJFDTotal-JSYJ201509023.htm)
  * [基于文本及符号密度的网页正文提取方法](https://kns.cnki.net/KCMS/detail/detail.aspx?dbcode=CJFQ&dbname=CJFDLAST2019&filename=GWDZ201908029&v=MDY4MTRxVHJXTTFGckNVUkxPZmJ1Wm5GQ2poVXJyQklqclBkTEc0SDlqTXA0OUhiWVI4ZVgxTHV4WVM3RGgxVDM=)
  * [基于块密度加权标签路径特征的Web新闻在线抽取](https://kns.cnki.net/kcms/detail/detail.aspx?filename=PZKX201708010&dbcode=CJFQ&dbname=CJFD2017&v=)
  * [基于DOM树和视觉特征的网页信息自动抽取](http://www.cnki.com.cn/Article/CJFDTOTAL-JSJC201310069.htm)
  * [基于行块分布函数的通用网页正文抽取算法](https://code.google.com/archive/p/cx-extractor/)

  * [GeneralNewsExtractor](https://github.com/kingname/GeneralNewsExtractor)
  * [GerapyAutoExtractor](https://github.com/Gerapy/GerapyAutoExtractor)
  * [artical-spider](https://github.com/govzhz/artical-spider)
  * [html-extractor](https://github.com/cnyangkui/html-extractor)
  * [vthread](https://github.com/cilame/vthread)
  * [usepy](https://github.com/use-py/usepy)

  If you want to contribute with CrawlersTools check out the [GitHub](https://github.com/MuggleK/CrawlersTools).


