# packages

pkgId: c3283def3f72c3a9b24422a556fc1fe34c60f79435c13c25e1f41c882e14313b
name: python-c2dcczp
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: c2dcczp is a simple block cipher implemented in C
url: https://github.com/Rin-Wood/c2dcczp
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c2dcczp-1.0.0-1.src.rpm
checksum_type: sha256
description:
  `c2dcczp` is a Python package for decrypting data, using a custom CCZp decryption algorithm implemented in C.



  - Provides efficient CCZp decryption functionality, based on C implementation.
  - Supports Python 3.6+



  Install the latest version of `c2dcczp` from PyPI:

  ```bash
  pip install c2dcczp
  ```


  Here's how to use `c2dcczp` for decryption:

  ```python
  import c2dcczp

  data = b'...your encrypted data...'
  key = [uint32, uint32, uint32, uint32]

  c2dcczp.SetKey(key)

  dec = c2dcczp.decrypt(data)


pkgId: d5655e8b1f00080ead827c08175b79e999cbb9ec1a88abd2d793d92795d1310a
name: python-c2g
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Tools for mapping CLIs to GUIs.
description: Placeholder
url: https://github.com/aocks/c2g
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c2g-0.1.0-1.src.rpm
checksum_type: sha256
rpm_license:
  BSD 2-Clause License  Copyright (c) 2016--2019, Emin Martinian 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.  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: 2092967d3cd322b513ec7a636d2606266e12755f6105d9d80b5db9905be99033
name: python-c2net-beta
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: A test package for c2net pypi
url: https://openi.pcl.ac.cn/liuzx/c2net-pypi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c2net-beta-0.2.5-1.src.rpm
checksum_type: sha256
description:
  > PYPI package for c2net-beta



  - 虎鲸平台提供使用代码，数据集，模型示例



  *适配python3.6及以上版本*

  > PYPI package for C2NET-BETA。



  _适配 python3.6 及以上版本_

  ```bash
  pip3 install -U c2net
  pip install c2net==0.0.3 -i https://pypi.tuna.tsinghua.edu.cn/simple
  ```



  ```

  from c2net.context import prepare, upload_output


  c2net_context = prepare()


  code_path = c2net_context.code_path
  dataset_path = c2net_context.dataset_path
  pretrain_model_path = c2net_context.pretrain_model_path
  you_must_save_here = c2net_context.output_path


  upload_output()
  ```


pkgId: b7fea5c7bf5772e06cd531fbbf362696598fea6549fa37a0005fc036ca99c7cf
name: python-c3d
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: A library for manipulating C3D binary files
url: https://github.com/EmbodiedCognition/py-c3d
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c3d-0.5.2-1.src.rpm
checksum_type: sha256
description:
  This is a small library for reading and writing C3D binary files. C3D files are
  a standard format for recording 3-dimensional time sequence data, especially
  data recorded by a 3D motion tracking apparatus.


pkgId: ecac13bf95ef95c08fe14af31f4dae05531149c245fdcc691f660c8f8d4a6c8b
name: python-c3p
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: CHEBI Classification Programs
url: https://pypi.org/project/c3p/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c3p-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Learning classification programs to categorize SMILES strings into [CHEBI](https://www.ebi.ac.uk/chebi/) classes.

  ![logo](docs/assets/c3p-small.png)

  See [Slides](https://docs.google.com/presentation/d/1VJvRptWu6FhTTmZGM4X3ymbxn9JwYPWDUp9djfMfDao/edit#slide=id.p)



  ```bash
  pip install c3p
  c3po -x "CC1=CC=C(C=C1)C1=C(C#N)C2=NC3=CC=CC=C3N2C(N)=C1C#N"
  ```



  All code in Notebook

  Example [generated programs](c3p/programs/)


pkgId: 914d97ee6be33efca5a8a56a853aea36babce0d27f4b88d527e1afbd37183b81
name: python-c42eventextractor
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Utilities to extract and record Code42 security events
url: https://pypi.org/project/c42eventextractor/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c42eventextractor-0.4.1-1.src.rpm
checksum_type: sha256
description:
  ![Build status](https://github.com/code42/c42eventextractor/workflows/build/badge.svg)
  [![versions](https://img.shields.io/pypi/pyversions/c42eventextractor.svg)](https://pypi.org/project/c42eventextractor/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  The `c42eventextractor` package provides modules that assist in the retrieval and logging of Code42 security events and
  alerts. This is done by exposing handlers that allow developers to supply custom behaviors to occur when retrieving
  events. By default, the extractors will simply print their results to stdout, but these handlers can be extended to
  allow developers to record the event info to whatever location or format they desire.



  - Python 2.7.x or 3.5.0+
  - Code42 Server 6.8.x+
  - py42 version 1.7.0+



  Install `c42eventextractor` using pip:

  You can install the `c42eventextractor` package from PyPI, from source, or from distribution.



  The easiest and most common way is to use `pip`:

  ```bash
  pip install c42eventextractor
  ```

  To install a previous version of c42eventextractor via `pip`, add the version number. For example, to install version
  0.2.9, you would enter:

  ```bash
  pip install c42eventextractor==0.2.9
  ```

  Visit the [project history](https://pypi.org/project/c42eventextractor/#history) on PyPI to see all published versions.



  Alternatively, you can install the c42eventextractor package directly from
  [source code](https://github.com/code42/c42eventextractor):

  ```bash
  git clone https://github.com/code42/c42eventextractor.git
  ```

  When it finishes downloading, from the root project directory, run:

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



  If you want create a `.tar` ball for installing elsewhere, run this command from the project's root directory:

  ```bash
  python setup.py sdist
  ```

  After it finishes building, the `.tar` ball will be located in the newly created `dist` directory. To install it, enter:

  ```bash
  pip install c42eventextractor-[VERSION].tar.gz
  ```



  To get all security events, use the `FileEventExtractor`:

  ```python
  from c42eventextractor.extractors import FileEventExtractor
  from c42eventextractor import ExtractionHandlers
  import py42.sdk

  code42_sdk = py42.sdk.from_local_account(
      "https://example.authority.com",
      "admin@example.com",
      "password",
  )

  handlers = ExtractionHandlers()


  def handle_response(response):
      pass

  def record_cursor_position(cursor):
      pass

  def get_cursor_position():
      pass

  handlers.handle_response = handle_response
  handlers.record_cursor_position = record_cursor_position
  handlers.get_cursor_position = get_cursor_position

  extractor = FileEventExtractor(code42_sdk, handlers)
  extractor.extract()




  from py42.sdk.queries.fileevents.filters import EventTimestamp
  time_filter = EventTimestamp.in_range(1564694804, 1564699999)
  extractor.extract(time_filter)


  from datetime import datetime
  begin_date_string = "21 June, 2020"
  end_date_string = "22 June, 2020"
  begin_date = datetime.strptime(begin_date_string, "%d %B, %Y")
  end_date = datetime.strptime(end_date_string, "%d %B, %Y")
  begin_timestamp = (begin_date - datetime.utcfromtimestamp(0)).total_seconds()
  end_timestamp = (end_date - datetime.utcfromtimestamp(0)).total_seconds()
  time_filter = EventTimestamp.in_range(begin_timestamp, end_timestamp)
  extractor.extract(time_filter)




  from py42.sdk.queries.fileevents.filters import DeviceUsername, FilePath
  _NEEDS_DEVICE_USERNAME_FILTER = False
  _NEEDS_FILE_PATH_FILTER = True

  filters = []
  if _NEEDS_DEVICE_USERNAME_FILTER:
      filters.append(DeviceUsername.eq("test.user@example.com"))
  if _NEEDS_FILE_PATH_FILTER:
      filters.append(FilePath.is("path/to/file"))
  extractor.extract(*filters)
  ```



  Getting alerts is similar to getting security events, use the AlertExtractor with appropriate alert filters from the
  `py42.sdk.queries.alerts.filters` module:

  ```python
  from c42eventextractor.extractors import AlertExtractor
  from py42.sdk.queries.alerts.filters import AlertState



  extractor = AlertExtractor(code42_sdk, handlers)

  open_filter = AlertState.eq(AlertState.OPEN)
  extractor.extract(open_filter)
  ```



  The default behavior of the extractor is to "AND" all filter groups that get passed in for extraction. If you want to
  construct an "OR" query between multiple filters, you can set the `.use_or_query` attribute on the
  extractor instance and it will convert the query to "OR" all filters except those in the `.or_query_exempt_filters`
  list. This list by default contains all of the timestamp filter classes (as using "OR" with a timestamp filter negates any
  other filter categories). If you need to exclude any other specific filters from the "OR" group and keep them in the "AND"
  part of the query, you can append either the base filter class (which will exempt any instance of that type of query from the
  "OR" query), or pass in a constructed filter with value(s) to only exclude that exact filter from the "OR" group.

  Example to "OR" two filters (`FileName` and `FileSize`) but keep the whole query restricted to only Exposure events:

  ```python
  extractor = FileEventExtractor(code42_sdk, handlers)

  file_name_filter = FileName.eq("document.txt")
  file_size_filter = FileSize.greater_than(1024*1024*1024)
  exposure_event_filter = ExposureType.exists()


  extractor.use_or_query = True


  extractor.or_query_exempt_filters.append(exposure_event_filter)

  extractor.extract(file_name_filter, file_size_filter, exposure_event_filter)
  ```

  OR queries can be done with both the `FileEventExtractor` and `AlertExtractor`.



  A basic set of handlers is provided in the `c42eventextractor.extraction_handlers.ExtractionHandlers` class.

  These default to printing the response data and any errors to the console and stores cursor position in memory.

  `c42eventextractor` also provides some common logging and formatting implementations that you may find useful for
  reporting on security data.

  For example, to extract and submit file events to a syslog server in CEF format, use the below as your
  `handle_response` implementation:

  ```python
  import json
  import logging
  from c42eventextractor.logging.handlers import NoPrioritySysLogHandler
  from c42eventextractor.logging.formatters import FileEventDictToCEFFormatter

  my_logger = logging.getLogger("MY_LOGGER")
  handler = NoPrioritySysLogHandler("examplehostname.com")
  handler.setFormatter(FileEventDictToCEFFormatter())
  my_logger.addHandler(handler)
  my_logger.setLevel(logging.INFO)

  def handle_response(response):
      events = json.loads(response.text)["fileEvents"]
      for event in events:
          my_logger.info(event)
  ```

  To customize processing of results/errors further, or to persist cursor data to a location of your choosing, override
  the methods on the provided handlers or create your own handler class with the same method signature as
  `c42eventextractor.extraction_handlers.ExtractionHandlers`.



  Because extractors automatically check for cursor checkpoints from the provided handlers, if the `.extract()` method
  is called with the same filter classes used to store the checkpoint position (`DateObserved` for alerts and
  `InsertionTimestamp` for file events), an exception will be raised if a cursor checkpoint already exists, as the
  extractor will automatically add its own timestamp filter to the query.



  c42eventextractor includes mappings from JSON field names to common event format (CEF). These formatters are available
  by importing the `c42eventextractor.logging.formatters` module. To create a logger that logs file events in CEF format
  to a file, follow this guide:

  ```python
  import logging
  from c42eventextractor.logging.formatters import FileEventDictToCEFFormatter

  formatter = FileEventDictToCEFFormatter()
  handler = logging.FileHandler("output.txt", delay=True, encoding="utf-8")
  logger = logging.getLogger("extractor_logger")
  handler.setFormatter(formatter)
  logger.addHandler(handler)
  logger.setLevel(logging.INFO)
  ```

  The following tables map the data from JSON field names to CEF as well as forensic search field names.



  The table below maps JSON fields, CEF fields, and [Forensic Search fields](https://support.code42.com/Administrator/Cloud/Administration_console_reference/Forensic_Search_reference_guide)
  to one another.


  | JSON field                 | CEF field                             | Forensic Search field                  |
  |:--------------------------:|:-------------------------------------:|:--------------------------------------:|
  | actor                      | suser                                 | Actor                                  |
  | cloudDriveId               | aid                                   | n/a                                    |
  | createTimestamp            | fileCreateTime                        | File Created Date                      |
  | deviceUid                  | deviceExternalId                      | n/a                                    |
  | deviceUserName             | suser                                 | Username (Code42)                      |
  | domainName                 | dvchost                               | Fully Qualified Domain Name            |
  | eventId                    | externalID                            | n/a                                    |
  | eventTimestamp             | end                                   | Date Observed                          |
  | exposure                   | reason                                | Exposure Type                          |
  | fileCategory               | fileType                              | File Category                          |
  | fileName                   | fname                                 | Filename                               |
  | filePath                   | filePath                              | File Path                              |
  | fileSize                   | fsize                                 | File Size                              |
  | insertionTimestamp         | rt                                    | n/a                                    |
  | md5Checksum                | fileHash                              | MD5 Hash                               |
  | modifyTimestamp            | fileModificationTime                  | File Modified Date                     |
  | osHostName                 | shost                                 | Hostname                               |
  | processName                | sproc                                 | Executable Name (Browser or Other App) |
  | processOwner               | spriv                                 | Process User (Browser or Other App)    |
  | publicIpAddress            | src                                   | IP Address (public)                    |
  | removableMediaBusType      | cs1 (Code42AEDRemovableMediaBusType)  | Device Bus Type (Removable Media)      |
  | removableMediaCapacity     | cn1 (Code42AEDRemovableMediaCapacity) | Device Capacity (Removable Media)      |
  | removableMediaName         | cs3 (Code42AEDRemovableMediaName)     | Device Media Name (Removable Media)    |
  | removableMediaSerialNumber | cs4                                   | Device Serial Number (Removable Media) |
  | removableMediaVendor       | cs2 (Code42AEDRemovableMediaVendor)   | Device Vendor (Removable Media)        |
  | sharedWith                 | duser                                 | Shared With                            |
  | syncDestination            | destinationServiceName                | Sync Destination (Cloud)               |
  | url                        | filePath                              | URL                                    |
  | userUid                    | suid                                  | n/a                                    |
  | windowTitle                | requestClientApplication              | Tab/Window Title                       |
  | tabUrl                     | request                               | Tab URL                                |
  | emailSender                | suser                                 | Sender                                 |
  | emailRecipients            | duser                                 | Recipients                             |



  See the table below to map exfiltration events to CEF signature IDs.

  | Exfiltration event | CEF field |
  |:------------------:|:---------:|
  | CREATED            | C42200    |
  | MODIFIED           | C42201    |
  | DELETED            | C42202    |
  | READ_BY_APP        | C42203    |
  | EMAILED            | C42204    |


pkgId: a270f1364ec086d5bb48d83cd20cf00d4544a641f8f5946f2a4bc997f5792f75
name: python-c6t
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Unofficial Administrative Command Line Interface for Contrast Security
url: https://github.com/jharper-sec/c6t
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c6t-0.1.1-1.src.rpm
checksum_type: sha256
description:
  An unofficial Administrative Command Line Interface (CLI) for Contrast Security.



  - [c6t](#c6t)
    - [Table of Contents](#table-of-contents)
    - [Features](#features)
    - [Prerequisites](#prerequisites)
    - [Installation](#installation)
    - [Usage](#usage)
      - [Login](#login)
      - [Configure](#configure)
      - [Get Agent Configuration File](#get-agent-configuration-file)
    - [Project Structure](#project-structure)
    - [Development](#development)
      - [Setting Up](#setting-up)
      - [Running Tests](#running-tests)
    - [Contributing](#contributing)
    - [License](#license)



  - Login to your Contrast account and save your API credentials to your local machine.
  - Configure your API credentials manually.
  - Download the agent configuration file to your local machine.
  - Integrate with Secure Code Warrior to fetch training exercises and videos for identified vulnerabilities.
  - Download the latest Contrast Security agent from the Maven repository.



  - Python 3.8 or higher



  ```shell
  $ pip install c6t
  ```





  This will prompt you to login to your Contrast account and save your API credentials to your local machine.

  ```shell
  $ c6t login
  ```



  Alternatively, you can configure your API credentials manually.

  ```shell
  $ c6t configure
  ```



  This will download the agent configuration file to your local machine.

  ```shell
  $ c6t agent-config
  ```



  ```
  c6t-main/
  ├── .github/               # GitHub configuration files for CI/CD
  │   ├── dependabot.yml
  │   └── workflows/
  │       └── dump-env.yml
  ├── src/                   # Source files for the c6t package
  │   └── c6t/
  │       ├── api/
  │       │   ├── agent_config.py
  │       │   ├── __init__.py
  │       │   └── maven_repo.py
  │       ├── configure/
  │       │   ├── __init__.py
  │       │   └── credentials.py
  │       ├── external/
  │       │   └── integrations/
  │       │       └── scw/
  │       │           ├── __init__.py
  │       │           ├── contrast_api.py
  │       │           └── contrast_scw.py
  │       ├── templates/
  │       │   ├── contrast_security.yaml.j2
  │       │   └── contrast_security_env.yaml.j2
  │       ├── ui/
  │       │   └── auth.py
  │       ├── __init__.py
  │       ├── __main__.py
  │       └── cli.py
  ├── tests/                 # Unit tests
  │   ├── data/
  │   │   ├── checksumfile
  │   │   └── testfile
  │   ├── __init__.py
  │   ├── test_cli.py
  │   └── test_maven_repo.py
  ├── .gitignore
  ├── .python-version
  ├── LICENSE
  ├── README.md
  ├── pyproject.toml         # Project configuration
  ├── requirements-dev.lock
  └── requirements.lock
  ```





  1. Clone the repository:
      ```shell
      $ git clone https://github.com/jharper-sec/c6t
      $ cd c6t
      ```

  2. Install [Rye](https://rye.astral.sh/):
      Linux/macOS:
      ```shell
      $ curl -sSf https://rye.astral.sh/get | bash
      ```

  3. Use Rye to install the dependencies:
      ```shell
      $ rye sync
      ```



  To run the tests, use:

  ```shell
  $ rye run pytest
  ```



  Contributions are welcome! Please read the [contributing guidelines](CONTRIBUTING.md) for more details.



  This project is licensed under the terms of the Apache license. See the [LICENSE](LICENSE) file for details.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2024 Contrast Security, Inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 3d5c9d858a713891aa9c3d590fd2176740b762b2a6b260e17aa333efc1d38ab2
name: python-c8-target-c8collection
arch: src
version: 0.0.25
epoch: 0
release: 1
summary: Singer.io target for writing to C8DB collection
description: Singer.io target for writing to C8DB collection
url: https://www.macrometa.com/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c8-target-c8collection-0.0.25-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 https://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  Copyright 2013-2018 Docker, Inc.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  https://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 17ada7c2f6c0bf0e428081b0b32c796e70ba8a0857ab448f8c611e15a9b59922
name: python-c8y-api
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Python microservice and application client for the Cumulocity REST API
url: https://github.com/SoftwareAG/cumulocity-python-api
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c8y-api-3.0.0-1.src.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/SoftwareAG/cumulocity-python-api)
  ![GitHub release (latest by date)](https://img.shields.io/github/v/release/SoftwareAG/cumulocity-python-api)
  ![GitHub Release Date](https://img.shields.io/github/release-date/SoftwareAG/cumulocity-python-api)
  ![ReadTheDocs](https://img.shields.io/readthedocs/cumulocity-python-api)



  This project is a Python client for the Cumulocity REST API to make it easier to develop programs, scripts, device agents or microservices in Python.

  See also the [documentation on _Read the Docs_](https://cumulocity-python-api.readthedocs.io/).






  Before installing the module (or any module for that matter) consider creating
  a virtual environment for your project. This is generally preferred over
  installing modules and dependencies globally:

  ```shell
  cd <project-root>
  python3 -m venv venv
  source venv/bin/activate
  ```



  The recommended way is to install the lastest distribution package directly from the Python Package Index (PyPI).
  You can either add _c8y_api_ as a dependency to your project using _setup.cfg_, or install it manually:

  ```shell
  pip install c8y_api
  ```



  Releases are also archived within the GitHub releases page. The module is released as standard Python wheel (_.whl_ file).
  It can be downloaded and installed using pip using the following command:

  ```shell
  pip install <release wheel file>
  ```

  Like installing from PyPI, this will install all necessary dependencies automatically.  For your
  reference, the module's dependencies are also listed in file _requirements.txt_.



  Alternatively, you can clone the repository. The module sources can be used directly within your Python 3 project.
  Simply copy the _c8y_api_ folder to your sources root and install the requirements by running the following command:

  ```shell
  pip3 install -r requirements.txt
  ```

  The _requirements.txt_ file is part of the sources.

  If the _c8y_api_ folder is in your sources root folder all imports should
  work right away. Alternatively you can add _c8y_api_ to your _PYHTONPATH_:

  ```shell
  export PYTHONPATH=<project-root>/c8y_api; $PYTHONPATH
  ```



  This project is licensed under the Apache 2.0 license - see <https://www.apache.org/licenses/LICENSE-2.0>

  ______________________

  These tools are provided as-is and without warranty or support. They do not constitute part of the Software AG product suite. Users are free to use, fork and modify them, subject to the license agreement. While Software AG welcomes contributions, we cannot guarantee to include every contribution in the master project.

  ______________________

  You can find additional information in the [Software AG TECHcommunity](https://tech.forums.softwareag.com/tag/Cumulocity-IoT). There is also an introductory article ([Getting started with the Cumulocity Python API](https://tech.forums.softwareag.com/t/getting-started-with-the-cumulocity-python-api/264700)) available.

  Contact us at [TECHcommunity](mailto:technologycommunity@softwareag.com?subject=Github/SoftwareAG) if you have any questions.

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


pkgId: 96ec7626926984ddc48023ac016c22719deb5b794ba0af0d75b6de2e41ea2e38
name: python-c8ydm
arch: src
version: 1.3.7
epoch: 0
release: 1
summary: Cumulocity Device Management Agent
url: https://pypi.org/project/c8ydm/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c8ydm-1.3.7-1.src.rpm
checksum_type: sha256
description:
  Cumulocity Device Management (DM) Reference Agent written in Python3 to demonstrate most of the [Device Management Capabilities](https://cumulocity.com/guides/users-guide/device-management/) of [Cumulocity IoT](https://www.softwareag.cloud/site/product/cumulocity-iot.html)



  The agent can be run in a docker container or natively on a device with preferrable with linux OS (e.g raspberry pi) or any other operating system.

  The docker version is mainly used to simulate a device including a SSH + VNC server for Remote Access. It can be also used to simulatoe multiple instances of the agent & devices.

  The native version is mainly used when connecting physical devices with real capabilities and sensors attached.

  Here is a detailed ["How-To" guide](
  https://tech.forums.softwareag.com/t/getting-started-with-cumulocity-iot-device-management/256401) which provides a step-by-step instruction to get the agent running & to explore the device management features of Cumulocity IoT



  To quickly run the agent you can use the [prebuild docker image](https://hub.docker.com/repository/docker/switschel/c8ydm).

      docker run switschel/c8ydm

  If you want docker management included just mount the docker sock to the container by adding

      -v /var/run/docker.sock:/var/run/docker.sock

  Per default Bootstrapping is used and no other information is necessary. In this case the docker **container Id** is the device Id which should be entered when [registering a device in cumulocity](https://www.cumulocity.com/guides/users-guide/device-management/#device-registration-manually).

  You can find it out with:

      docker ps

  If you don't want to use the prebuild image for any reason (e.g. you want to make changes to the docker image) just clone the repo and in a linux shell of your choice use:

      chmod +x start.sh & ./start.sh

  In windows shells like PS or CMD run:

      start.bat

  The script will build a docker image and starting one instance afterwards.

  If you want to run the Agent without using docker you need to [build](#build) and  [run](#run) the Agent manually.



  To configure the agent you can mount the [agent.ini](./config/agent.ini) to the docker image by using in the docker run command:

      -v {{path-to-your-local-agent.ini}}:/root/.cumulocity/agent.ini

  As an alternative you can use [environment variables](#environment-variables) to overwrite the default values in the agent.ini within the image. Here is an example to change the loglevel:

      -e C8YDM_AGENT_LOGLEVEL=DEBUG

  For the local docker build you can use three options to change the docker image:

  1. Enable/Disable VNC as part of the docker image (1 per default)

      ```
      INSTALL_VNC=1 ./start.sh
      ```

  2. By default, the docker container runs in background. If you want to run it interactively:

      ```
      INTERACTIVE=1 ./start.sh
      ```
  3. Generate self-signed certificates and using certificate based authentication

      ```
      USE_CERTS=1 ./start.sh
      ```


  The agent contains scripts for generating & uploading self-signed certificates. To use them additional informatiopn as environment variables are needed. You can use the [use_certs.env](./use_certs.env) file as a template to provide them or add the environment variables using "-e" command of docker.

  Here is an example env file to generate a self signed certificate and upload it to a target tenant:

      C8YDM_MQTT_CERT_AUTH=true
      C8YDM_MQTT_URL=mqtt.eu-latest.cumulocity.com
      CERT_TENANT=<tenantID>
      CERT_USER=<username>
      CERT_PASSWORD=<password>

  The easiest way is to use the --env-file comand of docker to load it. Example:

      docker run --env-file use_certs.env switschel/c8ydm

  or for the local image run after maintaining the [use_certs.env](./use_certs.env):

      USE_CERTS=1 ./start.sh

  If you have your own certificates already you have multiple options to use them. In all cases you must make use of the "device.id" property in the agent.ini to set a device ID you used to generate the certificates.

  **Option 1:** Mount the whole config folder to the docker container containing the certs and adapted agent.ini. Make sure that you set the properties accordingly and that the cert paths are pointing to the location /root/.cumulocity/certs:

      -v {{path-to-your-local-config-folder}}:/root/.cumulocity/


  **Option 2:** Mount the certificates and adapt the config using environment variables

  **Option 3:** Before building the docker image locally copy the certs to "config/certs" folder, change the agent.ini, [build](#building-docker-image) the image and [run](#docker) the image.




  To quickly run the agent natively make sure pyhton 3.7+ and pip is installed on your computer.
  Manually put the [config file](./config/agent.ini) and the [DM_Agent.json](./config/DM_Agent.json) into the /.cumulocity folder in your **user folder**.
  For example: "/home/user1/.cumulocity" in Linux or "C:\Users\user1\\.cumulocity" in Windows.

  Installation

      pip install c8ydm

  To start the agent run

      c8ydm.start

  and to stop run

      c8ydm.stop







  | **Feature**                                  | **Supported**          |
  |----------------------------------------------|------------------------|
  |     Device Certificates                      |     Yes                |
  |     Device Bootstrapping & Registration      |     Yes                |
  |     Software Updates (apt)                   |     Yes                |
  |     Firmware Updates (simulated only)        |     Yes                |
  |     Configuration Updates text-based         |     Yes                |
  |     Configuration file-based                 |     Yes                |
  |     Device Profiles                          |     Yes                |
  |     Network                                  |     Yes                |
  |     Device Metrics (CPU, Memory etc.)        |     Yes                |
  |     Remote Logfile Requests                  |     Yes                |
  |     Location Updates                         |     Yes                |
  |     Remote Shell                             |     Yes                |
  |     Remote Access (SSH, VNC, Passthrough)    |     Yes                |
  |     Hardware Metering (CPU, Memory, HDD)     |     Yes                |
  |     Raspberry PI SenseHAT                    |     Yes                |
  |     Docker Management                        |     Yes                |
  |     Connectivity (Mobile) Management         |     No                 |
  |     Adv. Software Management                 |     Yes (apt)          |
  |     Service Management                       |     Yes (docker)       |



  The DM Agent can run on a Raspberry PI (3+) with a SenseHAT.
  It supports:
  * Reading out all sensor values of the SenseHAT (Humidity, Temperature, Acceleration, Gyroscope, Compass)
  * Display Messages on the LEDs sent via Cumulocity to the Pi (c8y_Message) via Message Widget.
  * Generates Events when the Joystick is pressed in different direction.

  It is suggested to run the Agent as a Service. Use [dm-agent.service](./service/dm-agent.service) to install it:
  ```
  sudo cp ./service/dm-agent.service /etc/systemd/system/
  sudo systemctl enable dm-agent.service
  sudo systemctl daemon-reload
  sudo service dm-agent start
  ```


  The agent can be configured via the agent.ini which must be placed in

      {userFolder}/.cumulocity

  When running in docker container the agent.ini can be mounted to the /root/.cumulocity/agent.ini

  You can find a reference agent.ini [here](/config/agent.ini)

  | Category | Property   | Description
  | ---------|:----------:|:-----------
  | mqtt     | url        | The URL of the Cumulocity MQTT endpoint
  | mqtt     | port       | The Port of the Cumulocity MQTT endpoint
  | mqtt     | tls        | True when using port 8883, false when using port 1883
  | mqtt     | cert_auth  | true when you want use Device Certificates for Device Authentication
  | mqtt     | client_cert | Path to your cert which should be used to for Authentication
  | mqtt     | client_key  | Path to your private key for Authentication
  | mqtt     | ping.interval.seconds | Interval in seconds for the mqtt client to send pings to MQTT Broker to keep the connection alive.
  | agent    | name       | The prefix name of the Device in Cumulocity. The serial will be attached with a "-" e.g. dm-example-device-1234567.
  | agent    | type       | The Device Type in Cumulocity
  | agent    | main.loop.interval.seconds | The interval in seconds sensor data will be forwarded to Cumulocity
  | agent    | requiredinterval | The interval in minutes for Cumulocity to detect that the device is online/offline.
  | agent    | loglevel   | The log level to write and print to file/console.



  The environment variables with "C8YDM_" prefix are mapped to configuration files.
  Mapping rules:

    - Prefix C8YDM_{{CATEGORY}} means what category the option belongs to
    - Upper case letters are mapped to lower case letters
    - Double underscore __ is mapped to .

  Examples:

      C8YDM_MQTT_CERT_AUTH => mqtt.cert_auth
      C8YDM_AGENT_MAIN__LOOP__INTERVAL__SECONDS => agent.main.loop.interval.seconds



  The agent can be build in multiple ways.


  To build the agent via pip just run (as a root user, otherwise add "sudo" prior all commands).

      pip3 install -r requirements.txt

   to install dependencies and afterwards

      pip3 install .

  to build the agent itself.
  Please note that in debian/ubuntu you need additionally install

      apt install python-apt

  via apt.

  Continue with chapter [Run](#run)


  In order to build the .deb yourself first install python-stdeb via apt.

      apt install python3-stdeb

   Afterwards run

      python3 setup.py --command-packages=stdeb.command bdist_deb

  on the level of the setup.py.

  In oder to install the debian package locally run

      apt install ./deb_dist/python-c8ydm_0.1-1_all.deb

  Continue with chapter [Run](#run)



  To build a docker image you can make use of the provided [Dockerfile](./docker/Dockerfile).

  Example:
  ```console
  docker build -t dm-image -f docker/Dockerfile .
  ```





  Before running the agent some manual steps need to be taken

  1. Manually put the [config file](./config/agent.ini) into {userfolder}/.cumulocity

  You can run the agent by executing (as root, otherwise add "sudo")

  ```console
  c8ydm.start
  ```
  in your console when you used [Building via pip](#building-via-pip) to build and install the agent.



  Before running the agent some manual steps need to be taken

  1. Manually put the [config file](./config/agent.ini) and the [DM_Agent.json](./config/DM_Agent.json) into ~/.cumulocity folder. ~ stands for the current user folder. The SmartRESTTemplate will be automatically uploaded on first start.

  2. You have to install "c8y-device-proxy" via pip or using the provided deb file of the [C8Y Device Proxy](https://github.com/SoftwareAG/cumulocity-remote-access-agent/releases/download/v1.1.1/python3-c8y-device-proxy_1.1.1-1_all.deb)

  You can run the agent by executing (as root, otherwise add "sudo")

  ```console
  c8ydm.start
  ```
  in your console when you used [Building via deb](#building-debian-package) to build and install the agent.



  You can run the agent by executing

  ```console
  docker run -d -v /var/run/docker.sock:/var/run/docker.sock dm-image
  ```
  in your console when you used [Building Docker Image](#building-docker-image) to build and install the agent.

  The config can be mounted the container. Otherwise the default config will be used. See [Docker Quick Start Configuration](#docker-quick-start-configuration)



  You can run multiple instances of an container via:

  ```console
  . mass_start.sh 5
  ```

  where in this example 5 is the number of agent instances.



  The project comes with VS Code devcontainer support. Make sure you use [Visual Studio Code](https://code.visualstudio.com/) in combination with docker. Just open the project in VS Code and click on "Reopen in Dev Container".

  In the background the Agent will be build and started. Also a debug/run configuration is provided so you can easilly start/debug the agent within VS Code.



  You can generate certificates necessary to certficate authentication, and you can upload the generated root certificate to your tenant's trusted certificate list by executing the scripts like below:

  ```
  ./scripts/generate_cert.sh \
  --serial pyagent0001 \
  --root-name iot-ca \
  --cert-dir /root/.cumulocity/certs \
  --cert-name device-cert

  ./scripts/upload_cert.sh \
  --tenant-domain <tenant domain> \
  --tenant-id <tenant ID> \
  --username <username for the tenant> \
  --password <password for the tenant> \
  --cert-path /root/.cumulocity/certs/iot-ca.pem \
  --cert-name <(arbitrary) displayed name of the root certificate>
  ```

  After this, you can connect the agent to your tenant using cert authentication (with the serial `pyagent0001` in this case).



  With the agent running in the container, execute

  ```
  ./test.sh \
  --url <tenant domain> \
  --tenant <tenant ID> \
  --username <username for the tenant> \
  --password <password for the tenant>
  ```

  to run pytest.



  The agent knows three types of classes that it will automatically load and include from the "agentmodules" directory.

  1. Sensors

          class Sensor:
            __metaclass__ = ABCMeta

            def __init__(self, serial):
              self.serial = serial

            '''
            Returns a list of SmartREST messages. Will be called every iteration of the main loop.
            '''
            @abstractmethod
            def getSensorMessages(self): pass

     Sensors are periodically polled by the main loop and published.

  2. Listeners

          class Listener:
            __metaclass__ = ABCMeta

            def __init__(self, serial, agent):
              self.serial = serial
              self.agent = agent

            '''
            Callback that is executed for any operation received
            '''
            @abstractmethod
            def handleOperation(self, message): pass

            '''
            Returns a list of supported operations
            '''
            @abstractmethod
            def getSupportedOperations(self): pass

            '''
            Returns a list of supported SmartREST templates (X-Ids)
            '''
            @abstractmethod
            def getSupportedTemplates(self): pass

     Listeners are called whenever there is a message received on a subscribed topic.

  3. Initializers

          class Initializer:
            __metaclass__ = ABCMeta

            def __init__(self, serial):
              self.serial = serial

            '''
            Returns a list of SmartREST messages. Will be called at the start of the agent
            '''
            @abstractmethod
            def getMessages(self): pass

     Initializers are only called once at the start of the agent.

  You can take a look at the two example modules for how it can be used.


  The logfile and configuration can be found in the following directory.

      /root/.cumulocity

  _____________________
  These tools are provided as-is and without warranty or support. They do not constitute part of the Software AG product suite. Users are free to use, fork and modify them, subject to the license agreement. While Software AG welcomes contributions, we cannot guarantee to include every contribution in the master project.

  For more information you can Ask a Question in the [Tech Community Forums](https://tech.forums.softwareag.com/tag/Cumulocity-IoT).


pkgId: 127290f5b60d301d6066a1fac809a2cffddb8fbb66fc406e59c7b8392c467110
name: python-c8ylp
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Cumulocity Local Client Proxy
url: https://github.com/SoftwareAG/cumulocity-remote-access-local-proxy
rpm_license: Apache v2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-c8ylp-2.5.0-1.src.rpm
checksum_type: sha256
description:
  This is a proxy implementation for the Cloud Remote Access feature of Cumulocity which allows to connect to devices using native TCP-based clients like ssh, vnc, rdp etc.

  Main purpose of this proxy is to bridge all TCP packets via WebSocket. The local proxy is designed to run on clients where the native client software is installed.

  ![architecture](img/Remote_access_architecture.png)

  The proxy is written in Python3.



  > ### Migration Notes
  >
  > If your are upgrade from 1.x please see the [MIGRATION to V2 NOTES](docs/MIGRATION_V2.md) as there are some breaking changes. Please forgive us, but you can be sure it is worth it! Version 2.x brings a lot of great features like interactive ssh sessions and plugins to make c8ylp even more useful!
  >

  The Local Proxy can be installed via pip, or manually installed from the repository by cloning it.

  Additionally a Debian package (.deb) can be created by building the project yourself and hosting the package in your own Debian repository. See the [DEVELOPER notes](docs/DEVELOPER.md) for details.




  ```console
  pip install c8ylp
  ```

  >
  > Note: Depending on your python setup, you may need to use `pip3` instead of `pip`.
  >



  You can install specific version by specifying the version number when using pip.

  ```console
  pip install c8ylp==1.5.0
  ```

  Or if you want to install the latest v1.x version and do not want to upgrade to v2.x until you are ready, then use:

  ```console
  pip install "c8ylp<2.0.0"
  ```



  Clone the project, then navigate to the root folder of the project and run:

  ```console
  pip install .
  ```





   * **PASSTHROUGH endpoint:** To use the local proxy you need a remote access PASSTHROUGH endpoint configured on each of your devices you want to connect to. See this guide for further details: https://tech.forums.softwareag.com/t/how-to-get-started-with-cloud-remote-access-for-cumulocity-iot/258446#step-by-step-guide-to-setup-a-passthrough-connection-16

  *  **Tenant Authentication Method:** The desired tenant must be configured to use the `OAI Secure` Authentication. Read more: https://cumulocity.com/guides/users-guide/administration/#authentication

  * **Single Device Tunnel only**: The Local Proxy needs to be executed for each device tunnel you want to establish. Multiple device tunnels per single Local Proxy Instance is currently not supported due to the limitation of the SSH Protocol.



  `c8ylp` supports different commands depending on your use case. The commands are organized in a multi-level command structure. The list of available commands and subcommands can be shown by using the `--help/-h` option.

  The command can be launched by either using the `c8ylp` binary or by calling the `c8ylp` module via python.

  ```sh
  c8ylp


  python -m c8ylp
  ```

  The available commands can be shown using:

  ```console
  % c8ylp --help
  Usage: c8ylp [OPTIONS] COMMAND [ARGS]...

  Options:
    --help  Show this message and exit.

  Commands:
    connect  Connect to a device via different protocols
    login    Login and save token to an environment file
    plugin   Run a custom plugin (installed under ~/.c8ylp/plugins/)
    server   Start local proxy in server mode
    version  Show the c8ylp version number
  ```



  The following scenarios show the common use cases of `c8ylp`.



  ```sh
  c8ylp server <device> --env-file .env
  ```

  The port information will be shown in the terminal so that you can connect to it via a client corresponding to the protocol currently being used on the device (i.e. ssh, vnc etc.)



  If you just want to connect via ssh using a once-off proxy instance using a random port number (to prevent conflicts with other applications), then use:

  ```sh
  c8ylp connect ssh <device> --ssh-user <device_username> --env-file .env
  ```



  **This is a unix only option**

  ```sh
  c8ylp server <device> --env-file .env --socket-path /tmp/device.socket
  ```

  then connect with ssh like:

  ```sh
  ssh -o 'ProxyCommand=socat - UNIX-CLIENT:/tmp/device.socket' <device_username>@localhost
  ```



  Using stdin/out forwarding to Cumulocity enables the use of `c8ylp` as a proxy command without the need of a local TCP server.
  As proxy commands cannot interact with the user you have to ensure there is an active Cumulocity session.

  The session can be ensured by using the `c8ylp login --env-file .env` command that will update the environment file.
  As long as the session is active the Cumulocity server can be used as proxy command with `ssh` as following:

  ```sh
  ssh -o 'ProxyCommand=c8ylp server <device> --stdio --env-file .env' <device_username>@<device>
  ```

  By adding the proxy command to the `.ssh/config` file, the usage of the Cumulocity server can be simplified even more.
  The file allows to define user and environment file so the connection can be done by simply typing `ssh <device>`.
  For this use the following example configuration (`%n` will be replaced by `ssh` with the given device name):

  ```console
  Host <device>
      User <device_username>
      PreferredAuthentications publickey
      IdentityFile <identify_file>
      ServerAliveInterval 120
      StrictHostKeyChecking no
      UserKnownHostsFile /dev/null
      ProxyCommand c8ylp server %n --stdio --env-file .env





  Host linux-*
      User admin
      PreferredAuthentications publickey
      IdentityFile ~/.ssh/myprivatekey
      ServerAliveInterval 120
      StrictHostKeyChecking no
      UserKnownHostsFile /dev/null
      ProxyCommand c8ylp server %n --stdio --env-file .env
  ```



  The command usage and all options can be viewed online on the following pages:

  * [c8ylp](docs/cli/C8YLP.md)
  * [c8ylp login](docs/cli/C8YLP_LOGIN.md)
  * [c8ylp server](docs/cli/C8YLP_SERVER.md)
  * [c8ylp connect](docs/cli/C8YLP_CONNECT.md)
  * [c8ylp connect ssh](docs/cli/C8YLP_CONNECT_SSH.md)
  * [c8ylp plugin](docs/cli/C8YLP_PLUGIN.md)
  * [c8ylp plugin command](docs/cli/C8YLP_PLUGIN_COMMAND.md)
  * [c8ylp version](docs/cli/C8YLP_VERSION.md)



  `c8ylp` can be configured via command line options or environment variables. The environment variables can either be set via the shell, or by using a dotenv file (i.e. `.env`). When using a dotenv (environment) file then it needs to be provide to the `--env-file <file>` option.



  Create a file called `.env` and add the following contents:

  ```sh

  C8Y_HOST=<cumulocity_host>
  C8Y_USER=<your_cumulocity_username>


  C8YLP_VERBOSE=true
  ```

  Then reference the file from the command line:

  ```console
  c8ylp server test-device --env-file .env
  ```

  You can also set the path the dotenv file via an environment variable to save you adding it to all your commands manually. i.e.:

  ```sh

  export C8YLP_ENV_FILE=tenant1.config


  c8ylp connect ssh my-device-name
  ```

  The environment variables corresponding to each option can be viewed by using the in-built help for each command.

  ```sh
  c8ylp server --help

  c8ylp connect ssh --help
  ```

  > Please note that the Local Proxy will block the current terminal session. If you want to use it in background just use "&" and/or "nohup". As the relevant information will be stored in a log file as well you can forward the output to dev/null or to syslog if you want to do so.
  >```
  >c8ylp server [options] > /dev/null 2>&1
  >```

  If no TCP Client is connected but Web Socket Connection is open it might get be terminated by a server timeout. The Local Proxy will automatically reestablish the connection in this case.

  If a TCP Client has been connected and the Web Socket Connection gets terminated, the TCP Client Connection will be terminated which results in that the Local Proxy terminates and needs to be restarted manually.



  `c8ylp` (version >= 2.0.0) supports tab completion for bash, zsh and fish shells.

  To add/activate the completions you will need to add the corresponding line to your shell profile, and reload your shell afterwards.

  **Note**

  Unfortunately tab completion is not supported in PowerShell or Cygwin.

  ```sh

  eval "$(_C8YLP_COMPLETE=bash_source c8ylp)"


  eval "$(_C8YLP_COMPLETE=zsh_source c8ylp)"


  _C8YLP_COMPLETE=fish_source c8ylp | source
  ```



  `c8ylp` can be extended in the form of plugins. Both python based plugins and bash scripts are supported. Checkout the [plugins](docs/PLUGINS.md) documentation for more information about how to create your own plugin, but it is intended for advanced users only. For simple one liners have a look at using the in-built generic plugin [c8ylp plugin command](docs/cli/C8YLP_PLUGIN_COMMAND.md) instead.

  Plugins are loaded at runtime and can be listed by running the following command:

  ```console
  c8ylp plugin
  ```




  The log file can be found in the following directory.

  ```console
  ~/.c8ylp/*.log
  ```

  Where `~` is your user folder.

  To increase the detail of log use the option `--verbose or -v`. If set, the log will be written on debug level.

  Log information will not be printed out to the console by default unless the `--verbose or -v` option is used. The log file however is always active to help provide a record of activities and to help diagnose any problems should they arise.

  You can suppress all console message (i.e. stdout) by redirecting the output to `/dev/null`.

  ```sh

  c8ylp [OPTIONS] > /dev/null 2>&1
  ```



  The Local Proxy depends on the following components packages. The dependencies will be automatically installed when installing via pip or if you are installing c8ylp via a manually built Debian package (.deb).

  * [certifi](https://pypi.org/project/certifi/)
  * [click](https://pypi.org/project/click/)
  * [requests](https://pypi.org/project/requests/)
  * [setuptools](https://pypi.org/project/setuptools/)
  * [websocket_client](https://pypi.org/project/websocket_client/)



  Checkout the [DEVELOPER Notes](docs/DEVELOPER.md) to see how to contribute to the project.

  _____________________
  These tools are provided as-is and without warranty or support. They do not constitute part of the Software AG product suite. Users are free to use, fork and modify them, subject to the license agreement. While Software AG welcomes contributions, we cannot guarantee to include every contribution in the master project.

  For more information you can Ask a Question in the [Tech Community Forums](https://tech.forums.softwareag.com/tag/Cumulocity-IoT).


pkgId: ca4fd43b77c3816df34cb4f1e0b6780240c6f7e34fea9a9088ed151cb8ff71f3
name: python-ca5e9fb055b0e9d98f2c2a6bee72c3f9
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://303sec.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ca5e9fb055b0e9d98f2c2a6bee72c3f9-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  This package is an example of a Dependency Hallucination. There is no code in this package, it is just a placeholder to prevent exploitation.

description:
  This package is an example of a Dependency Hallucination. If you are trying to install it, you have most likely been given this package incorrectly from an AI coding assistant.

  There is no code in this package, it is just a placeholder to prevent exploitation.


pkgId: 99afe203e0a161d0b9872a7d6a22182d4ec8e7e7092cd0773df805aa2667b05e
name: python-cabarchive
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: A pure-python library for creating and extracting cab files
url: https://github.com/hughsie/python-cabarchive
rpm_license: LGPL-2.1-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cabarchive-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Contributors welcome, either adding new functionality or fixing bugs.

  See also: https://msdn.microsoft.com/en-us/library/bb417343.aspx


pkgId: 0ff93f036f89228bc12ecfdbb0b384e636a035f1bc29a78013d875ef6cc2ddfa
name: python-cabby
arch: src
version: 0.1.23
epoch: 0
release: 1
summary: TAXII client library
url: https://github.com/EclecticIQ/cabby/
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cabby-0.1.23-1.src.rpm
checksum_type: sha256
description:
  Python TAXII client implementation from `EclecticIQ <https://www.eclecticiq.com>`_.
  |travis badge| |coveralls.io badge| |docs badge| |requirements badge|
  A simple Python library for interacting with TAXII servers.


pkgId: e50f129c5d02445bad07158ada55a1820279b1ddceafa61124e2c01ead25841c
name: python-cabinets
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A consistent approach to file operations, anywhere.
url: https://github.com/lucasmlofaro/cabinets
rpm_license: GNU GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cabinets-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg?style=flat-square)](https://www.gnu.org/licenses/gpl-3.0)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cabinets?style=flat-square)](#cabinets)
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/lucasmlofaro/cabinets/Python%20package?style=flat-square)](#cabinets)
  [![PyPI](https://img.shields.io/pypi/v/cabinets?style=flat-square)](https://pypi.org/project/cabinets/)

  `cabinets` is a Python library that provides a consistent interface for file operations
  across multiple storage platforms. File extensions are dynamically detected to allow
  automatic serialization and deserialization of Python objects.
  `cabinets` [supports](#built-in-protocols-and-parsers) a variety of protocols and file
  format parsers natively, and new protocols or parsers can be
  easily [registered](#custom-protocols-and-parsers).



  - [Sample Usage](#sample-usage)
      - [Read a file](#read-a-file)
      - [Write a file](#write-a-file)
      - [List files in a directory](#list-files-in-a-directory)
      - [Reading and Writing with Other Protocols](#reading-and-writing-with-other-protocols)
  - [Built-in Protocols and Parsers](#built-in-protocols-and-parsers)
      - [Protocols](#protocols)
      - [Parsers](#parsers)
  - [Protocol Configuration](#protocol-configuration)
  - [Custom Protocols and Parsers](#custom-protocols-and-parsers)
      - [Adding Cabinets](#adding-cabinets)
      - [Adding Parsers](#adding-parsers)
      - [Loading Plugins](#loading-plugins)
  - [Contributing](#contributing)





  Set up a test file in your local filesystem:

  ```python
  import json

  obj = {'test': 1}

  with open('data.json', 'w') as fh:
      json.dump(obj, fh)
  ```

  Read back and parse the file using `cabinets`:

  ```python
  import cabinets

  new_obj = cabinets.read('test.json')
  ```

  That's it! The file is *loaded* and *parsed* in just one line.



  `cabinets` also supports creating files. We can rewrite the first example using
  only `cabinets`.

  ```python
  import cabinets

  obj = {'test': 1}
  cabinets.create('test.json', obj)

  new_obj = cabinets.read('test.json')

  assert new_obj == obj
  ```



  In some situations, you may need to know what files are in a directory before doing
  any operations. `cabinets` also provides an `list` function to assist with this.

  ```python
  import cabinets

  obj = {'test': 1}
  cabinets.create('example/test.json', obj)
  cabinets.create('example/test2.yaml', obj)
  cabinets.create('example/subdir/test3.txt', "test")

  assert cabinets.list('example/') == ['test.json', 'test2.yaml']
  assert cabinets.list('example/subdir/') == ['test3.txt']

  ```

  > **Important:** For simplicity, `cabinets` restricts the output of `list` to **only file types**.
  > Subdirectories are excluded, and must be queried separately.
  > Future versions may include a flag in `list` for returning subdirectories as well.




  Using `cabinets` allows you to interact with multiple file storage protocols depending
  on the URI you specify. In the previous examples, we used
  `read()` and `write()` to operate within our local file system; that's
  because `cabinets` assumes we're using the `file://` protocol by default. Luckily,
  accessing other storage systems is just as easy!

  For example, operating on a file on AWS S3 is done exactly the same way:

  ```python
  import cabinets


  local_obj = cabinets.read('file://test.json')


  cabinets.create('s3://test.json', local_obj)


  remote_obj = cabinets.read('s3://test.json')

  assert local_obj == remote_obj
  ```

  The above example will read a file from the local filesystem and create a new file
  containing the same data, at the same path in S3.

  By prefixing the *path* with `{protocol}://` we specify how and where `cabinets` should
  look for a file. Using `file://` (default if none specified) tells `cabinets` to use *
  path* on the local filesystem. Using `s3://` on the other hand instructs `cabinets` to
  perform operations against that *path* in AWS S3.

  > NOTE: The `S3Cabinet` may require initial configuration for the `s3` protocol to
  > function properly. See [Protocol Configuration](#protocol-configuration) for details.

  See all the natively supported protocols [below](#protocols).





  - Local File System (`file://`)
  - S3 (`s3://`)



  - YAML (`.yml`, `.yaml`)
  - JSON (`.json`)
  - Python Pickle (`.pickle`)
  - CSV *(beta)* (`.csv`)
  - TXT (`.txt`)

  ```python
  import cabinets


  local_foo_data = cabinets.read('file://test.foo')


  s3_foo_data = cabinets.read('s3://test.foo')
  ```



  Some storage platform protocols may require additional configuration parameters to be
  set before they can be used. Each `Cabinet` subclass can expose
  a `set_configuration(**config)` class method to take care of any required initial setup.

  ```python
  from cabinets.cabinet.s3_cabinet import S3Cabinet


  S3Cabinet.set_configuration(region_name='us-west-2', aws_access_key_id=...)


  S3Cabinet.read('bucket-in-us-west-2/test.json')

  import cabinets

  cabinets.read('s3://bucket-us-west-2/test.json')
  ```

  See the documentation of specific `Cabinet` classes for what configuration parameters
  are available.

  Additionally, there is a top-level `set_configuration()` function so that importing
  specific `Cabinet` subclasses is not required. Simply pass the desired protocol as the
  first argument.

  ```python
  import cabinets


  cabinets.set_configuration('s3', region_name='us-west-2', aws_access_key_id=...)


  cabinets.read('s3://bucket-us-west-2/test.json')
  ```



  `cabinets` is designed to allow complete extensibility in adding new protocols and
  parsers. Just because your desired storage platform or file format is not listed above,
  doesn't mean you can't use it with `cabinets`!



  New protocol connections can be added by subclassing abstract base class `Cabinet`, and
  registering the class to one or more protocol identifiers:

  ```python
  from cabinets import Cabinet, register_protocols


  @register_protocols('foo')
  class FooCabinet(Cabinet):

      @classmethod
      def set_configuration(cls, **kwargs):
          
          ...

      @classmethod
      def read_content(cls, path: str) -> bytes:
          
          ...

      @classmethod
      def create_content(cls, path: str, content: bytes):
          
          ...

      @classmethod
      def delete_content(cls, path):
          
          ...

  ```

  Here we define a `FooCabinet`, and register it to the protocol identifier `foo`. Once
  this class is loaded, any `cabinets` function calls using the `foo://` prefix will be
  processed with this class. This means if we called:

  ```python
  import cabinets
  from ... import FooCabinet  # ensure FooCabinet is loaded

  cabinets.read('foo://example.json')
  ```

  The first call that occurs will be `FooCabinet.read_content('foo.json)`, and that result
  is then parsed by the `JSONParser` before being returned.

  > **NOTE**: In order for the protocols to be registered, the class definition must be
  > run at least once. Make sure the modules where your custom `Cabinet` classes are defined
  > are imported somewhere before they are used, OR use the built in [Plugin](#plugins) system.



  `cabinets` also supports custom extension parsing in the exact same way:

  ```python
  from cabinets.parser import Parser, register_extensions


  @register_extensions('bar')
  class BarParser(Parser):
      @classmethod
      def load_content(cls, content: bytes):
          
          ...

      @classmethod
      def dump_content(cls, data: Any):
          
          ...
  ```

  Now if we redo our above example using the `.bar` extension:

  ```python
  from ... import FooCabinet, BarParser  # ensure FooCabinet and BarParser are loaded

  cabinets.read('foo://example.bar')
  ```

  This statement is roughly equivalent to:

  ```python
  BarParser.load_content(FooCabinet.read_content('foo.bar'))
  ```

  and should return a Python object from your `Foo` cabinet, using your `Bar` parser!



  As mentioned in the example above, your custom `Cabinet` and `Parser` classes must be
  executed in order to be added to the internal cache `cabinets` uses for protocol and
  extension lookup. If your custom classes are imported before any `cabinets` functions
  are use then, this won't be an issue. However, in many use cases there is no reason to
  import those classes aside from usage with `cabinets` functions. Instead of requiring
  each class to be imported manually at the start of your program,
  `cabinets` can search a specified path for new `Cabinet` and `Parser` classes, and load
  them automatically.

  Specifying the `PLUGIN_PATH` environment variable will cause `cabinets` to search for
  subdirectories called `cabinet` and `parser` in that path. Modules residing within those
  directories will be searched for `Cabinet` and `Parser` subclasses respectively.

  ```
  └─ PLUGIN_PATH
      |
      └───cabinet
      │   │   foo_cabinet.py
      └───parser
      │   │   bar_parser.py
      │   │   baz_parser.py
  ```

  If the above `FooCabinet` and `BarParser` classes are placed in `foo_cabinet.py`
  and `bar_parser.py`, they will be loaded and registered to their specified cache without
  needing to be referenced anywhere else in the program.



  This package is open source (see [LICENSE](LICENSE)), so please feel free
  to [contribute](https://opensource.guide/how-to-contribute/)
  by submitting a pull request, creating an issue, or contacting the authors directly.



  - Lucas Lofaro *(Co-Author)*: [lucasmlofaro@gmail.com](mailto:lucasmlofaro@gmail.com)
  - Sam Hollenbach *(
    Co-Author)*: [samhollenbach@gmail.com](mailto:samhollenbach@gmail.com)


pkgId: 29e103d401444c7bd128fc59b621c3b8a67ad82068845c0c6c98d6d89dee6c52
name: python-cacahuate
arch: src
version: 3.14.1
epoch: 0
release: 1
summary: The process virtual machine
url: https://github.com/tracsa/cacahuate
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cacahuate-3.14.1-1.src.rpm
checksum_type: sha256
description:
  **The process virtual machine**
  This project defines storage for an abstract _process_ in a company, and
  implements a virtual machine that keeps track of the execution of instances of
  the process.


pkgId: 6e699a94565e71433d25e24c7deacaf08837dcbc43edce198ce59e6ad9de26a6
name: python-cacao-accounting
arch: src
version: 0.0.0.dev20241207
epoch: 0
release: 1
url: https://pypi.org/project/cacao-accounting/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cacao-accounting-0.0.0.dev20241207-1.src.rpm
checksum_type: sha256
summary:
  Accounting solution for the management of Accounts Payable, Accounts Receivable, Inventory, Treasury and General Accounting.

description:
  ![Logo](https://raw.githubusercontent.com/cacao-accounting/cacao-accounting/main/cacao_accounting/static/media/Cacao%20Accounting-01.png)



  [![CI](https://github.com/cacao-accounting/cacao-accounting/actions/workflows/python-package.yml/badge.svg?branch=main&event=push)](https://github.com/cacao-accounting/cacao-accounting/actions/workflows/python-package.yml)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=cacao-accounting_cacao-accounting&metric=alert_status)](https://sonarcloud.io/dashboard?id=cacao-accounting_cacao-accounting)
  [![Coverage Status](https://coveralls.io/repos/github/cacao-accounting/cacao-accounting/badge.svg?branch=main)](https://coveralls.io/github/cacao-accounting/cacao-accounting?branch=main)
  [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fcacao-accounting%2Fcacao-accounting.svg?type=small)](https://app.fossa.com/projects/git%2Bgithub.com%2Fcacao-accounting%2Fcacao-accounting?ref=badge_small)
  ![PyPI - License](https://img.shields.io/pypi/l/cacao-accounting?color=green&logo=apache)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cacao-accounting?logo=Python&color=gree&link=https%3A%2F%2Fpypi.org%2Fproject%2Fstaging-cacao-accounting%2F)
  ![PyPI - Wheel](https://img.shields.io/pypi/wheel/cacao-accounting?logo=Python)
  [![Docker Repository on Quay](https://quay.io/repository/cacaoaccounting/cacaoaccounting/status "Docker Repository on Quay")](https://quay.io/repository/cacaoaccounting/cacaoaccounting)
  [![Gitter](https://badges.gitter.im/cacao-accounting/community.svg)](https://gitter.im/cacao-accounting/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

  Solución contable para la gestión de Cuentas por Cobrar, Cuentas por Cobrar, Inventario, Tesorería y Contabilidad General.

  ```
  Live demo at:
  URL: https://cacao-accounting.onrender.com/login
  User: cacao
  Password: cacao

  Wait to the free render instance to wake up.
  ```


  Nota:
  * Este es un proyecto en etapa temprana de desarrollo no apta para uso en producción.
  * Hemos definido una serie de [metas y objetivos](https://cacao-accounting.github.io/cacao-accounting/ROAD_MAP/) para el proyecto.

  Este proyecto surge de la necesidad observada en Nicaragua de contar con una solucion de software para que micro, pequeñas y medianas empresas (Pymes) cuenten con una herramienta para el procesamiento contable de sus actividades.
  Dado el costo de soluciones de software ya existentes muchas Pymes obtan por usar software pirata que casi de forma
  inevitable termina en una falla del software utilizado y perdida de datos. Otras empresas asumen que al contratar a
  un profesional contable este debe de contar por defecto con una herramienta para llevar la contabilidad de la entidad,
  el objetivo principal de este proyecto es proveeder de una herramienta confiable para el procesamiento contable de las
  operaciones de una o varias entidades.

  Reconocemos que ya existen opciones de soluciones de software contable robustas desarrolladas en python como lo son
  [Odoo](https://www.odoo.com/es_ES/), [Tryton](https://www.tryton.org/) y [ERPNext](https://erpnext.com/). Sin embargo
  estas herramientas requieren o el pago de una suscripción o la instalación de un servidor web, por lo que mayoria de
  profesionales contables no podrian implementarlos sin requerir asistencia de un administrador de sistemas, por esto uno
  de los objetivos de este proyecto es ofrecer tanto una solución de escritorio para un solo usuario así como una solución
  web que pueder ser usada por multiples usuarios al mismo tiempo.

  Consideramos que una ves el proyecto sea un producto usable puede tener potencial economico, no mediante el modelo
  de negocios de licenciamiento, si no con servicios conexos como implementación, capacitación, hospedaje en la nube y mantenimiento



  Todos los aportes son bienvenidos, ver el archivo [CONTRIBUTING](https://cacao-accounting.github.io/cacao-accounting/CONTRIBUTING/) para mas detalles.



  Derechos de autor 2024 William José Moreno Reyes

  Autorizado en virtud de la Licencia de Apache, Versión 2.0 (la "Licencia"); se
  prohíbe utilizar este archivo excepto en cumplimiento de la Licencia. Podrá
  obtener una copia de la Licencia en:

    http://www.apache.org/licenses/LICENSE-2.0

  A menos que lo exijan las leyes pertinentes o se haya establecido por escrito,
  el software distribuido en virtud de la Licencia se distribuye “TAL CUAL”, SIN
  GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sean expresas o implícitas. Véase
  la Licencia para consultar el texto específico relativo a los permisos y
  limitaciones establecidos en la Licencia.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2020 William José Moreno Reyes  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: d6af4fe4c4f8dd6b74d4cd6fb40f9913d0c723540a31bc2a9cb35198c1affd2a
name: python-cacao-accounting-desktop
arch: src
version: 2024.10.11
epoch: 0
release: 1
summary: Cacao Accounting Desktop App.
url: https://pypi.org/project/cacao-accounting-desktop/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cacao-accounting-desktop-2024.10.11-1.src.rpm
checksum_type: sha256
description:
  ![Logo](https://raw.githubusercontent.com/cacao-accounting/cacao-accounting-desktop/main/cacao_accounting_desktop/assets/CacaoAccounting.png)



  [![Python application](https://github.com/cacao-accounting/cacao-accounting-desktop/actions/workflows/python-app.yml/badge.svg)](https://github.com/cacao-accounting/cacao-accounting-desktop/actions/workflows/python-app.yml)

  This is Cacao Accounting software packaged as a windows
  executable, so accountans can download the app and use it
  in theirs Windows personal computers to run small accounting
  projects, once installed you not require a active internet
  conection to run the app, but it is recomended to have a
  conection to the internet to make backups of the app database.

  Please note that if you are a Linux or Mac user you can host
  Cacao Accounting for your personal use with a few steps, this
  project is focused in Windows system that do not have a default
  install of Python.



  Please note that this is not a native windows app, this mean a
  app compiled to run as windows executable, [Cacao Accounting](https://github.com/cacao-accounting/cacao-accounting)
  is a python wsgi app based is the [Flask Python Microframework](https://flask.palletsprojects.com/en/3.0.x/), but we use a simple hack thanks
  to the [Flask Web Gui](https://github.com/ClimenteA/flaskwebgui) project to start a local wsgi server and
  open a browers windows so the user can interact with the app, this way we can simulate a local install of
  the app so accountans can use the app localy with out knowing how to set up a server.

  Note than been usable as standalone Windows app is one of the main reason beging the development of the Cacao
  Accounting project.



  Several steps are necessary to create a windows executable:

  1. Download [WinPython 3.8.10](https://github.com/winpython/winpython/releases/download/4.3.20210620/Winpython32-3.8.10.0dot.exe), this contain a portable version of python suitable to run Cacao Accounting as a desktop app.

  ```
  Please note that there is no formal requirement on the Python version,
  Python 3.8.10 is taken as the base because it is the last stable version
  to support Windows 7.

  Support for Windows 7 ended on January 14, 2020, however some people may
  find it useful to be able to run Cacao Accounting on Windows 7 (it is up
  to the user to use a version of their operating system without manufacturer
  support, updating the operating system version is highly recommended).

  The 32-bit version must be functional but it is recommended to at least
  use a Core i3 processor or higher, which are 64-bit processors.

  It is possible that future versions of this project will update to a more
  recent version of python.
  ```

  3. Uncompress WinPython 3.8.10, this will create a directory name `WPy64-38100` and inside this directory a copy of Python portable named `python-3.8.10.amd64`

  4. Copy the content of `python-3.8.10.amd64` to the `pydist` in the same directory that the script `cacaoaccounting.pyw`, your working directory should be like this:

  ```
  work-dir:
   |-assets
   |-cacaoaccounting.pyw
   |-LICENSE
   |-pydist
    |-python.exe
    |-[support files to the python portable enviroment]
   |-README.md
   |-requirements.txt
   |-setup.nsi
  ```

  4. Install requirements inside the python portable enviroment with:

  ```
  pydist\python.exe -m pip install -r requirements.txt
  ```

  5. Ensure the python portable enviroment can run the scritp with:

  `pydist\python.exe cacaoaccounting.pyw`

  6. Generate a Windows executable with:

  ```
  python -m pip install gen-exe
  gen-exe --hide-console cacaoaccounting.exe "{EXE_DIR}\\pydist\\python.exe cacaoaccounting.pyw" --icon-file cacao_accounting_desktop/assets/icon.ico
  ```

  Your working directory now will have a Windows executable:

  ```
  work-dir:
   |-assets
   |-cacaoaccounting.pyw
   |-cacaoaccounting.exe
   |-LICENSE
   |-pydist
    |-python.exe
    |-[support files to the python portable enviroment]
   |-README.md
   |-requirements.txt
   |-setup.nsi
  ```

  Doble click on the executable to verify it works.

  7. Create a Windows installer with [nsis](https://nsis.sourceforge.io/Main_Page) using the `setup.nsi`, this will create a installer that can be shared to final users.

  ```
  Please consider that .exe installers, unlike .msi installers, may represent a danger
  to your computer by containing malicious software or performing actions not authorized
  by the user. For this reason, we recommend only using .exe installers obtained from
  reliable sources. Since Cacao Accounting Desktop is distributed free of charge, we
  recommend that you always download the application from the official Cacao Accounting
  website and do not use installers provided by third parties.

  To reduce the risk of damage to your computer, the Cacao Accounting installer does not
  require administrator permissions and only makes changes to your user folder without
  affecting other users on the computer.
  ```



  Copyright 2024 BMO Soluciones, S.A.

  ![BMO Logo](https://bmogroup.solutions/wp-content/uploads/2023/11/cropped-Logotipo-BMO-Soluciones-pequeno-1.png)


pkgId: 9922eecbd685270c0081cbd4916793d61f53a0befd052dd9a1cd6b9782c1dc53
name: python-cace
arch: src
version: 2.5.3
epoch: 0
release: 1
summary: Circuit Automatic Characterization Engine
url: https://github.com/efabless/cace
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cace-2.5.3-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">CACE</h1>
  <h2 align="center">Circuit Automatic Characterization Engine</h2>
  <p align="center">
      <a href="https://opensource.org/licenses/Apache-2.0"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License: Apache 2.0"/></a>
      <img src="https://github.com/efabless/cace/actions/workflows/ci.yaml/badge.svg?branch=main" alt="GitHub Actions Status Badge" />
      <a href="https://cace.readthedocs.io/"><img src="https://readthedocs.org/projects/cace/badge/?version=latest" alt="Documentation Build Status Badge"/></a>
      <a href="https://www.python.org"><img src="https://img.shields.io/badge/Python-3.8-3776AB.svg?style=flat&logo=python&logoColor=white" alt="Python 3.8 or higher" /></a>
      <a href="https://github.com/grantjenks/blue"><img src="https://img.shields.io/badge/code%20style-blue-blue.svg" alt="Code Style: blue"/></a>
  </p>
  <p align="center">
      <a href="https://invite.skywater.tools"><img src="https://img.shields.io/badge/Community-Open%20Source%20Silicon%20Slack-ff69b4?logo=slack" alt="Invite to the Open Source Silicon Slack"/></a>
  </p>

  CACE is a framework for analog and mixed-signal circuits that enables automatic characterization under various conditions and with Monte Carlo and mismatch analysis. After all parameters have been run under the given conditions, CACE will generate a summary showing the circuit performance.

  > [!NOTE]
  > The latest documentation can be viewed online at [cace.readthedocs.io](https://cace.readthedocs.io/).



  CACE currently supports two primary methods of installation for it and its dependencies.

  Please read the installation instruction in the documentation under ["Installation Overview"](https://cace.readthedocs.io/en/latest/getting_started/index.html).



  Works for macOS and Linux (x86-64 and aarch64) as well for Windows via WSL2. Recommended, as it is more integrated with your filesystem and overall has less upload and download deltas.

  See [Nix-based installation](https://cace.readthedocs.io/en/latest/getting_started/common/nix_installation/index.html) in the docs for more info.



  You'll need to bring your own compiled utilities, but otherwise, simply install CACE as follows:

  ```console
  	python3 -m pip install --upgrade cace
  ```



  To invoke the CLI:

  ```console
  cace [datasheet] [output] [options]
  ```

  For more information about the usage of CACE please have a look at ["Usage Guides"](https://cace.readthedocs.io/en/latest/usage_guides/index.html) in the documentation.



  There exist already numerous designs that use CACE. We have assembled a list of different designs that you can use as reference: [Example Designs](https://cace.readthedocs.io/en/latest/examples/index.html).



  [The Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt).


pkgId: b05c97b6f3ccafe146b597844fd9c44f47f593355acbab20bce7c09413f42bb5
name: python-cachalot
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Minimal persistent memoization cache
url: https://radek-sprta.gitlab.io/Cachalot/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachalot-1.5.0-1.src.rpm
checksum_type: sha256
description:
  Cachalot is a minimal persistent memoization cache. It provides a decorator, that stores function result for future use. Perfect for heavy computations and I/O operation (such as web requests). On backend, it uses TinyDB for storage.


  - Simple usage via decorator
  - Persistent caching
  - Key expiration
  - Maximum cache size, to prevent bloat


  Cachalot requires Python 3.5 or newer to run.

  **Python package**

  You can easily install Cachalot using pip:

  `pip3 install cachalot`

  **Manual**

  Alternatively, to get the latest development version, you can clone this repository and then manually install it:

  ```
  git clone git@gitlab.com:radek-sprta/cachalot.git
  cd cachalot
  python3 setup.py install
  ```


  ```python
  from cachalot import Cache

  @Cache()
  def expensive_function():
      return expensive_calculation()
  ```


  ```python
  from cachalot import Cache

  @Cache(path='cache.json', timeout=3600, size=5e3, filesize=1e6, retry=True, renew_on_read=True)
  def expensive_function():
      return expensive_calculation()
  ```

  - `path`: Path to the database file. Defaults to .cache.json.
  - `timeout`: How long should the data be cached in seconds. Defaults to 0 (infinite).
  - `size`: Maximum number of keys cached. Defaults to 0 (infinite).
  - `filesize`: Maximum size of database file in bytes. Defaults to 0 (infinite).
  - `retry`: Retry if result is blank. Defaults to False.
  - `renew_on_read`: Renew the entry, i.e refresh the entry timestamp on reads. Defaults to True


  If you want to manually invalidate an entry, you can calculate the hash of the function call and then pass it the `remove` method.

  ```python
  key = cache.calculate_hash(len)('teststring')
  cache.remove(key)
  ```

  For more information, see [documentation][documentation].


  For information on how to contribute to the project, please check the [Contributor's Guide][contributing]


  [mail@radeksprta.eu](mailto:mail@radeksprta.eu)

  [incoming+radek-sprta/cachalot@gitlab.com](incoming+radek-sprta/cachalot@gitlab.com)


  MIT License


  This package was created with [Cookiecutter][cookiecutter] and the [python-cookiecutter][python-cookiecutter] project template. Inspired by [Cashier][cachier]

  [cachier]: https://github.com/atmb4u/cashier
  [contributing]: https://gitlab.com/radek-sprta/cachalot/blob/master/CONTRIBUTING.md
  [cookiecutter]: https://github.com/audreyr/cookiecutter
  [documentation]: https://radek-sprta.gitlab.io/cachalot
  [python-cookiecutter]: https://gitlab.com/radek-sprta/python-cookiecutter


pkgId: e3c5857a2d600bd14997782d874be08dd12be1d11933c153879d13860f6033b4
name: python-cache-decorator
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: a simple decorator to cache the results of computationally heavy functions
url: https://github.com/zommiommy/cache_decorator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cache-decorator-2.2.0-1.src.rpm
checksum_type: sha256
description:
  |pip| |downloads|
  A simple decorator to cache the results of computationally heavy functions.
  The package automatically serialize and deserialize depending on the format of the save path.
  By default it supports ``.json .json.gz .json.bz .json.lzma`` and ``.pkl .pkl.gz .pkl.bz .pkl.lzma .pkl.zip``
  but other extensions can be used if the following packages are installed:
  numpy: ``.npy .npz``
  pandas: ``.csv .csv.gz .csv.bz2 .csv.zip .csv.xz``
  Also there is an optimized format for numerical dataframes:
  pandas: ``.embedding .embedding.gz .embedding.bz2 .embedding.xz``
  This creates an optionally compressed tar archive with pickles of the index and
  columns and a ``.npy`` of the values.
      import time
      import numpy as np
      import pandas as pd
      from cache_decorator import Cache
      @Cache(
          cache_path={
              "info": "/tmp/{function_name}/{_hash}.json.xz",
              "data": "/tmp/{function_name}/{_hash}.csv.gz",
          },
          validity_duration="24d",
          args_to_ignore=("verbose",),
          enable_cache_arg_name="enable_cache",
      )
      def function_to_cache(seed: int, verbose: bool = True):
          np.random.seed(seed)
          if verbose:
              print(f"using seed {seed}")
          return {
              "info": {"timestamp": time.time(), "seed": seed,},
              "data": pd.DataFrame(
                  np.random.randint(0, 100, size=(100, 4)), columns=list("ABCD")
              ),
          }


pkgId: 1ead837c1b0114935b69599ff8ffd668f528d0431c9c20a86670afbb6591f637
name: python-cache-fastapi
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Clean caching library for FastAPI
url: https://github.com/Sayanc2000/cache-fastapi
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cache-fastapi-0.0.6-1.src.rpm
checksum_type: sha256
description:
  "


  A lightweight caching library which leverages FastAPI's middleware functionality
  and follows best practices of cache-control to easily speed up your large requests.


pkgId: a1e513078a45266c1099eaa0b0667f73d561cf8400d4b2948be54769f028b688
name: python-cache-money
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Async cache decorator for memoization using aioredis.
url: https://github.com/novisto/cache-money
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cache-money-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://dev.azure.com/novisto/novisto/_apis/build/status/novisto.cache-money?branchName=master)](https://dev.azure.com/novisto/novisto/_build/latest?definitionId=30&branchName=master)
  [![codecov](https://codecov.io/gh/novisto/cache-money/branch/master/graph/badge.svg?token=V05Y6MTMU2)](https://codecov.io/gh/novisto/cache-money)
  [![Version](https://img.shields.io/pypi/v/cache-money)](https://pypi.org/project/cache-money/)
  [![Python Version](https://img.shields.io/pypi/pyversions/cache-money)](https://pypi.org/project/cache-money/)

  Async cache library for [memoization](https://en.wikipedia.org/wiki/Memoization) using Redis. Inspired by
  [Walrus](https://github.com/coleifer/walrus) and implemented with [aioredis](https://github.com/aio-libs/aioredis-py).

  Cache Money is used through a decorator you can add to your function that needs to be cached. When the decorator
  gets executed, Cache Money will make a unique key from the name of the function and the params received and look up in
  redis if there is a result for this key. If there is a result it will be used as the output of the function and the
  execution of the function will be skipped.

  You can add a timeout in the declaration of the decorator, you can find constants for common timeout duration in
  `cache_money/constants.py`. When the timeout is reached, Redis remove the entry itself.

  It's also possible to clear the cache early by using the method bust that gets added to a function decorated by
  Cache Money. An example is provided below.

  This library is available on PyPI under the name cache-money. You can install with pip by running `pip install
  cache-money`.




  You need a redis instance running to use this library. This library was tested to run on version of Redis >= 4.0.0.
  If you have docker set up you can create a redis instance like this:

  ```shell
  make redis-start
  ```






  First thing is initializing Cache Money and decorating a function that you want to cache

  ```python
  from cache_money import cache_money, init_cache_money
  from cache_money.constants import CACHE_HOUR, CACHE_WEEK

  init_cache_money(host="localhost")

  @cache_money.cached(timeout=CACHE_HOUR)
  async def addition(x: int, y: int) -> int:
      return x + y

  @cache_money.cached(timeout=CACHE_WEEK)
  async def multiplication(x: int, y: int) -> int:
      return x * y
  ```

  If you run the following calls to the function `addition` consecutively:
  ```doctest
    >>> await addition(3, 4)
    7

    >>> await addition(3, 7)
    10

    >>> await addition(3, 4)
    7
  ```

  The first and second call would be executed, but the third call would have used the cache in redis instead, as long
  as the third call was done within one hour of when the first call was made, as the function addition is caching results
  for one hour.

  In Redis you would see two entries like this:

  ```shell


  127.0.0.1:6379> KEYS *
  1) "__main__:addition:ea53056bad64a599c84efdfd4f4cbb64"
  2) "__main__:addition:bb6b7afb6a6cf3191f6d7fd35d976d42"

  127.0.0.1:6379> TTL addition:ea53056bad64a599c84efdfd4f4cbb64
  (integer) 3403
  ```



  You can force expire (bust) the cache for a specific function call

  ```doctest
  >> await addition(3, 4)
  >> await addition(3, 7)
  >> await addition.bust(3, 4)
  ```

  In Redis you would see one entry as the other one has been busted

  ```shell
  127.0.0.1:6379> KEYS *
  1) "__main__:addition:bb6b7afb6a6cf3191f6d7fd35d976d42"
  ```




  You can bust the cache for all instance of a function call

  ```doctest
  >> await addition(3, 4)
  >> await addition(3, 7)
  >> await multiplication(2, 4)
  >> await addition.bust_all()
  ```

  In Redis you would see no entries for the function `addition` which has been busted,
  you would see one entry for `multiplication`

  ```shell
  127.0.0.1:6379> KEYS *
  1) "__main__:multiplication:bc3b7afc6a7cf3191f6d1fd31d810d55"
  ```




  You can bust the cache of all entries made by Cache Money as well

  ```doctest
  >> await addition(3, 4)
  >> await addition(3, 7)
  >> await multiplication(2, 4)
  >> cache_money.bust()
  ```

  In Redis you would see no entries

  ```shell
  127.0.0.1:6379> KEYS *
  (empty array)
  ```




  To set yourself up for development on Cache Money, make sure you are using
  [poetry](https://poetry.eustace.io/docs/) and simply run the following commands from the root directory:

  ```shell
  make sys-deps
  make install
  ```


pkgId: 8cefab3d09b19fad82b6715a23ae6781f9112602bcc1870a7019bd1e12ded448
name: python-cache-pandas
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Easily cache pandas DataFrames to file and in memory.
url: https://pypi.org/project/cache-pandas/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cache-pandas-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Easily cache outputs of functions that generate pandas DataFrames to file or in memory. Useful for data science projects where a large DataFrame is generated, but will not change for some time, so it could be cached to file. The next time the script runs, it will use the cached version.



  `cache-pandas` includes the decorator `cache_to_csv`, which will cache the result of a function (returning a DataFrame) to a csv file. The next time the function or script is run, it will take that cached file, instead of calling the function again.

  An optional expiration time can also be set. This might be useful for a webscraper where the output DataFrame may change once a day, but within the day, it will be the same. If the decorated function is called after the specified cache expiration, the DataFrame will be regenerated.



  The following example will cache the resulting DataFrame to `file.csv`. It will regenerate the DataFrame and its cache if the function is called a second time atleast 100 seconds after the first.

  ```python
  from cache_pandas import cache_to_csv

  @cache_to_csv("file.csv", refresh_time=100)
  def sample_constant_function() -> pd.DataFrame:
      """Sample function that returns a constant DataFrame, for testing purpose."""
      data = {
          "ints": list(range(NUM_SAMPLES)),
          "strs": [str(i) for i in range(NUM_SAMPLES)],
          "floats": [float(i) for i in range(NUM_SAMPLES)],
      }

      return pd.DataFrame.from_dict(data)
  ```


  ```
  filepath: Filepath to save the cached CSV.
  refresh_time: Time seconds. If the file has not been updated in longer than refresh_time, generate the file
      anew. If `None`, the file will never be regenerated if a cached version exists.
  create_dirs: Whether to create necessary directories containing the given filepath.
  ```



  `cache-pandas` includes the decorator `timed_lru_cache`, which will cache the result of a function (returning a DataFrame) to a memory, using `functools.lru_cache`.

  An optional expiration time can also be set. This might be useful for a webscraper where the output DataFrame may change once a day, but within the day, it will be the same. If the decorated function is called after the specified cache expiration, the DataFrame will be regenerated.



  The following example will cache the resulting DataFrame in memory. It will regenerate the DataFrame and its cache if the function is called a second time atleast 100 seconds after the first.

  ```python
  from cache_pandas import timed_lru_cache

  @timed_lru_cache(seconds=100, maxsize=None)
  def sample_constant_function() -> pd.DataFrame:
      """Sample function that returns a constant DataFrame, for testing purpose."""
      data = {
          "ints": list(range(NUM_SAMPLES)),
          "strs": [str(i) for i in range(NUM_SAMPLES)],
          "floats": [float(i) for i in range(NUM_SAMPLES)],
      }

      return pd.DataFrame.from_dict(data)
  ```


  ```
  seconds: Number of seconds to retain the cache.
  maxsize: Maximum number of items to store in the cache. See `functools.lru_cache` for more details.
  typed: Whether arguments of different types will be cached separately. See `functools.lru_cache` for more details.
  ```


  `cache_to_csv` and `timed_lru_cache` can even be composed together. Usually the correct way to do this is to wrap `timed_lru_cache` last, because `cache_to_csv` will always check the file before calling the function. The refresh time can even differ between the two caching mechanisms.


  ```python
  from cache_pandas import timed_lru_cache, cache_to_csv

  @timed_lru_cache(seconds=100, maxsize=None)
  @cache_to_csv("file.csv", refresh_time=100)
  def sample_constant_function() -> pd.DataFrame:
      """Sample function that returns a constant DataFrame, for testing purpose."""
      data = {
          "ints": list(range(NUM_SAMPLES)),
          "strs": [str(i) for i in range(NUM_SAMPLES)],
          "floats": [float(i) for i in range(NUM_SAMPLES)],
      }

      return pd.DataFrame.from_dict(data)
  ```


pkgId: 8cd5345cc890cd816ded29e6f1a9e2510ca90a8b7806ca88b1acad7981def76a
name: python-cache-to-disk
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Local disk caching decorator for python function.
url: https://github.com/sarenehan/cache_to_disk
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cache-to-disk-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Local disk caching decorator for python functions with auto-invalidation.

  This is intended to cache functions that both take a long time to run, and have return values that take up too much memory to cache in-memory with redis. The results of the function are pickled and saved to a file, and then unpickled and returned the next time the function is called. The caching is argument specific, so if the function is called with different arguments, the function will be run again. The caching decorator accepts an integer representing the number of days to cache the function for. After this many days, the file for that function will be deleted the next time this module is imported.


  ```bash
  pip install cache_to_disk
  ```


  cache_to_disk(n_days_to_cache)
  delete_disk_caches_for_function(function_name)
  delete_old_disk_caches()



  **cache_to_disk**
  ```python
  """
  This example caches the function "my_function" for 3 days.
  """

  from cache_to_disk import cache_to_disk

  @cache_to_disk(3)
  def my_function():
      to_return = []
      for i in range(10000):
          for j in range(i):
              to_return.append(i * j ** .23)
      return to_return
  ```
  **delete_disk_caches_for_function**

  ```python
  """
  This example invalidates all of the caches for the function "my_function". The function will be invalidated automatically, but this should be used when the function definition has been changed and you want it to re-run.
  """

  from cache_to_disk import delete_disk_caches_for_function
  delete_disk_caches_for_function('my_function')
  ```

  **runtime_accounting**
  ```python
  """
  This example shows how to check the run-time cache accounting, which shows hits, misses and nocache events
  """

  from cache_to_disk import cache_to_disk

  @cache_to_disk(3)
  def query_registrar(host, port, query):
      socket = tcp_connect(host, port)
      socket.send(query)
      response = b''
      while True:
          buf = read_wrapper(socket)
          if buf is None:
              break
          response += buf
      return response

  query_registrar('whois.verisign-grs.com', 43, b'test.com')
  query_registrar('whois.verisign-grs.com', 43, b'test.com')
  query_registrar('whois.verisign-grs.com', 43, b'test.com')
  query_registrar('whois.verisign-grs.com', 43, b'test.com')
  print(query_registrar.cache_info())
  ```

  **nocache**
  ```python
  """
  This example shows how to inhibit caching depending on certain conditions, such as a network failure while also returning a value
  """
  from cache_to_disk import cache_to_disk, NoCacheCondition
  from random import randint
  @cache_to_disk(3)
  def query_registrar(host, port, query):
      socket = tcp_connect(host, port)
      socket.send(query)
      response = b''
      while True:
          try:
              if randint(0, 5) > 3:
                  
                  raise socket.error
              buf = read_wrapper(socket)

              if buf is None:
                  break
              response += buf
          except socket.error:
              
              
              raise NoCacheCondition(function_value=response)
      return response

  query_registrar('whois.verisign-grs.com', 43, b'test.com')
  query_registrar('whois.verisign-grs.com', 43, b'test.com')
  query_registrar('whois.verisign-grs.com', 43, b'test.com')
  query_registrar('whois.verisign-grs.com', 43, b'test.com')
  print(query_registrar.cache_info())
  ```


pkgId: 93470ab9f57d709856ed1ef333bbebfd19b1376c02f3becf7ff3e35faef5aeca
name: python-cache3
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: A safe and lightweight cache library, written in pure-Python.
url: https://github.com/StKali/cache3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cache3-0.4.3-1.src.rpm
checksum_type: sha256
description:
  **cache3** is a MIT licensed  safe and lightweight cache library, written
  in pure-Python.
  cache3 is very tiny and completely implemented by the Python standard library without any third-party dependencies, so it can be easily embedded in any Python program or script.


pkgId: 03dd2fb4f498e1f7b9c1e97d267c14bae3a73e51eceff6ee3d328470fc26cca1
name: python-cachecall
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A cache library for sync and async functions with ttl and expiration time.
url: https://github.com/igor-rodrigues-ss/cachecall
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachecall-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A cache library for sync and async functions with ttl and expiration time.


  - [Algorithm (FIFO)](#algorithm)
  - [TTL](#ttl-time-to-live)
  - [Expire Time](#exp)
  - [Cache groups](#cache-groups)
  - [Examples](#examples)
      - [Cache regular (sync) functions](#cache-regular-sync-functions)
      - [Cache async functions](#cache-async-functions)
      - [Cache with max size](#cache-with-max-size)
      - [Cache with ttl (time to live)](#cache-with-ttl-time-to-live)
      - [Cache with expire time](#cache-with-expire-time)
      - [Cache group](#cache-group)
      - [Clean cache group](#clean-cache-group)
      - [Keep cache ignoring some keys](#keep-cache-ignoring-some-keys)
      - [Cache with memory max size](#cache-with-memory-max-size)
      - [Access cache object](#access-cache-object)
  - [Documentation](#documentation)
      - [Cache decorator](#cache-decorator)
      - [Cache object](#cache-object)
      - [Expire Time class](#expire-time-class)


  The FIFO Algorithm is used to control the input and output of data for cache groups.


  By default each function has its own cache group to keep the cached data separated. Is possible create a shared cache group between different functions or clear cache group using ```clear_cache("group_name")```.


  By default the ```cache``` decorator has the ttl parameter to define *time to live* in seconds to expire the cached data.


  With **cachecall.ExpireTime** is possible define a specific time to cached data expire every day. [Example here](#cache-with-expire-time).





  ```python
  from cachecall import cache

  @cache()
  def func(x=None):
      print("call")
      return 10
  ```


  ```python
  from cachecall import cache

  @cache()
  async def afunc(x=None):
      print("call")
      return 15

  await afunc()
  ```


  ```python
  from cachecall import cache

  @cache(max_size_call=2)
  def func(x):
      print("call")
      return x

  func("a") # Add value "a" in cache
  func("b") # Add value "b" in cache
  func("c") # Remove value "a" from cache and Add value "c"
  func("d") # Remove value "b" from cache and Add value "d"
  ```



  ```python
  from cachecall import cache

  @cache(ttl=10)
  def func(x=1):
      print("call")
      return "abc"
  ```

  - Each 10 seconds the cache for the function ```func``` will be expired.



  ```python
  from cachecall import cache, ExpireTime

  @cache(expire_time=ExpireTime(10, 15, 20))
  def func(a=None):
      print("call")
      return "xyz"
  ```

  - Every day at 10:15:20 the value cached will expire.
  - If the ```ExpireTime(10, 15, 20)``` will defined before 10:15:20 in current day, the the data cached will expired in same day, but if ExpireTime will defined after the 10:15:20, the cached value will be expired in next day.
  - You can expire cache in several specific hours using a tuple of several ExpireTime.

  ```python
  @cache(expire_time=(ExpireTime(6, 0, 0), ExpireTime(12, 0, 0), ExpireTime(18, 0, 0),))
  def func(a):
      ...
  ```



  ```python
  from cachecall import cache, ExpireTime

  @cache(ttl=18000, expire_time=ExpireTime(6, 0, 0))
  def func(a=None):
      print("call")
      return "xyz"
  ```
  - ```ttl``` and ```expire_time``` can be used together. In this example the cached data will expire each 5 hours and every day at 6:00:00.


  ```python
  from cachecall import cache

  @cache(group_name='some_group_name')
  def do_a(x=None):
      print("call a")
      return "xyz"

  @cache(group_name='some_group_name')
  def do_b(x=None):
      print("call abc")
      return "abc"
  ```

  - All the cached data will be stored inside a cache group called "some_group_name".
  - Even though you use many different functions with the same parameters inside the same cache group, all cached data are associated with your specific function.



  ```python
  from cachecall import cache, clear_cache

  @cache(group_name='some_group_name')
  def func(x=None):
      print("call")
      return "xyz"

  clear_cache('some_group_name') # Clear all cached data inside some_group_name
  ```



  ```python
  from cachecall import cache

  @cache(ignore_keys=("y"))
  def func(x=1, y=None):
      print("call")
      return x

  func(1, y=1) # Cache data
  func(1, y=2) # the y value is ignored and the cached data is returned
  func(1, y=12345) # the y value is ignored and the cached data is returned
  func(2, y=12345) # Add new data in cache
  ```
  - When some parameter is defined in ignore keys tuple these parameter value is ignored in cache creation, and even though the value of this parameter is changed the data will be kept cached.
  - Currently this feature only works if the ignored parameters are used as named arguments.


  ```python
  from cachecall import cache, kb
  fake_lg1 = ''.join([str(val) for val in range(500)]) # sizeof: 1439 bytes
  fake_lg2 = '-'.join([str(val) for val in range(400)]) # sizeof: 1538 bytes

  @cache(max_size_mem=kb(2)) # defining a limit of usage memory for 2 kilobytes (2048 bytes)
  def func(param):
      print("call")

      if param == "a":
          return fake_lg1

      return fake_lg2

  func("a") # Add fake_lg1 in cache
  func("a") # Using cache
  func("b") # Remove fake_lg1 from cache because of memory limit 2048 bytes and add fake_lg2
  ```



  ```python
  from cachecall import cache

  @cache()
  def func(x):
      print('call')
      return x

  func(1) # add in cache
  func(1) # Use cached data
  func(2) # add in cache


  func.cache.data # Cached data
  ```
  - See more about [cache object](#cache-object).





  ```python
  from cachecall import cache
  ```


  - max_size_call: *Optional[int]*
      - Number of values (or call to cached function) that will be stored in cache.
      - If None the cache size will be unlimited.
      - Default value is None.

  - group_name: *Optional[str]*
      - Group name for cached data.
      - Each function has their own cache group, but if you wish to use the same cached data for different functions just use the same *group_name* for these functions.
      - If None the group name default will be "function-name_uuid4".
      - Default value is None.

  - ttl: *Optional[Union[int, float]]*
      - (Time To Live) Value in seconds to expire the cached data.
      - If None the value never expires.
      - Default value is None.

  - expire_time: *Optional[Union[ExpireTime, Tuple[ExpireTime]]]*
      - Specific time to expire a cached value daily.
      - You can use a tuple (or list) of ```ExpireTime``` objects for defining several specific times to expire data.
      - If None the value never expires.
      - Default value is None.

  - ignore_keys: *Optional[Tuple[str]]*
      - Tuple of parameters name that will be ignored in cache.
      - If some cached data exists and the value of some ignored_key is changed, the data will be continued cached because all arguments mapped in ignore_keys tuple will be ignored.
      - Currently this feature only works if the ignored parameters are used as named arguments.
      - *Observation*:
          - Even though the cached function (function decorated by *cachecall.cache* decorator) no has any defined parameter the data of this function will be cached using a "no-key" key for identifying cached data.

          - The ```ignore_keys``` have be used if your cached function (function decorated by *cachecall.cache* decorator) has at least two parameters or more, because, if your function has only one parameter and this parameter is defined in ignore_keys, that means that your function will cache data normally because the only defined parameter will be ignored. Therefore, using ```ignore_keys``` for cached functions with only one defined parameter and this only parameter name passed as value in *ignore_keys* will have no effect and the data will be cached normally.

          - This behavior also will occur if you have many parameters and all parameters names are passed to ```ignore_keys```.

  - log_level: *Optional[Union[int, str]]*
      - This parameter is useful for you to see some behaviors that's occurring in data caching.
      - Default value is ```logging.WARNING```.

  - max_size_mem: *Optional[Union[int, float]]*
      - Define a limit of memory usage in bytes for each cache group. All cached data always have a memory size less or equal to the value defined in max_size_mem.
      - If a unique data has a size memory greater than the value defined in ```max_size_mem``` this value will not be cached. This operation will be logged as debug level.
      - Default value is None. Thats mean that no exists memory limit for cache group.
      - Functions for control cache unity:
          - ```from cachecall import kb, mb, gb```
          - ```kb(val)```: return the ```val``` value converted to bytes. For example: ```kb(1) = 1024```.
          - ```mb(val)```: return the ```val``` value converted to bytes. For example: ```mb(1) = 1048576```.
          - ```gb(val)```: return the ```val``` value converted to bytes. For example: ```gb(1) = 1073741824```.




  - This object is used to control the cache data.
  - Each cached function will have a cache object.
  - The goal in adding this method in the cached function is for debug purposes using ```func.cache.data```.
  - We recommend strongly that you won't handle any operation using this method so you do not cause any unexpected error.


  ```python
  from cachecall import ExpireTime

  @dataclass
  class ExpireTime:
      hour: int
      minute: int
      second: int
  ```


pkgId: 00dd09ab4b2afc41ca056a117d29612ccdaf7525118acb2f84b93a45e26f1e7e
name: python-cached-historical-data-fetcher
arch: src
version: 0.2.24
epoch: 0
release: 1
summary: Python utility for fetching any historical data using caching.
url: https://github.com/34j/cached-historical-data-fetcher
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cached-historical-data-fetcher-0.2.24-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/34j/cached-historical-data-fetcher/actions/workflows/ci.yml?query=branch%3Amain">
      <img src="https://img.shields.io/github/actions/workflow/status/34j/cached-historical-data-fetcher/ci.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://cached-historical-data-fetcher.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/cached-historical-data-fetcher.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/34j/cached-historical-data-fetcher">
      <img src="https://img.shields.io/codecov/c/github/34j/cached-historical-data-fetcher.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/cached-historical-data-fetcher/">
      <img src="https://img.shields.io/pypi/v/cached-historical-data-fetcher.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/cached-historical-data-fetcher.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/cached-historical-data-fetcher.svg?style=flat-square" alt="License">
  </p>

  Python utility for fetching any historical data using caching.
  Suitable for acquiring data that is added frequently and incrementally, e.g. news, posts, weather, etc.



  Install this via pip (or your favourite package manager):

  ```shell
  pip install cached-historical-data-fetcher
  ```



  - Uses cache built on top of [`joblib`](https://github.com/joblib/joblib), [`lz4`](https://github.com/lz4/lz4) and [`aiofiles`](https://github.com/Tinche/aiofiles).
  - Ready to use with [`asyncio`](https://docs.python.org/3/library/asyncio.html), [`aiohttp`](https://github.com/aio-libs/aiohttp), [`aiohttp-client-cache`](https://github.com/requests-cache/aiohttp-client-cache). Uses `asyncio.gather` for fetching chunks in parallel. (For performance reasons, only using `aiohttp-client-cache` is probably not a good idea when fetching large number of chunks (web requests).)
  - Based on [`pandas`](https://github.com/pandas-dev/pandas) and supports `MultiIndex`.





  Override `get_one()` method to fetch data for one chunk. `update()` method will call `get_one()` for each unfetched chunk and concatenate results, then save to cache.

  ```python
  from cached_historical_data_fetcher import HistoricalDataCacheWithFixedChunk
  from pandas import DataFrame, Timedelta, Timestamp
  from typing import Any


  class MyCacheWithFixedChunk(HistoricalDataCacheWithFixedChunk[Timestamp, Timedelta, Any]):
      delay_seconds = 0.0 # delay between chunks (requests) in seconds
      interval = Timedelta(days=1) # interval between chunks, can be any type
      start_index = Timestamp.utcnow().floor("10D") # start index, can be any type

      async def get_one(self, start: Timestamp, *args: Any, **kwargs: Any) -> DataFrame:
          """Fetch data for one chunk."""
          return DataFrame({"day": [start.day]}, index=[start])


  print(await MyCacheWithFixedChunk().update())
  ```

  ```shell
                             day
  2023-09-30 00:00:00+00:00   30
  2023-10-01 00:00:00+00:00    1
  2023-10-02 00:00:00+00:00    2
  ```

  **See [example.ipynb](example.ipynb) for real-world example.**



  Override `get_one` method to fetch data for one chunk in the same way as in `HistoricalDataCacheWithFixedChunk`.
  After updating `ids` by calling `set_ids()`, `update()` method will call `get_one()` for every unfetched id and concatenate results, then save to cache.

  ```python
  from cached_historical_data_fetcher import IdCacheWithFixedChunk
  from pandas import DataFrame
  from typing import Any

  class MyIdCache(IdCacheWithFixedChunk[str, Any]):
      delay_seconds = 0.0 # delay between chunks (requests) in seconds

      async def get_one(self, start: str, *args: Any, **kwargs: Any) -> DataFrame:
          """Fetch data for one chunk."""
          return DataFrame({"id+hello": [start + "+hello"]}, index=[start])

  cache = MyIdCache() # create cache
  cache.set_ids(["a"]) # set ids
  cache.set_ids(["b"]) # set ids again, now `cache.ids` is ["a", "b"]
  print(await cache.update(reload=True)) # discard previous cache and fetch again
  cache.set_ids(["b", "c"]) # set ids again, now `cache.ids` is ["a", "b", "c"]
  print(await cache.update()) # fetch only new data
  ```

  ```shell
         id+hello
      a   a+hello
      b   b+hello
         id+hello
      a   a+hello
      b   b+hello
      c   c+hello
  ```



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-end -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: 029d2f7be91e08de02c0aa916a02da845e921133358fc3d01eb624a274d49c23
name: python-cached-path
arch: src
version: 1.6.3
epoch: 0
release: 1
summary: A file utility for accessing both local and remote files through a unified interface
url: https://github.com/allenai/cached_path
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cached-path-1.6.3-1.src.rpm
checksum_type: sha256
description:
  <!-- start tagline -->

  A file utility library that provides a unified, simple interface for accessing both local and remote files.
  This can be used behind other APIs that need to access files agnostic to where they are located.

  <!-- end tagline -->

  <p align="center">
      <a href="https://github.com/allenai/cached_path/actions">
          <img alt="CI" src="https://github.com/allenai/cached_path/workflows/CI/badge.svg?event=push&branch=main">
      </a>
      <a href="https://pypi.org/project/cached_path/">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/cached_path">
      </a>
      <a href="https://cached-path.readthedocs.io/en/latest/?badge=latest">
          <img src="https://readthedocs.org/projects/cached-path/badge/?version=latest" alt="Documentation Status" />
      </a>
      <a href="https://github.com/allenai/cached_path/blob/main/LICENSE">
          <img alt="License" src="https://img.shields.io/github/license/allenai/cached_path.svg?color=blue&cachedrop">
      </a>
      <br/>
  </p>



  - [Documentation](https://cached-path.readthedocs.io/)
  - [PyPI Package](https://pypi.org/project/cached-path/)
  - [Contributing](https://github.com/allenai/cached_path/blob/main/CONTRIBUTING.md)
  - [License](https://github.com/allenai/cached_path/blob/main/LICENSE)



  <!-- start py version -->

  **cached-path** requires Python 3.7 or later.

  <!-- end py version -->



  <!-- start install pip -->

  **cached-path** is available [on PyPI](https://pypi.org/project/cached-path/). Just run

  ```bash
  pip install cached-path
  ```

  <!-- end install pip -->



  <!-- start install source -->

  To install **cached-path** from source, first clone [the repository](https://github.com/allenai/cached_path):

  ```bash
  git clone https://github.com/allenai/cached_path.git
  cd cached_path
  ```

  Then run

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

  <!-- end install source -->



  ```python
  from cached_path import cached_path
  ```

  Given something that might be a URL or local path, `cached_path()` determines which.
  If it's a remote resource, it downloads the file and caches it to the [cache directory](#cache-directory), and
  then returns the path to the cached file. If it's already a local path,
  it makes sure the file exists and returns the path.

  For URLs, `http://`, `https://`, `s3://` (AWS S3), `gs://` (Google Cloud Storage), and `hf://` (HuggingFace Hub) are all supported out-of-the-box.
  Optionally `beaker://` URLs in the form of `beaker://{user_name}/{dataset_name}/{file_path}` are supported, which requires [beaker-py](https://github.com/allenai/beaker-py) to be installed.

  For example, to download the PyTorch weights for the model `epwalsh/bert-xsmall-dummy`
  on HuggingFace, you could do:

  ```python
  cached_path("hf://epwalsh/bert-xsmall-dummy/pytorch_model.bin")
  ```

  For paths or URLs that point to a tarfile or zipfile, you can also add a path
  to a specific file to the `url_or_filename` preceeded by a "!", and the archive will
  be automatically extracted (provided you set `extract_archive` to `True`),
  returning the local path to the specific file. For example:

  ```python
  cached_path("model.tar.gz!weights.th", extract_archive=True)
  ```



  By default the cache directory is `~/.cache/cached_path/`, however there are several ways to override this setting:
  - set the environment variable `CACHED_PATH_CACHE_ROOT`,
  - call `set_cache_dir()`, or
  - set the `cache_dir` argument each time you call `cached_path()`.



  <!-- start team -->

  **cached-path** is developed and maintained by the AllenNLP team, backed by [the Allen Institute for Artificial Intelligence (AI2)](https://allenai.org/).
  AI2 is a non-profit institute with the mission to contribute to humanity through high-impact AI research and engineering.
  To learn more about who specifically contributed to this codebase, see [our contributors](https://github.com/allenai/cached_path/graphs/contributors) page.

  <!-- end team -->



  <!-- start license -->

  **cached-path** is licensed under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0).
  A full copy of the license can be found [on GitHub](https://github.com/allenai/cached_path/blob/main/LICENSE).

  <!-- end license -->

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


pkgId: 2dc9e6155beec4a4d119b8a296512c1ef92a1268691d71425f3ad7d37f13f5f8
name: python-cached_method
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: The equivalent of cached_property for methods
url: https://pypi.org/project/cached_method/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cached_method-0.1.0-1.src.rpm
checksum_type: sha256
description:
  The `@cached_method` decorator is the equivalent of
  [`functools.cached_property`](https://docs.python.org/3/library/functools.html#functools.cached_property)
  for methods. This means that each instance has its own cache, so that the caches get
  garbage collected as soon as the owning objects are. The main advantages of
  `cached_method` over applying `functools.lru_cache` directly to methods are
  1. the surrounding class need not be hashable,
  2. and the class objects are not collected in a global cache, extending their lifetime.
  This makes `cached_method` applicable to classes holding references to scarce resources
  such as GPU memory that you want to be freed as soon as possible. Furthermore, the
  decorator can cache the output of `__hash__` because it does not hash the object itself
  for cache lookups.

  Implementation-wise `cached_method` closely follows `functools.cached_property` though it
  eschews the internal locking, which is now [considered a
  mistake](https://bugs.python.org/issue43468). Since cached methods should be idempotent
  anyway, we just accept possibly calling the method multiple times in parallel with
  equivalent arguments if the object is used in multi-threaded contexts.

  ```python
  from cached_method import cached_method

  class GPUVector:
      def __init__(self, data):
          
          self.data = data

      
      @cached_method(maxsize=2)
      def norm(self, p=2):
          return (self.data ** p).sum() ** (1 / p)

      @cached_method
      def __hash__(self):
          
          return hash(tuple(self.data.to_cpu()))
  ```

  If you are working with small, hashable objects that do not have to be gargabe collected
  as soon as possible, consider the [method hashing technique described in the Python
  FAQ](https://docs.python.org/3/faq/programming.html#how-do-i-cache-method-calls). It gives
  you an easy way to control the total cache size and allows cache hits between
  equivalent-but-not-identical objects. Of course, caching on the class level means that
  objects stay live until you clear the cache manually, even if the cache is the last object
  referencing them.


pkgId: c2b9fc9a9acb7d488a338fb3dca95b0ed60daa6e7f0dbb04eb54cce3bccf3c30
name: python-cacheout
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: A caching library for Python
url: https://github.com/dgilland/cacheout
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cacheout-0.16.0-1.src.rpm
checksum_type: sha256
description:
  - Project: https://github.com/dgilland/cacheout
  - Documentation: https://cacheout.readthedocs.io
  - PyPI: https://pypi.python.org/pypi/cacheout/
  - Github Actions: https://github.com/dgilland/cacheout/actions


pkgId: 58962d3f9ad555a741db86b6ec93b74e9e3cd6c36c870d0250a576436d4e6f69
name: python-cacherator
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A Python package to cache class properties and function results in JSON files.
url: https://pypi.org/project/cacherator/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cacherator-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Cacherator is a Python package that provides decorators to cache class properties and function results in JSON files. This is particularly useful for classes that perform expensive computations or make external API calls, allowing results to persist across program executions.



  - Persistent Caching: Automatically saves and loads class properties and method results to and from JSON files.
  - Time-to-Live (TTL) Support: Define how long cached results remain valid.
  - Automatic Serialization: Handles JSON serialization of common data types, including datetime objects.
  - Customizable Storage: Specify the directory and filename for cached data.
  - Logging: Optional logging of cache operations for easier debugging and monitoring.



  Install the package using pip:
  ```bash
  pip install cacherator
  ```



  Use the `json_cache` decorator to enable caching for a class.

  ```python
  from cacherator import json_cache

  @json_cache(ttl=1)
  class ExampleClass:
      def __init__(self, example_id="example"):
          self.data_id = example_id

      def expensive_method(self, x):
          
          return x ** 2


  obj = ExampleClass(example_id="example_1")
  result = obj.expensive_method(5)  # Calls the method and caches the result
  ```

  When a method from a decorated class object is called again with the same arguments, the cached result will be used as long as the time-to-live of the cache is not exceeded. When the class object is closed (usually when the program ends), the cache will be written to a json file. When the class object is initialized the next time, the stored json will be loaded into the cache.


  - `data_id` (str, optional): Unique identifier for the JSON file. Defaults to the class name.
  - `directory` (str, optional): Directory where the JSON file will be saved. Defaults to "json/data".
  - `clear_cache` (bool, optional): If True, clears any existing cache when initializing the object. Defaults to False.
  - `ttl` (float | int | timedelta, optional): Time-to-live for cached function results. Defaults to 999 days.
  - `logging` (bool, optional): If True, enables logging of save/load operations. Defaults to True.

  Every function in the decorated class automatically accepts two additional named arguments:
  - `clear_cache` (bool, optional): If True, clears any existing cache of this function. Defaults to False.
  - `ttl` (float | int | timedelta, optional): Set time-to-live for this specific function. Defaults to the class decorator ttl.


  This project is licensed under the MIT License.


  For questions or suggestions, please open an issue on the [GitHub repository](https://github.com/Redundando/json_cache).


pkgId: af5a1d134a3b774325ffcfd1e153f9cb03571c44e6d5f2afff51a21344f5987a
name: python-cacherator
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: A Python library for persistent JSON-based caching of class state and function results.
url: https://pypi.org/project/cacherator/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cacherator-1.0.5-1.src.rpm
checksum_type: sha256
description:
  Cacherator is a Python package that provides persistent caching functionality for your Python classes and functions. It allows you to easily cache function results to disk, improving performance for expensive computations or API calls.



  - Persistent caching of function results
  - Customizable Time-To-Live (TTL) for cached data
  - Option to clear cache on demand
  - JSON-based storage for easy inspection and portability
  - Automatic serialization and deserialization of cached data
  - Support for instance methods and properties



  You can install PyCacherator using pip:

  ```bash
  pip install cacherator
  ```





  To use Cacherator, simply inherit from the `JSONCache` class and use the `@Cached` decorator on your methods:

  ```python
  from cacherator import JSONCache, Cached

  class MyClass(JSONCache):
      def __init__(self, data_id):
          super().__init__(data_id=data_id)

      @Cached()
      def expensive_operation(self, arg1, arg2):
          
          return result
  ```



  You can customize the caching behavior by passing arguments to the `JSONCache` constructor and the `@Cached` decorator:

  ```python
  from datetime import timedelta
  from cacherator import JSONCache, Cached

  class MyClass(JSONCache):
      def __init__(self, data_id):
          super().__init__(
              data_id=data_id,
              directory="custom/cache/dir",
              clear_cache=False,
              ttl=timedelta(days=999),
              logging=True
          )

      @Cached(ttl=300, clear_cache=False)
      def cached_method(self, arg):
          
          return result
  ```





  The base class for objects with caching capabilities.



  - `data_id` (str): Unique identifier for the cache instance.
  - `directory` (str): Directory to store cache files (default: "json/data").
  - `clear_cache` (bool): Whether to clear existing cache on instantiation (default: False).
  - `ttl` (timedelta | int | float): Default Time-To-Live for cached data (default: 999 days).
  - `logging` (bool): Enable logging of cache operations (default: True).



  Decorator for caching method results.



  - `ttl` (float | int | timedelta): Time-To-Live for the cached result (defaults to the ttl set on object level).
  - `clear_cache` (bool): Whether to clear existing cache before execution (default: False).



  This project is licensed under the MIT License.


pkgId: 59a40b7cf499722c172bfe0c81cf9b7352dc4883fc7ab4d879135a7a75155ec3
name: python-cachetools
arch: src
version: 5.5.0
epoch: 0
release: 1
summary: Extensible memoizing collections and decorators
url: https://github.com/tkem/cachetools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachetools-5.5.0-1.src.rpm
checksum_type: sha256
description:
  This module provides various memoizing collections and decorators,
  including variants of the Python Standard Library's `@lru_cache`_
  function decorator.
     from cachetools import cached, LRUCache, TTLCache
     
     @cached(cache={})
     def fib(n):
         return n if n < 2 else fib(n - 1) + fib(n - 2)
     
     @cached(cache=LRUCache(maxsize=32))
     def get_pep(num):
         url = 'http://www.python.org/dev/peps/pep-%04d/' % num
         with urllib.request.urlopen(url) as s:
             return s.read()
     
     @cached(cache=TTLCache(maxsize=1024, ttl=600))
     def get_weather(place):
         return owm.weather_at_place(place).get_weather()
  For the purpose of this module, a *cache* is a mutable_ mapping_ of a
  fixed maximum size.  When the cache is full, i.e. by adding another
  item the cache would exceed its maximum size, the cache must choose
  which item(s) to discard based on a suitable `cache algorithm`_.
  This module provides multiple cache classes based on different cache
  algorithms, as well as decorators for easily memoizing function and
  method calls.


pkgId: 020937b7c02fc4b933ad4d4e5a5b338025f633d02cee76054572f8ca089c7fc6
name: python-cachetory
arch: src
version: 3.4.2
epoch: 0
release: 1
summary: Caching library with support for multiple cache backends
url: https://github.com/kpn/cachetory
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachetory-3.4.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/cachetory?logo=python&logoColor=yellow)](https://pypi.org/project/cachetory/)
  [![Python versions](https://img.shields.io/pypi/pyversions/cachetory?logo=python&logoColor=yellow)](https://pypi.org/project/cachetory/)
  [![Checks](https://img.shields.io/github/actions/workflow/status/kpn/cachetory/check.yml?label=checks&logo=github)](https://github.com/kpn/cachetory/actions/workflows/check.yml)
  [![Coverage](https://codecov.io/gh/kpn/cachetory/branch/main/graph/badge.svg?token=UNYTTvxiWk)](https://codecov.io/gh/kpn/cachetory)
  ![Code style](https://img.shields.io/badge/code%20style-ruff-000000.svg)



  <a href="https://kpn.github.io/cachetory/">
      <img alt="Documentation" height="30em" src="https://img.shields.io/github/actions/workflow/status/kpn/cachetory/docs.yml?label=documentation&logo=github">
  </a>



  ```python
  from cachetory import serializers
  from cachetory.backends import async_ as async_backends
  from cachetory.caches.async_ import Cache


  cache = Cache[int, bytes](
      serializer=serializers.from_url("pickle://?pickle-protocol=4"),
      backend=async_backends.from_url("redis://localhost:6379"),
  )

  async def main() -> None:
      await cache.set("foo", 42)
      assert await cache.get("foo") == 42
  ```


pkgId: fef8934e21d8b23b8bef82c033ee124db7481950fa9452f53c2a171546621979
name: python-cachew
arch: src
version: 0.18.20241020
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/karlicoss/cachew
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachew-0.18.20241020-1.src.rpm
checksum_type: sha256
rpm_license:
  The MIT License (MIT)  Copyright (c) 2019 Dima Gerasimov  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: e6321269d5ed9f38b2ae1f7a5717376b8d922d697e24a34d133943d161a4419d
name: python-cachey
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Caching mindful of computation/storage costs
url: http://github.com/dask/cachey/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachey-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Humans repeat stuff.  Caching helps.
  Normal caching policies like LRU aren't well suited for analytic computations
  where both the cost of recomputation and the cost of storage routinely vary by
  one million or more.  Consider the following computations
  ```python

  np.std(x)        # tiny result, costly to recompute

  np.transpose(x)  # huge result, cheap to recompute
  ```
  Cachey tries to hold on to values that have the following characteristics
  1. Expensive to recompute (in seconds)
  2. Cheap to store (in bytes)
  3. Frequently used
  4. Recenty used
  It accomplishes this by adding the following to each items score on each access
      score += compute_time / num_bytes * (1 + eps) ** tick_time
  For some small value of epsilon (which determines the memory halflife.) This
  has units of inverse bandwidth, has exponential decay of old results and
  roughly linear amplification of repeated results.


pkgId: 5f884f36057fd323ebb6e21c89c1780ccd73d9fb1e38de71658d7709c6d9a206
name: python-cachier
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Persistent, stale-free, local and cross-machine caching for Python functions.
url: https://pypi.org/project/cachier/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachier-3.0.1-1.src.rpm
checksum_type: sha256
description:
  Install ``cachier`` with:
      pip install cachier
  For the latest version supporting Python 2.7 please use:
      pip install 'cachier==1.2.8'

rpm_license:
  MIT License  Copyright (c) 2016 Shay Palachy  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: 8af4b075faf61d6ab10fe4f5aef6e0962a407a1ece6ffc404a7499ce531db218
name: python-cachingutil
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: A collection of caching utilities.
url: https://bitbucket.org/daycoder/cachingutil.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachingutil-1.2.7-1.src.rpm
checksum_type: sha256
description:
  A hierarchy of classes to provide caching functionality
  with minimal fuss.
  When using the cache, just use the fetch method.
  This will pull from the cache if it's present and
  not expired otherwise will use 'fetch_from_source'.


pkgId: 460125f8e5f98e504496b190c7dc7bd7df7bb3e78cb3ce575f8af64ccd07c1c0
name: python-cacholote
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Efficiently cache calls to functions
url: https://pypi.org/project/cacholote/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cacholote-1.4.0-1.src.rpm
checksum_type: sha256
description:
  Efficiently cache calls to functions



  ```python
  >>> import cacholote
  >>> cacholote.config.set(cache_db_urlpath="sqlite://")
  <cacholote.config.set ...

  >>> @cacholote.cacheable
  ... def now():
  ...     import datetime
  ...     return datetime.datetime.now()

  >>> now() == now()
  True

  >>> with cacholote.config.set(use_cache=False):
  ...     now() == now()
  False

  ```



  ```python
  >>> import cacholote

  >>> import tempfile
  >>> tmpdir = tempfile.TemporaryDirectory().name
  >>> cacholote.config.set(
  ...     cache_db_urlpath="sqlite://",
  ...     cache_files_urlpath=tmpdir,
  ... )
  <cacholote.config.set ...

  >>> cached_open = cacholote.cacheable(open)
  >>> cached_file = cached_open("README.md")
  >>> cached_file.name.startswith(tmpdir)
  True

  >>> import filecmp
  >>> filecmp.cmp("README.md", cached_file.name)
  True

  ```



  ```python
  >>> import cacholote

  >>> import pytest
  >>> xr = pytest.importorskip("xarray")

  >>> import tempfile
  >>> tmpdir = tempfile.TemporaryDirectory().name
  >>> cacholote.config.set(
  ...     cache_db_urlpath="sqlite://",
  ...     cache_files_urlpath=tmpdir,
  ... )
  <cacholote.config.set ...

  >>> @cacholote.cacheable
  ... def dataset_from_dict(ds_dict):
  ...     return xr.Dataset(ds_dict)

  >>> ds = dataset_from_dict({"foo": 0})
  >>> ds
  <xarray.Dataset> Size: 8B
  Dimensions:  ()
  Data variables:
      foo      int64 ...

  >>> ds.encoding["source"].startswith(tmpdir)
  True

  ```



  Configuration settings can be accessed using `cacholote.config.get()` and modified using `cacholote.config.set(**kwargs)`. It is possible to use `cacholote.config.set` either as a context manager, or to configure global settings. See `help(cacholote.config.set)`.

  Defaults are controlled by environment variables and dotenv files. See `help(cacholote.config.reset)`.



  For best experience create a new conda environment (e.g. DEVELOP) with Python 3.11:

  ```
  conda create -n DEVELOP -c conda-forge python=3.11
  conda activate DEVELOP
  ```

  Before pushing to GitHub, run the following commands:

  1. Update conda environment: `make conda-env-update`
  1. Install this package: `pip install -e .`
  1. Sync with the latest [template](https://github.com/ecmwf-projects/cookiecutter-conda-package) (optional): `make template-update`
  1. Run quality assurance checks: `make qa`
  1. Run tests: `make unit-tests`
  1. Run the static type checker: `make type-check`
  1. Build the documentation (see [Sphinx tutorial](https://www.sphinx-doc.org/en/master/tutorial/)): `make docs-build`



  In case of database structure upgrade, developers must follow these steps:

  1. Update the new database structure modifying [/cacholote/database.py](/cacholote/database.py), using
     [SQLAlchemy ORM technologies](https://docs.sqlalchemy.org/en/latest/orm/)
  1. Execute from the cacholote work folder:
     ```
     alembic revision -m "message about the db modification"
     ```
  1. The last command will create a new python file inside [/alembic/versions](/alembic/versions). Fill the `upgrade`
     function with the operations that must be executed to migrate the database from the old structure to the new one.
     Keep in mind both DDL (structure modification) and DML (data modification) instructions. For reference,
     use https://alembic.sqlalchemy.org/en/latest/ops.html#ops.
     Similarly, do the same with the `downgrade` function.
  1. Commit and push the modifications and the new file.

  For details about the alembic migration tool, see the [Alembic tutorial](https://alembic.sqlalchemy.org/en/latest/tutorial.html).



  ```
  Copyright 2019, B-Open Solutions srl.
  Copyright 2022, European Union.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ```

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2019, B-Open Solutions srl.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: b151ad447ac400d3f970311879a489270731ad03b2ae6bb77d817ae06f814ec9
name: python-cachr
arch: src
version: 0.0.9
epoch: 0
release: 1
url: https://github.com/mike-huls/cachr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachr-0.0.9-1.src.rpm
checksum_type: sha256
summary:
  Easy caching in Python. Cachr allows you to compose your own cache and comes pre-packaged with many useful caches

description:
   ```text
   ██████╗ █████╗  ██████╗██╗  ██╗██████╗
  ██╔════╝██╔══██╗██╔════╝██║  ██║██╔══██╗
  ██║     ███████║██║     ███████║██████╔╝
  ██║     ██╔══██║██║     ██╔══██║██╔══██╗
  ╚██████╗██║  ██║╚██████╗██║  ██║██║  ██║
   ╚═════╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝
  ```

  ![coverage](https://img.shields.io/codecov/c/github/mike-huls/cachr)
  ![Tests](https://github.com/mike-huls/cachr/actions/workflows/tests.yml/badge.svg)
  ![version](https://img.shields.io/pypi/v/cachr?color=%2334D058&label=pypi%20package)
  ![dependencies](https://img.shields.io/librariesio/release/pypi/cachr)
  ![PyPI Downloads](https://img.shields.io/pypi/dm/cachr.svg?label=PyPI%20downloads)
  ![versions](https://img.shields.io/pypi/pyversions/cachr.svg?color=%2334D058)


  [//]: # (|         |                                                                                                                                                                                                                                                                                                                                                               |)

  [//]: # (|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|)

  [//]: # (| Testing | ![coverage]&#40;https://img.shields.io/codecov/c/github/mike-huls/cachr&#41;                                                                                                                                                                                                                                                                                          |)

  [//]: # (| Package | [![PyPI Latest Release]&#40;https://img.shields.io/pypi/v/cachr.svg&#41;]&#40;https://pypi.org/project/cachr/&#41; [![PyPI Downloads]&#40;https://img.shields.io/pypi/dm/cachr.svg?label=PyPI%20downloads&#41;]&#40;https://pypistats.org/packages/cachr&#41; <br/>![status]&#40;https://img.shields.io/pypi/status/cachr&#41; ![dependencies]&#40;https://img.shields.io/librariesio/release/pypi/cachr&#41; |)

  [//]: # (| Meta    | ![GitHub License]&#40;https://img.shields.io/github/license/mike-huls/cachr&#41; ![implementation]&#40;https://img.shields.io/pypi/implementation/cachr&#41;  ![versions]&#40;https://img.shields.io/pypi/pyversions/cachr&#41;                                                                                                                                                       |)

  [//]: # (| Social  | ![tweet]&#40;https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fmike-huls%2Fcachr&#41; ![xfollow]&#40;https://img.shields.io/twitter/follow/mike_huls?style=social&#41;                                                                                                                                                                           | )

  **cachr** is a Python package that provides superfast, composable caches designed to
  optimize your applications in an easy and intuitive way.
  It aims to be the go-to package to use and build caches that make your applications
  superfast, memory-efficient and user-friendly.
  ```shell
  pip install cachr
  ```


  - [Main Features](#main-features)
  - [Usage Example](#Usage-example)
  - [Installation](#Installation)
  - [Dependencies](#Dependencies)
  - [License](#license)
  - [Documentation](#documentation)
  - [Development](#development)
  - [Contributing to Cachr](#Development)


  - 🐍 Pure Python
  - 🖌 Easily extendable
  - 👨‍🎨 User-friendly


  At the moment there are five caches available for use:
  - LFUCache: Removes the least frequently used item in the cache when it overflows
  - LRUCache: A Least Recently Used Cache removes the least recently used item when it overflows
  - RandomReplaceCache: randomly expells an item from the cache when it overflows
  - TTLCache: A Time-To-Live-cache acts like a LRUCache and also removes an entry from the cache after a certain expiration time
  - SlidingWindowCache: Like a TTLCache but it renews the expiration date eacht time an item is requested from the cache.

  All caches are added to your code in two ways: by `decorator` or as a regular object.
  Decorator:
  ```python
  import time
  from cachr import LRUCache



  @LRUCache(capacity=2)
  def add(i, y):
      time.sleep(1)
      print("adding..")
      return i + y


  print(add(1, 2))    # <-- takes a second to calculate
  print(add(1, 2))    # <-- takes value from cache immediately
  print(add(1, 2))    # <-- takes value from cache immediately
  ```

  Object:
  ```python
  from cachr import TTLCache

  my_cache =  TTLCache(capacity=25, ttl_seconds=60)

  def very_expensive_function(number:int) -> int:
      return number * number

  for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 3, 5, 7, 9, 1, 1, 1, 1]:
      value_from_cache = my_cache.get(i)
      if value_from_cache is not None:
          print(f"Answer for {i} is {value_from_cache}")
          continue
      print(f"calculating expensive function for {i}..")
      my_cache.put(key=i, value=very_expensive_function(number=i))
  ```




  ```sh
  pip install cachr
  ```
  The source code is currently hosted on GitHub at:
  https://github.com/mike-huls/cachr

  Binary installers for the latest released version are available at the [Python
  Package Index (PyPI)](https://pypi.org/project/cachr).


  Cachr has no Python dependencies


  [MIT](LICENSE.txt)


  🔨 Under construction


  Find the changelog and list of upcoming features [here](doc/CHANGELOG.md).
  <br>
  **Contributions** are always welcome; feel free to submit bug reports, bug fixes, feature requests, documentation improvements or enhancements!

  <hr>

  [Go to Top](#table-of-contents)


pkgId: e5667c53246bd359e5c1bb48199b3bbdbc2ba00b71036e6f5970b8d967228125
name: python-cachy
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Cachy provides a simple yet effective caching library.
url: https://github.com/sdispater/cachy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cachy-0.3.0-1.src.rpm
checksum_type: sha256
description:
  * `Documentation <http://cachy.readthedocs.org>`_
  * `Issue Tracker <https://github.com/sdispater/cachy/issues>`_


pkgId: b549dc0b547c1052ba615171670137b77496b89481f5c8a755ab2d38963e7e4e
name: python-cad-to-dagmc
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: Converts CAD files to a DAGMC h5m file
url: https://github.com/fusion-energy/cad_to_dagmc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cad-to-dagmc-0.7.3-1.src.rpm
checksum_type: sha256
description:
  [![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)

  [![CI with Conda install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_conda_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_conda_install.yml) Testing package and running examples with dependencies installed via Conda

  [![CI with pip install](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_pip_install.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_pip_install.yml) Testing package and running examples with dependencies installed vua PIP

  [![CI with model benchmark zoo](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_benchmarks.yml/badge.svg?branch=main)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/ci_with_benchmarks.yml) Testing with [Model Benchmark Zoo](https://github.com/fusion-energy/model_benchmark_zoo)

  [![Upload Python Package](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml/badge.svg)](https://github.com/fusion-energy/cad_to_dagmc/actions/workflows/python-publish.yml)

  [![PyPI](https://img.shields.io/pypi/v/cad_to_dagmc?color=brightgreen&label=pypi&logo=grebrightgreenen&logoColor=green)](https://pypi.org/project/cad_to_dagmc/)


  A minimal package that converts CAD geometry to [DAGMC](https://github.com/svalinn/DAGMC/) h5m files

  cad-to-dagmc can create:
  - surface meshes / faceted geometry / triangular meshes
  - unstructured mesh / tetrahedral meshes / volume meshes

  cad-to-dagmc can convert:
  - STEP files
  - CadQuery objects (in memory)

  cad-to-dagmc aims to produce DAGMC compatible h5m files from CAD geometry is intended to convert [STEP](http://www.steptools.com/stds/step/) files or [CadQuery](https://cadquery.readthedocs.io) objects to a [DAGMC](https://github.com/svalinn/DAGMC/) compatible h5m file.

  The resulting DAGMC geometry can then be used for simulations in [OpenMC](https://github.com/openmc-dev/openmc/) or [other supported codes](https://svalinn.github.io/DAGMC/).

  This package is tested with [pytest tests](https://github.com/fusion-energy/cad_to_dagmc/tree/main/tests) and also the DAGMC geometry made with this package is compared to simulation carried out with native constructive solid geometry, see [Model Benchmark Zoo](https://github.com/fusion-energy/model_benchmark_zoo) for more details.

  Also checkout these other software projects that also create DAGMC geometry [CAD-to-OpenMC](https://github.com/openmsr/CAD_to_OpenMC), [Stellarmesh](https://github.com/Thea-Energy/stellarmesh) and [Coreform Cubit](https://coreform.com/products/coreform-cubit/)



  - Install using Mamba
  - Install using Conda
  - Install using pip and source compilations



  In principle, installing any Conda/Mamba distribution will work. A few Conda/Mamba options are:
  - [Miniforge](https://github.com/conda-forge/miniforge) (recommended as it includes mamba)
  - [Anaconda](https://www.anaconda.com/download)
  - [Miniconda](https://docs.conda.io/en/latest/miniconda.html)

  This example assumes you have installed the Miniforge option or separately have installed Mamba with ```conda install -c conda-forge mamba -y```

  Create a new environment, I've chosen Python 3.10 here but newer versions are
  also supported.
  ```bash
  mamba create --name new_env python=3.10 -y
  ```

  Activate the environment
  ```bash
  mamba activate new_env
  ```

  Then you can install the cad_to_dagmc package
  ```bash
  mamba install -y -c conda-forge cad_to_dagmc
  ```



  In principle, installing any Conda/Mamba distribution will work. A few Conda/Mamba options are:
  - [Miniforge](https://github.com/conda-forge/miniforge) (recommended as it includes mamba)
  - [Anaconda](https://www.anaconda.com/download)
  - [Miniconda](https://docs.conda.io/en/latest/miniconda.html)

  Create a new environment, I've chosen Python 3.10 here but newer versions are
  also supported.
  ```bash
  conda create --name new_env python=3.10 -y
  ```

  Activate the environment
  ```bash
  conda activate new_env
  ```

  Then you can install the cad_to_dagmc package
  ```bash
  conda install -y -c conda-forge cad_to_dagmc
  ```



  It is also possible to avoid the use of conda/mamba and installing using pip.

  First ensure hdf5 is installed as this is needed by MOAB pip install command

  ```
  sudo apt-get install libhdf5-dev
  ```

  Then clone the latest version of MOAB and cd into the moab directory.

  ```
  git clone  master https://bitbucket.org/fathomteam/moab/
  cd moab
  ```

  Ensure pip is up to date as a new version is needed
  ```
  python -m pip install --upgrade pip
  ```

  Run the pip install command with cmake arguments.
  ```
  pip install . --config-settings=cmake.args=-DENABLE_HDF5=ON
  ```

  Then you can install the cad_to_dagmc package with ```pip```

  ```bash
  pip install cad_to_dagmc
  ```



  You may also want to install OpenMC with DAGMC to make use of the h5m geometry files produced in simulations. However you could also use other supported particle transport codes such as MCNP, FLUKA and others [link to DAGMC documentation](https://svalinn.github.io/DAGMC/).

  To install OpenMC you can run ```mamba install -c conda-forge openmc``` however this more specific command makes sure the latest version of OpenMC which contains DAGMC is chosen by conda / mamba
  ```bash
  mamba install -c conda-forge -y "openmc=0.14.0=dagmc*nompi*"
  ```

  It might not be possible to install OpenMC and cad-to-dagmc in the same conda/mamba python environment so you may have to create a new conda/mamba environment and install OpenMC there.

  Another option would be to [install OpenMC from source](https://docs.openmc.org/en/stable/quickinstall.html) which would also need compiling with MOAB and DAGMC options.




  The package requires newer versions of Linux. For example the package does not work on Ubuntu 18.04 or older.

  The package requires newer versions of pip. It is recommended to ensure that your version of pip is up to date. This can be done with ```python -m pip install --upgrade pip```

  Installing one of the package dependancies (gmsh) with pip appears to result in errors when passing cad objects in memory between cadquery / ocp and gmsh. The default method of passing cad objects is via file so this should not impact most users. The conda install gmsh appears to work fine with in memory passing of cad objects as the version of OCP matches between Gmsh and CadQuery.




  For examples see the [examples folder](https://github.com/fusion-energy/cad_to_dagmc/tree/main/examples)



  For examples see the [examples folder](https://github.com/fusion-energy/cad_to_dagmc/tree/main/examples)

  For more examples see the CAD tasks in the [neutronics-workshop](https://github.com/fusion-energy/neutronics-workshop) and [model benchmark zoo](https://github.com/fusion-energy/model_benchmark_zoo)


pkgId: e3bd3a29968ccb01da4cf58d8d67e31cebfbf58a514e43254caacfbdb377670c
name: python-cad-to-h5m
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Converts CAD files to a DAGMC h5m file using Cubit
url: https://github.com/fusion-energy/cad_to_h5m
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cad-to-h5m-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![N|Python](https://www.python.org/static/community_logos/python-powered-w-100x40.png)](https://www.python.org)

  [![CircleCI](https://circleci.com/gh/fusion-energy/cad_to_h5m/tree/main.svg?style=svg)](https://circleci.com/gh/fusion-energy/cad_to_h5m/tree/main) [![CI with docker build](https://github.com/fusion-energy/cad_to_h5m/actions/workflows/ci_with_docker_build.yml/badge.svg)](https://github.com/fusion-energy/cad_to_h5m/actions/workflows/ci_with_docker_build.yml)

  [![PyPI](https://img.shields.io/pypi/v/cad-to-h5m?color=brightgreen&label=pypi&logo=grebrightgreenen&logoColor=green)](https://pypi.org/project/cad-to-h5m/)


  <!-- can't report coverage as cubit init changes scope
  [![codecov](https://codecov.io/gh/fusion-energy/cad_to_h5m/branch/main/graph/badge.svg)](https://codecov.io/gh/fusion-energy/cad_to_h5m) -->

  [![docker-publish-release](https://github.com/fusion-energy/cad_to_h5m/actions/workflows/docker_publish.yml/badge.svg)](https://github.com/fusion-energy/cad_to_h5m/actions/workflows/docker_publish.yml)

  This is a minimal Python package that provides both **command line** and
  **API** interfaces for converting **multiple** CAD files (STP and SAT format)
  into a DAGMC h5m file using the Cubit Python API.

  This is useful for creating the DAGMC geometry for use in compatible neutronics
  codes such as OpenMC, FLUKA and MCNP.

  The geometry is tagged wih material names, optional imprinted and merging
  during the process which can speed up particle transport.

  <!--


  Perhaps the most common use of this program is to convert a STP file into
  DAGMC geometry.
  ```bash
  cad-to-h5m -i part1.stp -o dagmc.h5m -t mat:1 -c /opt/Coreform-Cubit-2021.5/bin/
  ```

  - the ```-i``` or ```--input``` argument specifies the input CAD filename(s)
  - the ```-o``` or ```--output``` argument specifies the output h5m filename
  - the ```-t``` or ```--tags``` argument specifies the tags to apply to the CAD volumes.
  - the ```-c``` or ```--cubit``` argument specifies the path to the Cubit python3 folder
  - the ```-v``` or ```--verbose``` argument enables (true) or disables (false) the printing of additional details

  Multiple STP or SAT files can also be combined and converted into a DAGMC
  geometry. This example combines two STP files into a single geometry with
  separate material tags for each STP file and saves the result as a h5m file.

  ```bash
  cad-to-h5m -i part1.stp part2.stp -o dagmc.h5m -t mat:1 mat:2 -c /opt/Coreform-Cubit-2021.5/bin/
  ```

  It is also possible to convert .sat files in the following way.

  ```bash
  cad-to-h5m -i part1.sat -o dagmc.h5m -t mat:1 -c /opt/Coreform-Cubit-2021.5/bin/
  ``` -->



  The package is available via the PyPi package manager and the recommended
  method of installing is via pip.
  ```bash
  pip install cad_to_h5m
  ```

  In addition [Cubit](https://coreform.com/products/coreform-cubit/) and the
  [Svalinn Plugin](https://github.com/svalinn/Cubit-plugin) needs to be
  installed to make full use of this package.



  Creating a h5m file from a single STP file called ```part1.stp``` and applying
  a material tag to the volume.

  ```python
  from cad_to_h5m import cad_to_h5m

  cad_to_h5m(
      files_with_tags=[{'cad_filename':'part1.stp', 'material_tag':'m1'}],
      h5m_filename='dagmc.h5m',
      cubit_path='/opt/Coreform-Cubit-2021.5/bin/'
  )
  ```

  Creating a h5m file from two STP files called ```part1.stp``` and ```part2.stp```.
  Both parts have distinct material tag applied to them and the result is output
  as a h5m file with the filename dagmc.h5m.

  ```python
  from cad_to_h5m import cad_to_h5m

  cad_to_h5m(
      files_with_tags=[
          {'cad_filename':'part1.stp', 'material_tag':'m1'},
          {'cad_filename':'part2.stp', 'material_tag':'m2'}
      ],
      h5m_filename='dagmc.h5m',
      cubit_path='/opt/Coreform-Cubit-2021.5/bin/'
  )
  ```

  Creating a h5m file from a single SAT is a similar process. Note the .sat file
  extension.

  ```python
  from cad_to_h5m import cad_to_h5m

  cad_to_h5m(
      files_with_tags=[{'cad_filename':'part1.sat', 'material_tag':'m1'}],
      h5m_filename='dagmc.h5m',
      cubit_path='/opt/Coreform-Cubit-2021.5/bin/'
  )
  ```

  Creating a tet mesh files compatible with the OpenMC / DAGMC Unstructured mesh
  format is also possible. Another key called ```tet_mesh``` to the ```files_with_tags``` dictionary will trigger the meshing of that CAD file.
  The value of the key will be passed to the Cubit mesh command as an instruction.
  The following command will produce a ```unstructured_mesh_file.exo```
  file that can then be used in DAGMC compatible neutronics codes. There are examples
  [1](https://docs.openmc.org/en/latest/examples/unstructured-mesh-part-i.html)
  [2](https://docs.openmc.org/en/latest/examples/unstructured-mesh-part-ii.html)
  for the use of unstructured meshes in OpenMC.

  ```python
  from cad_to_h5m import cad_to_h5m

  cad_to_h5m(
      files_with_tags=[
          {
              'cad_filename':'part1.sat',
              'material_tag':'m1',
              'tet_mesh': 'size 0.5'
          }
      ],
      h5m_filename='dagmc.h5m',
      cubit_path='/opt/Coreform-Cubit-2021.5/bin/'
      exo_filename='unstructured_mesh_file.exo'
  )
  ```

  Use if ```exo``` files requires OpenMC to be compiled with LibMesh. OpenMC also
  accepts DAGMC tet meshes made with MOAB which is another option. The following
  example creates a ```cub``` file that contains a mesh. The MOAB tool
  ```mbconvert``` is then used to extract the tet mesh and save it as a ```h5m```
  file which cna be used in OpenMC as shown in the OpenMC [examples](https://docs.openmc.org/en/stable/examples/unstructured-mesh-part-i.html)

  ```python
  from cad_to_h5m import cad_to_h5m

  cad_to_h5m(
      files_with_tags=[
          {
              'cad_filename':'part1.sat',
              'material_tag':'m1',
              'tet_mesh': 'size 0.5'
          }
      ],
      h5m_filename='dagmc.h5m',
      cubit_path='/opt/Coreform-Cubit-2021.5/bin/',
      cubit_filename='unstructured_mesh_file.cub'
  )
  ```
  The ```cub``` file produced contains a tet mesh as well as the faceted geometry.
  The tet mesh can be extracted and converted to another ```h5m``` file for use in
  OpenMC. MOAB is needed to convert the file and includes the command line tool
  ```mbconvert```, MOAB can be installed into a Conda environment with:

  ```
  conda install -c conda-forge moab
  ```
  Then ```mbconvert``` can be used to extract and convert the tet mesh from the
  ```cub``` file into a ```h5m``` file.

  ```bash
  mbconvert unstructured_mesh_file.cub unstructured_mesh_file.h5m
  ```

  Scaling geometry is also possible. This is useful as particle transport codes
  often make use of cm as the default unit. CAD files typically appear in mm as
  the default limit. Some CAD packages ignore units while others make use of them.
  The h5m files are assumed to be in cm by particle transport codes so often it
  is necessary to scale up or down the geometry. This can be done by adding
  another key called ```scale``` and a value to the ```files_with_tags```
  dictionary. This example multiplies the geometry by 10.

  ```python
  from cad_to_h5m import cad_to_h5m

  cad_to_h5m(
      files_with_tags=[
          {
              'cad_filename':'part1.sat',
              'material_tag':'m1',
              'scale': 10
          }
      ],
      h5m_filename='dagmc.h5m',
  )
  ```

  Assigning a material to the implicit complement is also possible. This can be useful on large complex geometries where boolean operations can result in robustness issues. This is implemented by assigning the desired material tag of the implicit complement to the optional ```implicit_complement_material_tag``` argument. Defaults to vacuum.

  ```python
  from cad_to_h5m import cad_to_h5m

  cad_to_h5m(
      files_with_tags=[
          {
              'cad_filename':'part1.sat',
              'material_tag':'m1',
          }
      ],
      h5m_filename='dagmc.h5m',
      implicit_complement_material_tag = 'm2'
  )
  ```


pkgId: ca264f8ad43c5d4335cb3ad7f82e02ba9026a7937b15b64b962f8eb6a2fc968e
name: python-cad-to-shapely
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Import CAD files to Shapely geometry
url: https://github.com/aegis1980/cad_to_shapely
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cad-to-shapely-0.3.2-1.src.rpm
checksum_type: sha256
description:
  convert a CAD file to [shapely](https://pypi.org/project/Shapely/) geometry for downstream processing.
  Currently supports, to varying degrees:

  - DXF using [exdxf](https://pypi.org/project/ezdxf/)
  - (IGES to follow)
  - (SVG to follow)



  Also some utils in utils.py



  To run example in `example.py` you need to install matplotlib `pip install matplotlib`.


pkgId: 0dc8337ba6700ffbafe6dbc1b9efe8c4da2d83d0f3646833636f4d4138a5c21e
name: python-cadctap
arch: src
version: 0.9.11
epoch: 0
release: 1
summary: Client for accessing data at the Canadian Astronomy Data Centre
url: http://www.cadc-ccda.hia-iha.nrc-cnrc.gc.ca/
rpm_license: AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cadctap-0.9.11-1.src.rpm
checksum_type: sha256
description:
  Canadian Astronomy Data Centre - TAP access
  client for interacting with catalog Web services hosted at the Canadian
  Astronomy Data Centre


pkgId: 0d9d91715de274fc5a434cef34ea143bdfd4d9e61ba0f1021220db1ea01d3d18
name: python-caddo-tool
arch: src
version: 0.17.1
epoch: 0
release: 1
summary: Benchmark Tool for CaddoBenchmark Project
url: https://pypi.org/project/caddo-tool/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caddo-tool-0.17.1-1.src.rpm
checksum_type: sha256
description:
  This repository contains files for Caddo Benchmark.





  ```
  user@computer:~$ pip install caddo-tool
  ```


  ```
  user@computer:~$ caddo_tool
  ```



  Yes, check wiki...


pkgId: 1d2033de6a254990040b90a9877dec25b749c06ba792104d9a4bd3f0a28b1611
name: python-caddy-bin
arch: src
version: 2.8.4
epoch: 0
release: 1
summary: A thin wrapper to distribute https://github.com/caddyserver/caddy via pip.
url: https://pypi.org/project/caddy-bin/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caddy-bin-2.8.4-1.src.rpm
checksum_type: sha256
description:
  This project was inspired by how [Maturin packages rust binaries](https://www.maturin.rs/bindings#bin).  The key observation is that in the wheel format, the [distribution-1.0.data/scripts/ directory is copied to bin](https://packaging.python.org/en/latest/specifications/binary-distribution-format/#installing-a-wheel-distribution-1-0-py32-none-any-whl), which means we can leverage this to seamlessly copy binaries into a user's PATH.

  Combined with Python's platform-specific wheels, this allows us to use pip as a "cross-platform package manager" for distributing single-binary CLI applications.

  This is the [list of tools bundled this way](https://github.com/justin-yan/pybin/tree/main/src/pybin), which can be installed with `pip install $TOOLNAME-bin`.



  The core of the logic lies in the `buildlib.py` module.

  - A mapping from download URL (often github releases) to pypi platform tag is required.
  - For each platform:
      - Download the release & extract the binary.
      - Set file permissions and place into scripts directory within wheel archive.
      - Create the METADATA and WHEEL files within wheel archive.
      - Place wheel into `dist/` folder.
  - Once all wheels are constructed, the distribution is uploaded to PyPI.

  CICD is configured to automatically recognize new *PyPI* releases by looking for a diff on the PYPI_VERSION.  When this happens, a build-and-release cycle is performed for that release version.


pkgId: fe8c306051d1d7c71b68206d22d6fc179d8d597e622c35a6e567f982fbfe04e4
name: python-cadence-client
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Python framework for Cadence Workflow Service
url: https://github.com/firdaus/cadence-python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cadence-client-1.0.1-1.src.rpm
checksum_type: sha256
description:
  cadence-python allows you to create Python functions that have their state (local variables etc..) implicitly saved such that if the process/machine fails the state of the function is not lost and can resume from where it left off.

  This programming model is useful whenever you need to ensure that a function runs to completion. For example:

  - Business logic involving multiple micro services
  - CI/CD pipelines
  - Data pipelines
  - RPA
  - ETL
  - Marketing automation / Customer journeys / Customer engagement
  - Zapier/IFTTT like end user automation.
  - Chat bots
  - Multi-step forms
  - Scheduler/Cron jobs

  Behind the scenes, cadence-python uses [Cadence](https://github.com/uber/cadence) as its backend.

  For more information about the fault-oblivious programming model refer to the Cadence documentation [here](https://cadenceworkflow.io/docs/03_concepts/01_workflows)



  ```
  wget https://raw.githubusercontent.com/uber/cadence/master/docker/docker-compose.yml
  docker-compose up
  ```



  ```
  docker run --network=host --rm ubercadence/cli:master --do sample domain register -rd 1
  ```



  ```
  pip install cadence-client==1.0.1
  ```



  ```python
  import sys
  import logging
  from cadence.activity_method import activity_method
  from cadence.workerfactory import WorkerFactory
  from cadence.workflow import workflow_method, Workflow, WorkflowClient

  logging.basicConfig(level=logging.DEBUG)

  TASK_LIST = "HelloActivity-python-tasklist"
  DOMAIN = "sample"



  class GreetingActivities:
      @activity_method(task_list=TASK_LIST, schedule_to_close_timeout_seconds=2)
      def compose_greeting(self, greeting: str, name: str) -> str:
          raise NotImplementedError



  class GreetingActivitiesImpl:
      def compose_greeting(self, greeting: str, name: str):
          return f"{greeting} {name}!"



  class GreetingWorkflow:
      @workflow_method(execution_start_to_close_timeout_seconds=10, task_list=TASK_LIST)
      async def get_greeting(self, name: str) -> str:
          raise NotImplementedError



  class GreetingWorkflowImpl(GreetingWorkflow):

      def __init__(self):
          self.greeting_activities: GreetingActivities = Workflow.new_activity_stub(GreetingActivities)

      async def get_greeting(self, name):
          
          
          
          return await self.greeting_activities.compose_greeting("Hello", name)


  if __name__ == '__main__':
      factory = WorkerFactory("localhost", 7933, DOMAIN)
      worker = factory.new_worker(TASK_LIST)
      worker.register_activities_implementation(GreetingActivitiesImpl(), "GreetingActivities")
      worker.register_workflow_implementation_type(GreetingWorkflowImpl)
      factory.start()

      client = WorkflowClient.new_client(domain=DOMAIN)
      greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
      result = greeting_workflow.get_greeting("Python")
      print(result)

      print("Stopping workers....")
      worker.stop()
      print("Workers stopped...")
      sys.exit(0)
  ```



  cadence-python is still under going heavy development. It should be considered EXPERIMENTAL at the moment. A production
  version is targeted to be released in ~~September of 2019~~ ~~January 2020~~ ~~March 2020~~ April 2020.

  1.0
  - [x] Tchannel implementation
  - [x] Python-friendly wrapper around Cadence's Thrift API
  - [x] Author activities in Python
  - [x] Start workflows (synchronously)
  - [x] Create workflows
  - [x] Workflow execution in coroutines
  - [x] Invoke activities from workflows
  - [x] ActivityCompletionClient heartbeat, complete, complete_exceptionally
  - [x] Activity heartbeat, getHeartbeatDetails and doNotCompleteOnReturn
  - [x] Activity retry
  - [x] Activity getDomain(), getTaskToken(), getWorkflowExecution()
  - [x] Signals
  - [x] Queries
  - [x] Async workflow execution
  - [x] await
  - [x] now (currentTimeMillis)
  - [x] Sleep
  - [x] Loggers
  - [x] newRandom
  - [x] UUID
  - [x] Workflow Versioning
  - [x] WorkflowClient.newWorkflowStub(Class workflowInterface, String workflowId);

  1.1
  - [ ] ActivityStub and Workflow.newUntypedActivityStub
  - [ ] Classes as arguments and return values to/from activity and workflow methods
  - [ ] WorkflowStub and WorkflowClient.newUntypedWorkflowStub
  - [ ] Custom workflow ids through start() and new_workflow_stub()
  - [ ] ContinueAsNew
  - [ ] Compatibility with Java client
  - [ ] Compatibility with Golang client

  2.0
  - [ ] Sticky workflows

  Post 2.0:
  - [ ] sideEffect/mutableSideEffect
  - [ ] Local activity
  - [ ] Parallel activity execution
  - [ ] Timers
  - [ ] Cancellation Scopes
  - [ ] Child Workflows
  - [ ] Explicit activity ids for activity invocations


pkgId: 7cbe8828935f80247d22ae198faea44563b6573222bcb3aa9acb8867624394ea
name: python-cadenza-sdk
arch: src
version: 0.23.1
epoch: 0
release: 1
summary: The official Python library for the cadenza API
url: https://github.com/cyberapper/cadenza-lite-sdk-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cadenza-sdk-0.23.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/cadenza_sdk.svg)](https://pypi.org/project/cadenza_sdk/)

  The Cadenza Python library provides convenient access to the Cadenza REST API from any Python 3.7+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [docs.cadenza.algo724.com](https://docs.cadenza.algo724.com). The full API of this library can be found in [api.md](https://github.com/cyberapper/cadenza-lite-sdk-python/tree/main/api.md).



  ```sh

  pip install cadenza_sdk
  ```



  The full API of this library can be found in [api.md](https://github.com/cyberapper/cadenza-lite-sdk-python/tree/main/api.md).

  ```python
  import os
  from cadenza_sdk import Cadenza

  client = Cadenza(
      
      bearer_token=os.environ.get("CADENZA_CLIENT_SDK_BEARER_TOKEN"),
      
      environment="uat",
  )

  response = client.utility.health()
  ```

  While you can provide a `bearer_token` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `CADENZA_CLIENT_SDK_BEARER_TOKEN="My Bearer Token"` to your `.env` file
  so that your Bearer Token is not stored in source control.



  Simply import `AsyncCadenza` instead of `Cadenza` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from cadenza_sdk import AsyncCadenza

  client = AsyncCadenza(
      
      bearer_token=os.environ.get("CADENZA_CLIENT_SDK_BEARER_TOKEN"),
      
      environment="uat",
  )


  async def main() -> None:
      response = await client.utility.health()


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `cadenza_sdk.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `cadenza_sdk.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `cadenza_sdk.APIError`.

  ```python
  import cadenza_sdk
  from cadenza_sdk import Cadenza

  client = Cadenza()

  try:
      client.utility.health()
  except cadenza_sdk.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except cadenza_sdk.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except cadenza_sdk.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from cadenza_sdk import Cadenza


  client = Cadenza(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).utility.health()
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from cadenza_sdk import Cadenza


  client = Cadenza(
      
      timeout=20.0,
  )


  client = Cadenza(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).utility.health()
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/cyberapper/cadenza-lite-sdk-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `CADENZA_LOG` to `debug`.

  ```shell
  $ export CADENZA_LOG=debug
  ```



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from cadenza_sdk import Cadenza

  client = Cadenza()
  response = client.utility.with_raw_response.health()
  print(response.headers.get('X-My-Header'))

  utility = response.parse()  # get the object that `utility.health()` would have returned
  print(utility)
  ```

  These methods return an [`APIResponse`](https://github.com/cyberapper/cadenza-lite-sdk-python/tree/main/src/cadenza_sdk/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/cyberapper/cadenza-lite-sdk-python/tree/main/src/cadenza_sdk/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.utility.with_streaming_response.health() as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for proxies
  - Custom transports
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  from cadenza_sdk import Cadenza, DefaultHttpxClient

  client = Cadenza(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/cyberapper/cadenza-lite-sdk-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import cadenza_sdk
  print(cadenza_sdk.__version__)
  ```



  Python 3.7 or higher.


pkgId: 28b3a3890de534daf20d1762fe6e936df3db325b05d377c5818de4df2ae46b04
name: python-cadnano2
arch: src
version: 2.4.11
epoch: 0
release: 1
summary: Cadnano2 for PyQt6
url: https://github.com/douglaslab/cadnano2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cadnano2-2.4.11-1.src.rpm
checksum_type: sha256
description:
  [Cadnano](http://cadnano.org/) is computer-aided design software for DNA origami nanostructures. The original citation is [here](https://academic.oup.com/nar/article/37/15/5001/2409858).



  **macOS**
  * Install [homebrew](https://brew.sh/)
  * Install python3: `brew install python3`
  * Create a virtualenv: `python3 -m venv ~/virtualenvs/cn24x`
  * Activate virtualenv: `source ~/virtualenvs/cn24x/bin/activate`
  * Install via pip: `pip3 install cadnano2`

  **Linux**
  * Create a virtual env: `python3 -m venv ~/virtualenvs/cn24x`
  * Activate the venv: `source ~/virtualenvs/cn24x/bin/activate`
  * Install from PyPI: `pip3 install cadnano2`

  **Windows** (tested for Python 3.10.4)
  * Download and install latest [python3](https://www.python.org/downloads/)
  * Use "Manage app execution aliases" to disable launching "App Installer" via any python executables.
  * Add python app folder to your system path, e.g. `C:\Users\shawn\AppData\Local\Programs\Python\Python310\`
  * Add scripts folder to your system path, e.g. `C:\Users\shawn\AppData\Local\Programs\Python\Python310\Scripts\`
  * Open command prompt (cmd.exe) and confirm you can run "python" and "pip".
  * Install Cadnano via pip: `pip install cadnano2`



  **macOS or Linux**
  * Open the Terminal
  * (macOS or Linux) Activate virtual env:
    - `source ~/virtualenvs/cn24x/bin/activate`
  * Run the app: `cadnano2`

  **Windows**
  * Open the Command Prompt
  * Run the app: `cadnano2`

  **macOS alias**
  * Add to `~/.zprofile`: `alias cn2="source ~/virtualenvs/cn24x/bin/activate && cadnano2"`
  * Open new Terminal and run: `cn2`


  * Open the Terminal
  * Activate virtual env: `source ~/virtualenvs/cn24x/bin/activate`
  * Upgrade via pip: `pip install --upgrade cadnano2`




  **Setup a dev environment (Mac or Linux)**

  * Create a virtualenv: `python3 -m venv ~/virtualenvs/cn24dev`
  * Activate virtualenv: `source ~/virtualenvs/cn24dev/bin/activate`
  * Install PyQt6: `pip install pyqt6`
  * Clone repo: `git clone git@github.com:douglaslab/cadnano2.git`
  * Change directory: `cd cadnano2`
  * Make desired code edits
  * Build and install: `python setup.py install`
  * Test: `cadnano2`
  * Repeat previous 3 steps as needed

  **Setup a dev environment (Windows)**

  * Install venv: `pip install virtualenv`
  * Create a virtualenv: `python -m venv virtualenvs\cn24dev` (e.g. in %homepath%)
  * Activate virtualenv: `virtualenvs\cn24dev\Scripts\activate`
  * Install PyQt6: `pip install pyqt6`
  * Clone repo: `git clone git@github.com:douglaslab/cadnano2.git`
  * Change directory: `cd cadnano2`
  * Make desired code edits
  * Build and install: `python setup.py install`
  * Test: `cadnano2`
  * Repeat previous 3 steps as needed


  **Build new dist and upload to PyPi**

  * `pip install build twine` <- install [build](https://pypi.org/project/build/) and [twine](https://pypi.org/project/twine/)
  * `cd /path/to/cadnano2/`
  * `python3 -m build`  creates dist/cadnano2-x.y.z.tar.gz and cadnano2-x.y.z-py3-none-any.whl
  * `python3 -m twine upload dist/cadnano2-x.y.z*`



  This version of Cadnano2 is maintained by the [Douglas Lab](http://bionano.ucsf.edu/). It is derived from [cadnano/cadnano2](https://github.com/cadnano/cadnano2).

  If you wish to use the Cadnano Python API for scripting, see [cadnano2.5](https://github.com/douglaslab/cadnano2.5/).



  This version of Cadnano2 is available under the MIT License. GUI code that uses PyQt6 is GPLv3 as [required](http://pyqt.sourceforge.net/Docs/PyQt6/introduction.html#license) by Riverbank Computing.


pkgId: d44d9e729648c0b0e0a1ba99fa0034c3dd33f0d6a852edd818166e533fe694e1
name: python-cadorchestrator
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://pypi.org/project/cadorchestrator/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cadorchestrator-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  CadOrchestrator helps you create consistent production files and clear assembly documentation for your modular hardware project.

description:
  ![](assets/CadOrchestrator.png)



  CadOrchestrator helps you create consistent production files and clear assembly documentation for your modular hardware project.

  Modular hardware projects seem almost impossible to document. Writing separate assembly documentation and generating images of each assembly step for every possible combination of components seems like an infinite task. Rather than manually generating each permutation, CadOrchestrator will generate consistent documentation for a given configuration. CadOrchestrator provides a simple browser interface to configure the modular hardware, then using your parametric CAD models, assembly render descriptions, and documentation templates it will generate documentation specifically for any custom configuration. Configuration can also be generate from a CLI interface to integrate CadOrchestrator into custom workflows.

  ![](assets/UIexample.png)

  CadOrchestrator is in an early development phase. We are focussing on creating documentation for the nimble. If you are interested in CadOrchestrator, please send us your feedback in an issue.



  This project is funded through [NGI Zero Core](https://nlnet.nl/core), a fund established by [NLnet](https://nlnet.nl) with financial support from the European Commission's [Next Generation Internet](https://ngi.eu) program. Learn more at the [NLnet project page](https://nlnet.nl/project/HardwareManuals).

  [<img src="https://nlnet.nl/logo/banner.png" alt="NLnet foundation logo" width="20%" />](https://nlnet.nl)
  [<img src="https://nlnet.nl/image/logos/NGI0_tag.svg" alt="NGI Zero Logo" width="20%" />](https://nlnet.nl/core)


pkgId: 7732a6d8677a87fefb01cb139eab1db7604113f5fd9c233a3ea6634b67e8fb67
name: python-cadproxdk
arch: src
version: 4.1
epoch: 0
release: 1
summary: A tool to manage Caddy reverse proxy configurations with Cloudflare DNS.
url: https://github.com/yourusername/cadproxdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cadproxdk-4.1-1.src.rpm
checksum_type: sha256
description:
  CADProxy is a tool designed to manage Caddy reverse proxy configurations with Cloudflare DNS. This tool simplifies the process of configuring reverse proxy setups and managing DNS records, utilizing AWS S3 for storing configuration profiles.



  - **Automatic DNS Record Management:** Automatically adds DNS records to Cloudflare.
  - **Caddy Configuration Management:** Updates Caddy configuration with new reverse proxy entries.
  - **AWS S3 Integration:** Stores and retrieves Caddy configuration profiles from S3.
  - **Profile Management:** Easily create and manage different configuration profiles for different domains.



  - Python 3.11 or higher
  - Caddy server
  - Cloudflare API token and zone ID
  - AWS S3 access key and secret key
  - `dig` command-line tool for DNS resolution checks



  You can install CADProxy using pip:

  ```bash
  pip install cadprox
  ```





  Create a `.env` file in the root directory of your project with the following content:

  ```
  S3_ACCESS_KEY=<your_s3_access_key>
  S3_SECRET_KEY=<your_s3_secret_key>
  S3_REGION=<your_s3_region>
  S3_BUCKET=<your_s3_bucket_name>
  S3_CADDY_FILENAME=Caddyfile  # Default filename, can be changed per profile
  ```



  1. **Create a Profile:**

     Run the following command to create a new profile:

     ```bash
     cadprox create <main_domain>
     ```

     You will be prompted to enter the following details:
     - Cloudflare API token
     - Cloudflare Zone ID
     - S3 Caddy filename (optional, defaults to `Caddyfile`)
     - Main domain

     Example:

     ```bash
     cadprox create aiagency.dev
     ```



  1. **Add a New Subdomain:**

     To add a new subdomain and configure the reverse proxy, run:

     ```bash
     cadprox add <subdomain> -p <port>
     ```

     Example:

     ```bash
     cadprox add subdomain.aiagency.dev -p 8080
     ```

     This command performs the following actions:
     - Adds a DNS record for the subdomain in Cloudflare.
     - Waits until the DNS record is resolvable.
     - Downloads the current Caddyfile from the specified S3 bucket.
     - Updates the Caddyfile with the new reverse proxy entry.
     - Uploads the updated Caddyfile back to S3.
     - Reloads the Caddy server with the new configuration.



  1. **Create Profile:**

     - Prompts user for Cloudflare and S3 details.
     - Stores these details in a `caddy_profiles.json` file in the specified S3 bucket.

  2. **Add Subdomain:**

     - Validates input and environment variables.
     - Retrieves external IP of the server.
     - Adds DNS record to Cloudflare.
     - Waits for DNS propagation.
     - Downloads the Caddyfile from S3.
     - Updates the Caddyfile with new reverse proxy settings.
     - Uploads the updated Caddyfile to S3.
     - Reloads the Caddy server.



  CADProxy uses Python's `logging` module for logging information, errors, and debugging messages. Logs are displayed in the console for easy tracking of actions and errors.



  ```bash
  CLOUDFLARE_API_TOKEN: <hidden>
  CLOUDFLARE_ZONE_ID: <hidden>
  S3_CADDY_FILENAME: Caddyfile
  MAIN_DOMAIN: aiagency.dev
  INFO: Downloaded Caddyfile from S3 bucket caddy-configs
  INFO: Successfully added DNS record: subdomain.aiagency.dev -> 192.0.2.1
  INFO: subdomain.aiagency.dev is now resolvable
  INFO: Updated Caddyfile with new entry for subdomain.aiagency.dev
  INFO: Uploaded Caddyfile to S3 bucket caddy-configs
  INFO: Caddy server reloaded successfully
  ```



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



  Contributions are welcome! Please open an issue or submit a pull request on GitHub.



  For any issues, questions, or suggestions, please open an issue on the [GitHub repository](https://github.com/yourusername/cadprox).
  More info [Thriveroute.com](Thriveroute.com).


pkgId: f8add208ba794b9c07c9dba1cbf4786993c885b86c7f2d2ed5cb43a3bb5bd8d1
name: python-cads-api-client
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: CADS API Python client
url: https://pypi.org/project/cads-api-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cads-api-client-1.3.2-1.src.rpm
checksum_type: sha256
description:
  CADS API Python client

  The `ApiClient` needs the `url` to the API root and a valid API `key` to access protected resources.
  You can also set the `CADS_API_URL` and `CADS_API_KEY` environment variables.

  It is possible (but not recommended) to use the API key of one of the test users,
  `00112233-4455-6677-c899-aabbccddeeff`. This is used in anonymous tests and
  it is designed to be the least performant option to access the system.

  Draft Python API:

  ```python
  >>> import cads_api_client
  >>> client = cads_api_client.ApiClient()
  >>> assert client.check_authentication()

  >>> collection = client.collection("reanalysis-era5-pressure-levels")
  >>> collection.end_datetime
  datetime.datetime(...)

  >>> client.retrieve(
  ...     collection_id="reanalysis-era5-pressure-levels",
  ...     product_type="reanalysis",
  ...     variable="temperature",
  ...     year="2022",
  ...     month="01",
  ...     day="01",
  ...     level="1000",
  ...     time="00:00",
  ...     target="tmp1-era5.grib",
  ... )  # blocks
  'tmp1-era5.grib'

  >>> remote = client.submit(
  ...     collection_id="reanalysis-era5-pressure-levels",
  ...     variable="temperature",
  ...     product_type="reanalysis",
  ...     year="2021",
  ...     month="01",
  ...     day="02",
  ...     time="00:00",
  ...     level="1000",
  ... )  # doesn't block
  >>> remote.request_uid
  '...'
  >>> remote.status
  '...'
  >>> remote.download("tmp2-era5.grib")  # blocks
  'tmp2-era5.grib'

  ```



  For best experience create a new conda environment (e.g. DEVELOP) with Python 3.11:

  ```
  conda create -n DEVELOP -c conda-forge python=3.11
  conda activate DEVELOP
  ```

  Before pushing to GitHub, run the following commands:

  1. Update conda environment: `make conda-env-update`
  1. Install this package: `pip install -e .`
  1. Sync with the latest [template](https://github.com/ecmwf-projects/cookiecutter-conda-package) (optional): `make template-update`
  1. Run quality assurance checks: `make qa`
  1. Run tests: `make unit-tests`
  1. Run the static type checker: `make type-check`
  1. Build the documentation (see [Sphinx tutorial](https://www.sphinx-doc.org/en/master/tutorial/)): `make docs-build`



  ```
  Copyright 2022, European Union.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ```

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2022, European Union.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 7ff2a5f1ff44e9d103481b25bde6fae9bb9ec0b0f164c08f964a986c4e4278d7
name: python-cads-api-client
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: CADS API Python client
url: https://pypi.org/project/cads-api-client/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cads-api-client-1.5.2-1.src.rpm
checksum_type: sha256
description:
  CADS API Python client

  Documentation: https://ecmwf-projects.github.io/cads-api-client/

  The `ApiClient` requires the `url` to the API root and a valid API `key`. You can also set the `CADS_API_URL` and `CADS_API_KEY` environment variables, or use a configuration file. The configuration file must be located at `~/.cads-api-client.json`, or at the path specified by the `CADS_API_RC` environment variable.

  ```
  $ cat $HOME/.cads-api-client.json
  {"url": "https://cds.climate.copernicus.eu/api", "key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}
  ```

  It is possible (though not recommended) to use the API key of one of the test users:

  ```
  00112233-4455-6677-c899-aabbccddeeff
  ```

  This key is used for anonymous tests and is designed to be the least performant option for accessing the system.



  Configure the logging level to display INFO messages:

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

  ```

  Instantiate the API client and verify the authentication:

  ```python
  >>> import os
  >>> from cads_api_client import ApiClient
  >>> client = ApiClient(
  ...     url=os.getenv("CADS_API_URL"),
  ...     key=os.getenv("CADS_API_KEY"),
  ... )
  >>> client.check_authentication()
  {...}

  ```

  Explore a collection:

  ```python
  >>> collection_id = "reanalysis-era5-pressure-levels"
  >>> collection = client.get_collection(collection_id)
  >>> collection.end_datetime
  datetime.datetime(...)

  >>> request = {
  ...     "product_type": "reanalysis",
  ...     "variable": "temperature",
  ...     "year": "2022",
  ...     "month": "01",
  ...     "day": "01",
  ...     "pressure_level": "1000",
  ...     "time": "00:00",
  ... }
  >>> collection.process.apply_constraints(**request)
  {...}

  ```

  Retrieve data:

  ```python
  >>> client.retrieve(collection_id, target="tmp1-era5.grib", **request)  # blocks
  'tmp1-era5.grib'

  >>> remote = client.submit(collection_id, **request)  # doesn't block
  >>> remote.request_uid
  '...'
  >>> remote.status
  '...'
  >>> remote.download("tmp2-era5.grib")  # blocks
  'tmp2-era5.grib'

  ```

  Interact with a previously submitted job:

  ```python
  >>> remote = client.get_remote(remote.request_uid)
  >>> remote.delete()
  {...}

  ```



  For best experience create a new conda environment (e.g. DEVELOP) with Python 3.11:

  ```
  conda create -n DEVELOP -c conda-forge python=3.11
  conda activate DEVELOP
  ```

  Before pushing to GitHub, run the following commands:

  1. Update conda environment: `make conda-env-update`
  1. Install this package: `pip install -e .`
  1. Sync with the latest [template](https://github.com/ecmwf-projects/cookiecutter-conda-package) (optional): `make template-update`
  1. Run quality assurance checks: `make qa`
  1. Run tests: `make unit-tests`
  1. Run the static type checker: `make type-check`
  1. Build the documentation (see [Sphinx tutorial](https://www.sphinx-doc.org/en/master/tutorial/)): `make docs-build`



  ```
  Copyright 2022, European Union.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ```

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2022, European Union.  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: bde1374f27221088e5a9d38a5b926077064670c1eb1436600570aeb51c1de1dd
name: python-cadwyn
arch: src
version: 4.4.3
epoch: 0
release: 1
summary: Production-ready community-driven modern Stripe-like API versioning in FastAPI
url: https://pypi.org/project/cadwyn/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cadwyn-4.4.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <a href="https://github.com/zmievsa/cadwyn/actions/workflows/ci.yaml?branch=main&event=push" target="_blank">
      <img src="https://github.com/zmievsa/cadwyn/actions/workflows/ci.yaml/badge.svg?branch=main&event=push" alt="Test">
  </a>
  <a href="https://codecov.io/gh/zmievsa/cadwyn" target="_blank">
      <img src="https://img.shields.io/codecov/c/github/zmievsa/cadwyn?color=%2334D058&logo=codecov" alt="Coverage">
  </a>
  <a href="https://pypi.org/project/cadwyn/" target="_blank">
      <img alt="PyPI" src="https://img.shields.io/pypi/v/cadwyn?color=%2334D058&logo=pypi&label=PyPI package" alt="Package version">
  </a>
  <a href="https://pypi.org/project/cadwyn/" target="_blank">
      <img src="https://img.shields.io/pypi/pyversions/cadwyn?color=%2334D058&logo=python" alt="Supported Python versions">
  </a>
  <a href="https://discord.gg/yRmcWF7rxE" target="_blank">
      <img alt="Discord" src="https://img.shields.io/discord/1183145640407076864?color=%2334D058&logo=discord">
  </a>
  </p>

  Cadwyn allows you to support a single version of your code while auto-generating the schemas and routes for older versions. You keep API versioning encapsulated in small and independent "version change" modules while your business logic stays simple and knows nothing about versioning.
  Its [approach](https://docs.cadwyn.dev/theory/how_we_got_here/#ii-migration-based-response-building) will be useful if you want to:
  1. Support many API versions for a long time
  2. Effortlessly backport features and bugfixes to older API versions
  Whether you are a newbie in API versioning, a pro looking for a sophisticated tool, an experimenter looking to build a similar framework, or even someone who just wants to learn about all approaches to API versioning -- Cadwyn has the functionality, theory, and documentation to cover all the mentioned use cases.

  The [documentation](https://docs.cadwyn.dev) has everything you need to succeed.

  These are our gorgeous sponsors. They are using Cadwyn and are sponsoring it through various means. Contact [me](https://github.com/zmievsa) if you would like to become one too!
  [![Monite](https://docs.cadwyn.dev/img/sponsor_logos/monite.png)](https://docs.monite.com/)


pkgId: 60fada8992a9863ff5b5bdb5ecf0865209f71034f295a0be2d0a2f0d01a37429
name: python-caen-felib
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Official Python binding for the CAEN FELib.
url: https://www.caen.it
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caen-felib-1.3.0-1.src.rpm
checksum_type: sha256
description:
  The official Python binding for the CAEN FELib.


  You need to install both the latest version of CAEN FELib and an implementation like the CAEN Dig2 from [the CAEN website](https://www.caen.it/products/caen-felib-library/).

  Then, install this module and have fun:

      pip install caen-felib


  Few examples may be found on the [`examples`](https://github.com/caenspa/py-caen-felib/tree/master/examples) folder of the project repository.


  Copyright &copy; 2024 CAEN SpA

  The caen-felib module is free software; you can redistribute it and/or
  modify it under the terms of the **GNU Lesser General Public
  License** as published by the Free Software Foundation; either
  version 3 of the License, or (at your option) any later version.

  The caen-felib module is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License along
  with the caen-felib module; if not, see https://www.gnu.org/licenses/.

  The license applies to the caen-felib module source as a whole, though
  individual source files can have a different license which is required to be
  compatible with the GNU Lesser General Public Library, version 3.


  Python API is described on the CAEN FELib library documentation, starting from CAEN FELib v1.2.3.


  Requirements and documentation can be found at https://www.caen.it/products/caen-felib-library/.


  For technical support, go to https://www.caen.it/mycaen/support/ (login and
  MyCAEN+ account required).


pkgId: 4445d54c8efc072f54f0b0477f14edfa2ebf25527afb0243469350e3f59d1e19
name: python-caen-hv-py
arch: src
version: 1.10
epoch: 0
release: 1
summary: Python wrapper for CAEN High Voltage C library.
url: https://github.com/Dyn0402/CAEN_HV_Python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caen-hv-py-1.10-1.src.rpm
checksum_type: sha256
description:
  Python wrapper around C wrapper for CAEN HV crate control, whose manual is included in the git repository.
  Currently only impelements functions for logging into and out of a CAEN HV crate over IP, reading and setting power status, setting HV target values, reading HV monitor values, and reading current monitor values.
  All reads and writes are currently implemented one channel at a time, though the C wrapper supports reading and writing to multiple channels at once.

  The user must specify and pass the crate IP address, username, and password to the CAENHVController initialization.
  It is noted in CAEN C wrapper manual that some models will disconnect if there has been no communication for 15 seconds.

  An example implementation is shown below.

  ```python
  from caen_hv_py.CAENHVController import CAENHVController
  from time import sleep

  ip_address = '192.168.20.20'  # Enter your CAEN HV Crate IP address
  username = 'user'  # Enter your CAEN HV Crate Username
  password = 'pass'  # Enter your CAEN HV Crate Password

  slot = 1
  channels = [0, 1, 2, 3, 4]
  v0s = [50, 100, 150, 200, 250]

  with CAENHVController(ip_address, username, password) as hv_wrapper:
      print('Turning off channels')
      for channel in channels:
          power = hv_wrapper.get_ch_power(slot, channel)
          if power:
              hv_wrapper.set_ch_pw(slot, channel, 0)
          sleep(1)

      sleep(5)

      print('Setting channels V0')
      for channel, v0 in zip(channels, v0s):
          hv_wrapper.set_ch_v0(slot, channel, v0)
          sleep(1)

      sleep(5)

      print('Turning on channels')
      for channel in channels:
          power = hv_wrapper.get_ch_power(slot, channel)
          if not power:
              hv_wrapper.set_ch_pw(slot, channel, 1)
          sleep(1)

      sleep(10)

      print('Getting channel power and Vmon')
      for channel in channels:
          power = hv_wrapper.get_ch_power(slot, channel)
          vmon = hv_wrapper.get_ch_vmon(slot, channel)
          imon = hv_wrapper.get_ch_imon(slot, channel)
          print(f'Channel {channel} power: {power} Vmon: {vmon}, Imon: {imon}')

      sleep(5)

      print('Turning off channels')
      for channel in channels:
          power = hv_wrapper.get_ch_power(slot, channel)
          if power:
              hv_wrapper.set_ch_pw(slot, channel, 0)

  print('Finshed')
  ```

  The predefined functions in the example above are tailored to a specific board.
  A new set of generic functions were added which should allow the user to get and set any parameter by name.
  There are separate functions for each data type. Unsigned short and float are the only two currently implemented.

  NOTE: If the parameter name is incorrect or not found, these functions will simply retrun their error codes.
  For the get functions, the error code is -1. For the set functions, the error code is 0 (success is 1).

  An example of how to use these functions is shown below.

  ```python
  from caen_hv_py.CAENHVController import CAENHVController
  from time import sleep

  ip_address = '192.168.20.20'  # Enter your CAEN HV Crate IP address
  username = 'user'  # Enter your CAEN HV Crate Username
  password = 'pass'  # Enter your CAEN HV Crate Password

  slot = 1
  channel = 2

  with CAENHVController(ip_address, username, password) as hv_wrapper:
      print('Read status')
      status = hv_wrapper.get_ch_param_ushort(slot, channel, 'Status')
      print(f'Status: {status}')

      print('Read "Imax Set" float parameter')
      imax_set = hv_wrapper.get_ch_param_float(slot, channel, 'Imax Set')
      print(f'Imax Set: {imax_set}')

      print('Set "Imax Set" float parameter')
      hv_wrapper.set_ch_param_float(slot, channel, 'Imax Set', 1.2)

  print('Finshed')
  ```


pkgId: 8997ac74655a807e0c5b2aab0a262660e370db4b32abfb5280fdc86c35898a49
name: python-caen-libs
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Official Python binding for CAEN VMELib, CAEN Comm, CAEN PLU and CAEN HV Wrapper libraries.
url: https://www.caen.it
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caen-libs-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Official Python binding for CAEN VMELib, CAEN Comm, CAEN PLU and CAEN HV Wrapper libraries.


  You need to install the latest version of the libraries from [the CAEN website](https://www.caen.it/subfamilies/software-libraries/).

  Then, install this module and have fun:

      pip install caen-libs


  Few examples may be found on the [`examples`](https://github.com/caenspa/py-caen-libs/tree/main/examples) folder of the project repository.


  Copyright &copy; 2024 CAEN SpA

  The caen-libs module is free software; you can redistribute it and/or
  modify it under the terms of the **GNU Lesser General Public
  License** as published by the Free Software Foundation; either
  version 3 of the License, or (at your option) any later version.

  The caen-libs module is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License along
  with the caen-libs module; if not, see https://www.gnu.org/licenses/.

  The license applies to the caen-libs module source as a whole, though
  individual source files can have a different license which is required to be
  compatible with the GNU Lesser General Public Library, version 3.


  Requirements and documentation can be found at https://www.caen.it/subfamilies/software-libraries/.


  For technical support, go to https://www.caen.it/mycaen/support/ (login and
  MyCAEN+ account required).


pkgId: bd0a46db5d2ae6ec7953bd5cfddfa22c84660f2ef2a361875ee5c0444b35ba17
name: python-caep
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Config Argument Env Parser (CAEP)
url: https://github.com/mnemonic-no/caep
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caep-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Configuration library that supports loading configuration from ini, environment variables
  and arguments into a [pydantic](https://docs.pydantic.dev/) schema.

  With the pydantic schema you will have a fully typed configuration object that is parsed
  at load time.





  Support list/set/dict defaults, so you can now do:

  ```python
  intlist: List[int] = Field([0,1,2], description="List of ints")
  ```

  The previous way to defined defaults using strings are still supported, but will fail type checking with the pydantic mypy plugin, and will be removed in a later version:

  ```python
  intlist: List[int] = Field("0,1,2", description="List of ints")
  ```



  Support for pydantic 2.x. It is advised to migrate models with these changes:



  Pydantic has builtin support for size of list, dictionaries and sets using `min_length` so you should change
  ```python
  intlist: List[int] = Field(description="Space separated list of ints", min_size=1)
  ```

  to

  ```python
  intlist: List[int] = Field(description="Space separated list of ints", min_length=1)
  ```



  Do not use `split` and `kv_split` directly on the field, but put them in a dictionary `json_schema_extra`. E.g. change

  ```python
  intlist: List[int] = Field(description="Space separated list of ints", split=" ")
  ```

  to

  ```python
  intlist: List[int] = Field(
      description="Space separated list of ints", json_schema_extra={"split": " "}
  )
  ```

  and change

  ```python
  dict_int: Dict[str, int] = Field(
      description="Int Dict split by slash and dash", split="-", kv_split="/"
  )
  ```

  to

  ```python
  dict_int: Dict[str, int] = Field(
      description="Int Dict split by slash and dash",
      json_schema_extra={"split": "-", "kv_split": "/"},
  )
  ```



  `root_validator` are stil supported, but it is advised to migrate to `model_validator`. Example using helper function `raise_if_some_and_not_all`:


  ```python
      @model_validator(mode="after")  # type: ignore
      def check_arguments(cls, m: "ExampleConfig") -> "ExampleConfig":
          """If one argument is set, they should all be set"""

          caep.raise_if_some_and_not_all(
              m.__dict__, ["username", "password", "parent_id"]
          )

          return m
  ```



  ```python

  from typing import List

  from pydantic import BaseModel, Field

  import caep


  class Config(BaseModel):

      text: str = Field(description="Required String Argument")
      number: int = Field(default=1, description="Integer with default value")
      switch: bool = Field(description="Boolean with default value")
      intlist: List[int] = Field(description="Space separated list of ints", json_schema_extra={"split": " "})




  config = caep.load(
      Config,
      "CAEP Example",
      "caep",  # Find .ini file under ~/.config/caep
      "caep.ini",  # Find .ini file name caep.ini
      "section",  # Load settings from [section] (default to [DEFAULT]
  )

  print(config)
  ```

  Sample output with a `intlist` read from environment and `switch` from command line:

  ```bash
  $ export INTLIST="1 2 3"
  $ ./example.py --text "My value" --switch
  text='My value' number=1 switch=True intlist=[1, 2, 3]
  ```



  Specifying configuration location, name and section is optional and can be skipped if you
  do not want to support loading ini files from `$XDG_CONFIG_HOME`:

  ```python

  config = caep.load(
      Config,
      "CAEP Example",
  )
  ```

  With the code above you can still specify a ini file with `--config <ini-file>`, and use
  environment variables and command line arguments.



  Pydantic fields should be defined using `Field` and include the `description` parameter
  to specify help text for the commandline.

  Unless the `Field` has a `default` value, it is a required field that needs to be
  specified in the environment, configuration file or on the command line.

  Many of the types described in [https://docs.pydantic.dev/usage/types/](https://docs.pydantic.dev/usage/types/)
  should be supported, but not all of them are tested. However,  nested schemas
  are *not* supported.

  Tested types:



  Standard string argument.



  Values parsed as integer.



  Value parsed as float.



  Value parsed as Path.



  Values parsed and validated as IPv4Address.



  Values parsed and validated as IPv4Network.



  Value parsed as booleans. Booleans will default to False, if no default value is set.
  Examples:


  | Field                                                      | Input     | Configuration |
  | -                                                          | -         | -             |
  | `enable: bool = Field(description="Enable")`               | <NOT SET> | False         |
  | `enable: bool = Field(value=False, description="Enable")`  | `yes`     | True          |
  | `enable: bool = Field(value=False, description="Enable")`  | `true`    | True          |
  | `disable: bool = Field(value=True, description="Disable")` | <NOT SET> | True          |
  | `disable: bool = Field(value=True, description="Disable")` | `yes`     | False         |
  | `disable: bool = Field(value=True, description="Disable")` | `true`    | False         |



  List of strings, split by specified character (default = comma, argument=`split`).

  Some examples:

  | Field                                                                     | Input   | Configuration |
  | -                                                                         | -       | -             |
  | `List[int] = Field(description="Ints", json_schema_extra={"split": " "})` | `1 2`   | [1, 2]        |
  | `List[str] = Field(description="Strs")`                                   | `ab,bc` | ["ab", "bc"]  |

  The argument `min_length` (pydantic builtin) can be used to specify the minimum size of the list:

  | Field                                                 | Input | Configuration          |
  | -                                                     | -     | -                      |
  | `List[str] = Field(description="Strs", min_length=1)` | ``    | Raises ValidationError |



  Set, split by specified character (default = comma, argument=`split`).

  Some examples:

  | Field                                                                    | Input      | Configuration |
  | -                                                                        | -          | -             |
  | `Set[int] = Field(description="Ints", json_schema_extra={"split": " "})` | `1 2 2`    | {1, 2}        |
  | `Set[str] = Field(description="Strs")`                                   | `ab,ab,xy` | {"ab", "xy"}  |

  The argument `min_length` can be used to specify the minimum size of the set:

  | Field                                                | Input | Configuration          |
  | -                                                    | -     | -                      |
  | `Set[str] = Field(description="Strs", min_length=1)` | ``    | Raises ValidationError |




  Dictioray of strings, split by specified character (default = comma, argument=`split` for
  splitting items and colon for splitting key/value).

  Some examples:

  | Field                                                | Input                | Configuration            |
  | -                                                    | -                    | -                        |
  | `Dict[str, str] = Field(description="Dict")`         | `x:a,y:b`            | {"x": "a", "y": "b"}     |
  | `Dict[str, int] = Field(description="Dict of ints")` | `a b c:1, d e f:2`   | {"a b c": 1, "d e f": 2} |

  The argument `min_length` can be used to specify the minimum numer of keys in the dictionary:

  | Field                                                      | Input | Configuration          |
  | -                                                          | -     | -                      |
  | `Dict[str, str] = Field(description="Strs", min_length=1)` | ``    | Raises ValidationError |




  Arguments are parsed in two phases. First, it will look for the optional argument `--config`
  which can be used to specify an alternative location for the ini file. If not `--config` argument
  is given it will look for an optional ini file in the following locations
  (`~/.config has presedence`) *if* `config_id` and `config_name` is specified:

  - `~/.config/<CONFIG_ID>/<CONFIG_FILE_NAME>` (or directory specified by `$XDG_CONFIG_HOME`)
  - `/etc/<CONFIG_FILE_NAME>`

  The ini file can contain a `[DEFAULT]` section that will be used for all configurations.
  In addition it can have a section that corresponds with `<SECTION_NAME>` (if specified) that for
  specific configuration, that will over override config from `[DEFAULT]`



  The configuration step will also look for environment variables in uppercase and
  with `-` replaced with `_`. For the example below it will lookup the following environment
  variables:

  - $NUMBER
  - $BOOL
  - $STR_ARG

  The configuration presedence are (from lowest to highest):
  * argparse default
  * ini file
  * environment variable
  * command line argument






  Helper functions to use [XDG Base Directories](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html) are included in `caep.xdg`:

  It will look up `XDG` environment variables like `$XDG_CONFIG_HOME` and use
  defaults if not specified.



  Generic function to get a `XDG` directory.

  The following example with will return a path object to ~/.config/myprog
  (if `$XDG_CONFIG_HOME` is not set) and create the directoy if it does not
  exist.

  ```python
  get_xdg_dir("myprog", "XDG_CONFIG_HOME", ".config", True)
  ```



  Shortcut for `get_xdg_dir("CONFIG")`.



  Shortcut for `get_xdg_dir("CACHE")`.



  Prior to version `0.1.0` the recommend usage was to add parser objects manually. This is
  still supported, but with this approach you will not get the validation from pydantic:

  ```python
  >>> import caep
  >>> import argparse
  >>> parser = argparse.ArgumentParser("test argparse")
  >>> parser.add_argument('--number', type=int, default=1)
  >>> parser.add_argument('--bool', action='store_true')
  >>> parser.add_argument('--str-arg')
  >>> args = caep.config.handle_args(parser, <CONFIG_ID>, <CONFIG_FILE_NAME>, <SECTION_NAME>)
  ```




  Raise ArgumentError if some of the specified entries in the dictionary has non
  false values but not all

  ```python
  class ExampleConfig(BaseModel):
      username: Optional[str] = Field(description="Username")
      password: Optional[str] = Field(description="Password")
      parent_id: Optional[str] = Field(description="Parent ID")

      @model_validator(mode="after")  # type: ignore
      def check_arguments(cls, m: "ExampleConfig") -> "ExampleConfig":
          """If one argument is set, they should all be set"""

          caep.raise_if_some_and_not_all(
              m.__dict__, ["username", "password", "parent_id"]
          )

          return m
  ```


     Return first external module that called this function, directly, or indirectly


pkgId: 655b1afba781bd79e57a2451e9a57e70890db7c6322796516322b398ae167e74
name: python-caerp-celery
arch: src
version: 2024.2.4
epoch: 0
release: 1
summary: caerp_celery
url: https://framagit.org/caerp/caerp_celery
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caerp-celery-2024.2.4-1.src.rpm
checksum_type: sha256
description:
  Since version 6, caerp-celery only supports python 3.
  Asynchronous tasks are executed through celery.
  pyramid_celery is used to integrate celery with the Pyramid related stuff.
  pyramid_beaker is used to cache responses.
  tasks:
      Asynchronous tasks called from CAErp
  scheduler:
      Beat tasks, repeated along the time (like cron tasks)


pkgId: 6207caea3b01c8530fd8bda3e6c7b64cf4be8d6f4ff4138c3f74eb5dd7b7441c
name: python-caerp-payment
arch: src
version: 2024.0.10
epoch: 0
release: 1
summary: caerp_payment
url: https://framagit.org/caerp/caerp_payment
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caerp-payment-2024.0.10-1.src.rpm
checksum_type: sha256
description:
  NB : À parir de la version 2.0, cette librairie ne supporte plus python 2
  Cette librairie a pour objectif de fournir un ensemble cohérent pour la gestion
  des encaissements, ce afin de répondre aux exigences de la loi de finance 2018.
  Le texte suivant `http://bofip.impots.gouv.fr/bofip/10691-PGP` décrit plus en
  détail le besoin à couvrir
  Elle fonctionne comme suit :
  - Les opérations d'encaissement sont effectuées au travers d'une API publique
  - Pour chaque opération d'encaissement, une entrée est écrite dans le journal
  Le journal est le garant de l'intégrité des opérations d'encaissement.


pkgId: ed66c91713c0de667bf559bc96c186372d6b4f23cbd123b785564fde9317432b
name: python-caerus
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Python package caerus
url: https://erdogant.github.io/caerus
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caerus-0.1.10-1.src.rpm
checksum_type: sha256
description:
  [![Python](https://img.shields.io/pypi/pyversions/caerus)](https://img.shields.io/pypi/pyversions/caerus)
  [![PyPI Version](https://img.shields.io/pypi/v/caerus)](https://pypi.org/project/caerus/)
  [![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/erdogant/caerus/blob/master/LICENSE)
  [![Downloads](https://pepy.tech/badge/caerus)](https://pepy.tech/project/caerus)
  [![Downloads](https://pepy.tech/badge/caerus/month)](https://pepy.tech/project/caerus/month)
  [![Sphinx](https://img.shields.io/badge/Sphinx-Docs-Green)](https://erdogant.github.io/caerus/)
  <!---[![BuyMeCoffee](https://img.shields.io/badge/buymea-coffee-yellow.svg)](https://www.buymeacoffee.com/erdogant)-->
  <!---[![Coffee](https://img.shields.io/badge/coffee-black-grey.svg)](https://erdogant.github.io/donate/?currency=USD&amount=5)-->

  ``caerus`` is Python package to compute the local-minima with the corresponding local-maxima within the given time-frame. This approach is designed to for stock-market valley and peak detection.

  Here are just a few of the things that caerus does well:
      - Ouput contains detected start-stop regions of local minima and maxima.
      - Figures are created.
      - Parameter gridsearch.
      - Designed for the detection of complex trend movements.


  **⭐️ Star this repo if you like it ⭐️**




  ```bash
  pip install caerus
  ```



  ```python
  from caerus import caerus
  ```





  On the [documentation pages](https://erdogant.github.io/caerus/) you can find detailed information about the working of the ``caerus`` with examples.

  <hr>





  * [Example: Detect peak and valleys in Bitcoin](https://erdogant.github.io/caerus/pages/html/Examples.html)

  <p align="left">
    <a href="https://erdogant.github.io/caerus/pages/html/Examples.html">
    <img src="https://github.com/erdogant/caerus/blob/master/docs/figs/figure_btc.png" width="600" />
    <img src="https://github.com/erdogant/caerus/blob/master/docs/figs/figure_btc_last_300days.png" width="600" />
    </a>
  </p>




  * [Example: Detect peak and valleys in Facebook](https://erdogant.github.io/caerus/pages/html/Examples.html)

  <p align="left">
    <a href="https://erdogant.github.io/caerus/pages/html/Examples.html">
    <img src="https://github.com/erdogant/caerus/blob/master/docs/figs/figure_fb.png" width="600" />
    </a>
  </p>


  * [Example: Gridsearch](https://erdogant.github.io/caerus/pages/html/Examples.html#gridsearch)

  <p align="left">
    <a href="https://erdogant.github.io/caerus/pages/html/Examples.html#gridsearch">
    <img src="https://github.com/erdogant/caerus/blob/master/docs/figs/figure_gridsearch_btc.png" width="600" />
    </a>
  </p>


  <hr>




  This project needs some love! ❤️

  Contribute to this project by feature requests, idea discussions, reporting bugs, opening pull requests, or through Github Sponsors. Your help is highly appreciated.

  * If you wish to buy me a <a href="https://www.buymeacoffee.com/erdogant">Coffee</a> for this work, it is very appreciated :)

  [![Github Sponsors](https://img.shields.io/github/sponsors/erdogant?label=github%20sponsors&logo=github%20sponsors&style=for-the-badge)](https://github.com/sponsors/erdogant)


  * Erdogan Taskesen, github: [erdogant](https://github.com/erdogant)


pkgId: 804adea461dcd28702e24f54f33c4089e0cb6cb9fbf9be03ee050e55314cda98
name: python-cafeteria-asyncio
arch: src
version: 0.3.0
epoch: 0
release: 1
url: https://github.com/abn/cafeteria-asyncio
rpm_license: APLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cafeteria-asyncio-0.3.0-1.src.rpm
checksum_type: sha256
summary:
  An extension to the cafeteria package to enable asyncio specific patterns for python 3.7 and above applications/libraries.

description:
  [![](https://github.com/abn/cafeteria-asyncio/workflows/Test%20Suite/badge.svg)](https://github.com/abn/cafeteria-asyncio/actions?query=workflow%3A%22Test+Suite%22)
  [![image](https://img.shields.io/pypi/v/cafeteria-asyncio.svg)](https://pypi.org/project/cafeteria-asyncio/)
  [![image](https://img.shields.io/pypi/l/cafeteria-asyncio.svg)](https://pypi.org/project/cafeteria-asyncio/)
  [![image](https://img.shields.io/pypi/pyversions/cafeteria-asyncio.svg)](https://pypi.org/project/cafeteria-asyncio/)
  [![image](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  [![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=abn/cafeteria-asyncio)](https://dependabot.com)


  An extension to the cafeteria package to enable asyncio specific patterns for python 3.7 and above applications/libraries.


  `pip install cafeteria-asyncio`


pkgId: 8980397a00364f0c6441e3217ad48df5a7bd3b8efb2c5842ff12489672f96e29
name: python-caffeine-ng
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: Tray bar app to temporarily inhibit screensaver and sleep mode.
url: https://codeberg.org/WhyNotHugo/caffeine-ng
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caffeine-ng-4.0.2-1.src.rpm
checksum_type: sha256
description:
  Caffeine is a little daemon that sits in your systray, and prevents the
  screensaver from showing up, or the system from going to sleep. It does so when
  an application is fullscreened (eg: youtube), or when you click on the systray
  icon (which you can do, when, eg: reading).


pkgId: f7e7c313e7f29aec9db5430869a9d642e2866a62dafe5a9bb3cce1241244cb41
name: python-caffoa
arch: src
version: 0.37.0
epoch: 0
release: 1
summary: Create Azure Functions From Open Api (for C#)
url: https://github.com/claasd/caffoa
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caffoa-0.37.0-1.src.rpm
checksum_type: sha256
description:
  This tool was superseeded by [caffoa.net](https://github.com/claasd/caffoa.net).
  Use caffoa.net as nuget tool to create your open api files.




  [![PyPI - License](https://img.shields.io/pypi/l/caffoa)](https://pypi.org/project/caffoa/)
  [![PyPI](https://img.shields.io/pypi/v/caffoa)](https://pypi.org/project/caffoa/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/caffoa)

  Tool to autogenerate azure function templates for .NET from openapi declaration.
  Instead of generating stubs, the goal is to be able to change the api and re-generate the files without overwriting your code.

  Currently considered alpha state. If something does not work that you feel should work, create a ticket with your openapi spec.

  It uses [prance](https://pypi.org/project/prance/) for parsing the openapi spec.



  As code generation needs a lot of configuration, all configuration is done using a config file in yaml format.

  The minimal config file is as follows:
  ```yaml
  config:
    version: 2
  services:
    - apiPath: my-service.openapi.yml
      function:
        name: MyClassName
        namespace: MyNamespace
        targetFolder: ./output
      model:
        namespace: MyNamespace.Model
        targetFolder: ./output/Model
  ```
  You can add multiple services. Also, you can omit either `model` or `function` if you do not need one of them.
  Then, call the tool:

  ```bash
  python3 -m caffoa --config path_to_config.yml
  ```



  If you specified the `function` part in the config file,
  the tool will create two files in the specified target folder:
  * MyClassNameFunction.generated.cs
  * IMyClassNameService.generated.cs

  Your job now is to create an implementation for the `IMyClassNameService` interface.

  Furthermore, you need [Dependency Injection](https://docs.microsoft.com/en-us/azure/azure-functions/functions-dotnet-dependency-injection) to pass your implementation to the constructor of the function.

  Now implement all the logic in your implementation of the interface. You can now change your API, and regenerate the generated files without overwriting your code.



  If you specified the `model` part in the config file, the tool will generate a file for each schema defined in the components section of the openapi definition. The filename will be the schema name converted to UpperCamelCase with generated.cs added to the end (Example: `user`will create a class `User` defined in the file `User.generated.cs`).
  The file will contain a shared class, with all properties of the schema. You can implement a shared class in a different file to add logic to these objects.


  * The schema must be defined in the components section.
  * Furthermore, schemas may not be nested without reference.
  (You can easily overcome this restriction by defining more schemas in the components section and have them reference each other.)
  * allOf is implemented as inheritance, and therefore can only handle allOf with one reference and one direct configuration


  There are multiple optional configuration options that you can use:
  ```yaml
  config:
    clearGeneratedFiles: true # default is false, removes all files below the working directory, that end in .generated.cs
    version: 2 # 1 (legacy, default), 2 (current), 3 (experimental)
    useFactory: false # version 2+ if set to true, a factory interface is created additionally to the Service interface. Useful if you need to have different behaviors based on headers.
    prefix: "Pre" # A prefix that is added to all model classes
    suffix: "Suf" # A suffix that is added to all model classes
    errorFolder: ./output/errors # version 3+ only. Folder where ClientError Exceptions are generated
    errorNamespace: MyErrorNamespace # # version 3+ only. Namespace for  ClientError Exceptions are generated
    imports: # a list of imports that will be added to most generated classes
      - MySpecialNamespace

  services:
    - apiPath: userservice.openapi.yml
      config:
        prefix:  # overrides the config element from the global config
        suffix:  # overrides the config element from the global config
        useFactory:  # overrides the config element from the global config
        errorFolder:  # overrides the config element from the global config
        errorNamespace:  # overrides the config element from the global config
        imports: # overrides the imports from the global config
      function:
        name: MyClassName
        namespace: MyNamespace
        targetFolder: ./output
        functionsName: MyFunctions # name of the functions class. defaults to {name}Functions
        interfaceName: IMyInterface # name of the interface class. defaults to I{name}Service.
        interfaceNamespace: MyInterfaceNamespace # defaults to 'namespace'. If given, the interface uses this namespace
        interfaceTargetFolder: ./output/shared # defaults to 'targetFolder'. If given, the interface is written to this folder

        
        
        
        
        boilerplate: |
          try {
              {BASE}
          catch(SomethingNotFoundException e) {
            return new HttpResponseMessage(HttpStatusCode.NotFound)
            {
                Content = new StringContent(err.Message)
            };
          }

        
        imports: # overrides the imports from the config section
          - MyNamespace.Exceptions.SomethingNotFoundException
      model:
        namespace: MyNamespace.Model
        targetFolder: ./output/Model
        
        excludes:
         - objectToExclude
        
        include:
          - objectToInclude
          - otherObjectToInclude
        imports: # overrides the imports from the global config
          - someImport
        prefix: # (Deprecated for version 3+) override prefix from the config section
        suffix: # (Deprecated for version 3+) override suffix from the config section
  ```


  If you have a well specified openapi doc, use only json request bodies and returns, and you want strict rules what you get to work with and what you return, you can try out version 3.

  Version 3 parses the return and requestBody specifications, and handles the object wrapping for you.
  * Request bodies that have well-defined schemas will be deserialized to the object
  * Responses that have well-defined schemas will be serialized to Json responses
  * The interface will not have IActionResult returns, but need to return the actual object for the method
  * The interface will have the actual type that was passed along in the body as parameter
  * Errors (400-499) will be implemented as Exceptions, that you can throw in your implementation.
  * If you return a JSON Object with your Errors, a derived class will be created for that
  * If you have different return codes for one object (e.g. 200 or 201 for a put request), the return of the interface will be (YourObject, int).

  Version 3 takes over a lot of boilerplate code for you. Furthermore, it forces you to not cut corners, as you cannot return a different object than the specification calls for.


pkgId: c71ecefabb7c13a72c287e081863f8062a4cf03b41f7799eb9f7352b6afca8fc
name: python-cafle
arch: src
version: 0.3.8
epoch: 0
release: 1
summary: a cash flow estimating tool
url: https://github.com/kphong16
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cafle-0.3.8-1.src.rpm
checksum_type: sha256
description:
  cafle은 기존 대부분 엑셀로 작업하던 재무모델(현금흐름추정 모델)을 python으로 작업할 수 있도록 도와 주는 python 패키지 입니다. cafle에는 index, account, write 모듈이 있습니다.

  account 모듈은 각각 개별 현금흐름의 내용을 저장하고, 현금흐름의 유출입을 관리하는 모듈이며, index모듈은 날짜 등 현금흐름의 시간적인 요소를 컨트롤하기 위한 모듈입니다.
  write 모듈은 최종적으로 작성된 현금흐름을 엑셀 파일 상에 출력해주는 모듈 입니다.

  매출, 사업비, 자금의 조달, 운영계좌 등 재무모델에 반영되는 각각의 요소들을 각각 하나의 account로 설정한 후 index에서 표현되는 시간 흐름에 따라 각각의 요소들간 사업 진행에 따라 발생되는 현금흐름의 유출입을 account 내에 기록합니다.
  account 내에 기록된 현금흐름들은 최종 모델링 후 개별적으로 확인이 가능합니다.

  구체적으로 얘기하자면,,, 자금의 조달, 매출 등 각각의 요소들 별로 사업적인 반응 조건들을 account에 설정합니다.
  자금의 조달의 경우 조달 금액, 시점, 금리, 각종 수수료와 시점 및 상황 별로 취해지는 액션들을 자금조달 account에 설정합니다.
  매출의 경우 매출의 발생 시점 및 금액 등 주요 가정들을 매출 account에 설정합니다.
  사업비, 운영계좌 등도 각각의 account에 필요한 조건 및 액션들을 설정합니다.
  이후 통합적으로 index의 흐름에 따라 account들 끼리 서로 현금흐름을 설정된 사항에 맞춰 주고 받도록 합니다.
  최종 모델링이 끝나면, 최종 작업 완료된 account에서 현금흐름 내역을 확인할 수 있습니다.


  금융회사에서 부동산개발금융(Project Financing) 분야에 10여년 가까이 종사해 오면서 투자 의사 결정을 위해 많은 재무모델을 직접 다뤄왔습니다.
  엑셀로 만든 재무모델은 그 자체로 투자 업무를 담당하는 사람들에게는 하나의 언어로서의 역할을 합니다.
  모델 작성에는 많은 시간과 노력을 소요하게 되는데, 다양한 영역의 투자 건들을 수시로 다뤄야 하는 입장에서는 모델 작성 및 관리에 소요되는 시간이 아쉬울 수 밖에 없습니다.

  python과 같은 프로그래밍 언어로 재무모델을 작성하게 되면 주요한 모델의 영역들을 모듈화 시켜서 미리 작성된 모듈들을 서로 갖다 붙이기만 하는 방식으로 모델을 작성하고 관리할 수 있습니다.
  충분히 모듈화가 된다면, 각각의 사업영역 및 사업구도에 맞춰서 레고 블록을 맞추듯 재무모델 작성이 가능합니다.
  cafle 패키지는 이러한 모듈화의 첫 시도입니다.


  tests-FS_model_sample2 폴더의 Example.xlsx 파일은 패키지를 이용하여 작성된 간단한 재무모델의 작성결과 샘플 입니다.
  해당 폴더의 cashflow.py는 사업기간 전반 동안 최초 자금의 인출에서 부터 사업비 지출, 외부조달 자금의 상환 까지 현금흐름을 전반적으로 컨트롤하고 있습니다.
  현재 올려진 샘플은 간단한 형태의 개발사업을 모델링 한 것이지만, 사업 및 자금조달의 구도가 복잡해지더라도 python으로 구현이 가능하며, 복잡해질 수록 엑셀 보다는 python으로 구현하는 것이 향후 관리 측면에서 유리합니다.


  회사일로 바빠서 틈틈이 작업해온 것인데, 이제야 누군가 남에게 보여줄 만한 수준이 된 것 같습니다.
  향후 임의로 수정될 수 있으며, 혹시 상기 취지에 관심 있는 분이 있다면 연락주시면 반갑겠습니다.


pkgId: 1e6355a5fc01424fecffadb0277e236ef48ec8ad0a029bcbdb1acb2a0f09723f
name: python-cagen
arch: src
version: 0.1.0.post3
epoch: 0
release: 1
summary: A static site generator for cmpalgorithms project
url: https://sr.ht/~somenxavierb/cagen/
rpm_license: GNU General Public License v2 (GPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cagen-0.1.0.post3-1.src.rpm
checksum_type: sha256
description:
  <!--
  SPDX-FileCopyrightText: 2023 Xavier Bordoy <somenxavier@posteo.net>

  SPDX-License-Identifier: GPL-2.0-only
  -->





  cagen is a static site generator intented for [cmpalgorithms project](https://sr.ht/~somenxavierb/cmpalgorithms/). So it's very rare you are interested in that. Although you can use it as any other static site generator.



  The software is distributed under [GPL 2-only license](https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt).



  It assumes your documents are written with markdown syntax. It is capable of convert those documents to any other format, using [pandoc](https://pandoc.org/) (specifically [pypandoc](https://github.com/JessicaTegner/pypandoc) wrapper) and [Mako templating system](https://www.makotemplates.org/).

  The reason to use "external" templating system instead of built-in pandoc template system is because pandoc templates [are not capable of make conditions with values](https://pandoc.org/MANUAL.html#conditionals) (something like `$if(author=='me') Print full name here $endif$`).

  The program just converts markdown files to HTML ones by default in the same directory. Unlike many other static site generators, there is no predefined structure by default: no `assets` directory neither `site` directory. By default, all generated files are in the same directory than the source files. Obviously, you can modify it if you want.

  We provide:

  - a [library](https://git.sr.ht/~somenxavierb/cagen/tree/main/item/src/cagen/libcagen.py)
  - a command line program (called `cagen`) for convert documents
  - a script called `cagen-make` to generate a Makefile to convert automatically all markdown files to HTML ones.

  The software is implemented in [python](https://www.python.org/) because it's easy to program (I'm very language-neutral). If you want some really fast static site generator, be free to fork the project and program with any compiled language.



  You can install via [pip](https://pypi.org/project/cagen/):
  ```
  pip install cagen
  ```

  If you are running ArchLinux or any Arch derivative ditribution, you can use this [PKGBUILD](https://git.sr.ht/~somenxavierb/cagen/tree/main/item/extras/PKGBUILD) to make a pacman package.



  Basic use is:
  ```
  cagen sourcefile.md generatedfile.html template.tmpl
  ```
  where

  - `sourcefile.md` is Markdown file
  - `generatedfile.html` is the HTML5 file
  - `template.tmpl` is Mako template file

  See `cagen --help` for more options.

  This tool is some kind of low-level tool. If you want some more higher-level one to automatically converts all markdown files to corresponding HTML5 files, we provide the `cagen-make` script (see above). The steps are:
  ```
  cagen-make --init
  ```

  It creates `Makefile`

  ```
  make
  ```

  It automatically convert all markdown files to HTML5 ones using `templates/schema.tmpl` Mako template. You can modify it editing `Makefile`.



  - You can see the [issue tracker](https://todo.sr.ht/~somenxavierb/cagen-tasks) and contribute if you want suggesting new features or reporting a bug.
  - The [API documentation](https://somenxavierb.srht.site/cagen/) is available.
  - The [Mailing List](https://lists.sr.ht/~somenxavierb/cagen-list) to make a question, suggest something you want, send patches, etc. As user and developer.


pkgId: 906fcfb2be17296ef9fa1820badd9e68348615f316ab7457e300bf7bc5df6ffc
name: python-cai-causal-graph
arch: src
version: 0.5.6
epoch: 0
release: 1
summary: A Causal AI package for causal graphs.
url: https://causalgraph.causalens.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cai-causal-graph-0.5.6-1.src.rpm
checksum_type: sha256
description:
  ![causaLens logo](https://github.com/causalens/cai-causal-graph/blob/main/cl-logo.png?raw=true)


  Documentation, including a quickstart and code reference docs, can be found [here](https://causalgraph.causalens.com/).

  [![PyPI version](https://img.shields.io/pypi/v/cai-causal-graph.svg?color=informational)](https://pypi.org/project/cai-causal-graph/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cai-causal-graph.svg?color=informational)](https://pypi.org/project/cai-causal-graph/)
  [![LICENSE](https://img.shields.io/badge/License-Apache_2.0-informational.svg)](https://www.apache.org/licenses/LICENSE-2.0)

  ![TEST](https://github.com/causalens/cai-causal-graph/workflows/MAIN-CHECKS/badge.svg?branch=main)
  ![DEPENDENCIES](https://github.com/causalens/cai-causal-graph/workflows/DEPENDENCIES-CHECKS/badge.svg?branch=main)
  ![RELEASE](https://github.com/causalens/cai-causal-graph/workflows/RELEASE/badge.svg)
  ![POST-RELEASE](https://github.com/causalens/cai-causal-graph/workflows/POST-RELEASE/badge.svg?branch=main)

  [![LINTING: mypy](https://img.shields.io/badge/Linting-mypy-informational.svg)](https://mypy-lang.org/)
  [![SECURITY: bandit](https://img.shields.io/badge/Security-bandit-informational.svg)](https://github.com/PyCQA/bandit)
  ![INTERROGATE](https://github.com/causalens/cai-causal-graph/blob/main/interrogate_badge.svg?raw=true)

  > **Note**
  > The current development cycle of this branch is `v0.5.x` (stable).



  `cai-causal-graph` is open source and licensed under the [Apache-2.0 license](https://github.com/causalens/cai-causal-graph/blob/main/LICENSE).


pkgId: 570055871d60f92dad7229e89d5bbcab30ebb3c85f53cdf62d1a817c075b0836
name: python-caikit
arch: src
version: 0.27.7
epoch: 0
release: 1
url: https://pypi.org/project/caikit/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caikit-0.27.7-1.src.rpm
checksum_type: sha256
summary:
  AI toolkit that enables AI users to consume stable task-specific model APIs and enables AI developers build algorithms and models in a modular/composable framework

description:
  [![Build Status](https://github.com/caikit/caikit/actions/workflows/build-library.yml/badge.svg?branch=main&label=tests)](https://github.com/caikit/caikit/actions)
  [![Minimum Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
  [![Release](https://img.shields.io/github/v/release/caikit/caikit?include_prereleases&style=)](https://github.com/caikit/caikit/releases/)
  [![Read the Docs](https://img.shields.io/static/v1?label=readthedocs&message=reference&color=blue)](https://caikit.readthedocs.io/en/latest/)
  [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/7443/badge)](https://bestpractices.coreinfrastructure.org/projects/7443)

  Caikit is an AI toolkit that enables users to manage models through a set of developer friendly APIs. It provides a consistent format for creating and using AI models against a wide variety of data domains and tasks.

  ![Caikit Overview](https://raw.githubusercontent.com/caikit/caikit/main/caikit-overview.png)



  Caikit streamlines the management of AI models for application usage by letting AI model authors focus on solving well known problems with novel technology. With a set of model implementations based on Caikit, you can:

  - Run training jobs to create models from your data
  - Run model inference using data APIs that represent data as structures rather than tensors
  - Implement the right training techniques to fit the model, from static regexes to multi-GPU distribution
  - Merge models from diverse AI communities into a common API (e.g. `transformers`, `tensorflow`, `sklearn`, etc...)
  - Update applications to newer models for a given task without client-side changes



  Developers who write applications that consume AI models are not necessarily AI experts who understand the intricate details of the AI models that they use. Some would like to treat AI as a "black box function" where they give it input and it returns the output. This is similar in cloud computing whereby some users would like to deploy their applications to the cloud without detailed knowledge of the cloud infrastructure. The value for them is in their application and that is what is of most interest to them.

  Caikit provides an abstraction layer for application developers where they can consume AI models through APIs independent of understanding the data form of the model. In other words, the input and output to the model is in a format which is easily programmable and does not require data transformations. This facilitates the model and the application to evolve independently of each other.

  When deploying a small handful of models, this benefit is minimal. The benefits are generally realized when consuming 10s or hundreds of AI models, or maintaining an application over time as AI technology evolves. Caikit simplifies the scaling and maintenance of such integrations compared to other runtimes. This is because other runtimes require an AI centric view of the model (for example, the common interface of “tensor in, tensor out”) which means having to code different data transformations into the application for each model. Additionally, the data form of the model may change from version to version.



  There are 2 key things to define upfront when using Caikit to manage your AI model. They are as follows:

  - [Module](https://github.com/caikit/caikit/blob/main/docs/adrs/001-module.md)
  - [Data model](https://github.com/caikit/caikit/blob/main/docs/adrs/010-data-model-definition.md)

  The `module` defines the entry points for Caikit to manage your model. In other words, it tells Caikit how to load, infer and train your model. An example is the [text sentiment module](https://github.com/caikit/caikit/blob/main/examples/text-sentiment/text_sentiment/runtime_model/hf_module.py). The `data model` defines the input and outputs of the model task. An example is the [text sentiment data model](https://github.com/caikit/caikit/blob/main/examples/text-sentiment/text_sentiment/data_model/classification.py).

  The model is served by a [gRPC](https://grpc.io) server which can run as is or in any container runtime, including [Knative](https://knative.dev/docs/) and [KServe](https://www.kubeflow.org/docs/external-add-ons/kserve/kserve/). Here is an example of the [text sentiment server code for gRPC](https://github.com/caikit/caikit/blob/main/examples/text-sentiment/start_runtime.py). This references the module configuration [here](https://github.com/caikit/caikit/blob/main/examples/text-sentiment/models/text_sentiment/config.yml). This configuration specifies the module(s), which wrap the model(s), to serve.

  There is an example of a client [here](https://github.com/caikit/caikit/blob/main/examples/text-sentiment/client.py) which is a simple Python CLI which calls the model and queries it for sentiment analysis on 2 different pieces of text. The client also references the module configuration.

  Check out the full [Text Sentiment example](examples/text-sentiment/) to understand how to load and infer a model using Caikit. If you want to get started with developing and integrating your AI model algorithm using Caikit, checkout the [GitHub template](https://github.com/caikit/caikit-template). In the template repository when you click on the green `Use this template` button, it generates a repository in your GitHub account with a simple customized module which is wrapped to be served by the Caikit runtime. This template is designed to be extended for module implementations.



  There are 2 user profiles who leverage Caikit:

  - AI Model Author:
    - Model Authors build and train AI models for data analysis
    - They bring data and tuning params to a pre-existing model architecture and create a new concrete model using APIs provided by Caikit
    - Examples of model authors are machine learning engineers, data scientists, and AI developers
  - AI Model Operator:
    - Model operators use an existing AI model to perform a specific function within the context of an application
    - They take trained models, deploy them, and then infer the models in applications through APIs provided by Caikit
    - Examples of operators are cloud and embedded application developers whose applications need analysis of unstructured data



  Get going with [Getting Started](#getting-started) or jump into more details with the [Python API docs](https://caikit.readthedocs.io/en/latest/).



  Check out our [contributing](CONTRIBUTING.md) guide to learn how to contribute to Caikit.



  Participation in the Caikit community is governed by the [Code of Conduct](code-of-conduct.md).


pkgId: 771996c714d72083ad875be1eed8de7b9550ee1aaa886b8d206e86c4cc0a8ded
name: python-caikit-nlp
arch: src
version: 0.5.7
epoch: 0
release: 1
summary: Caikit NLP
url: https://pypi.org/project/caikit-nlp/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caikit-nlp-0.5.7-1.src.rpm
checksum_type: sha256
description:
  Caikit-NLP is a python library providing various Natural Language Processing (NLP) capabilities built on top of [caikit](https://github.com/caikit/caikit) framework.



  Caikit-NLP implements concept of "task" from `caikit` framework to define (and consume) interfaces for various NLP problems and implements various "modules" to provide functionalities for these "modules".

  Capabilities provided by `caikit-nlp`:

  | Task                                                | Module(s)                                      | Salient Feature(s)                                                                                                                                                                                                                                                                                                                     |
  |-----------------------------------------------------|------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | TextGenerationTask                                  | 1. `PeftPromptTuning` <br> 2. `TextGeneration` | 1. Prompt Tuning, Multi-task Prompt tuning <br> 2. Fine-tuning  Both modules above provide optimized inference capability using Text Generation Inference Server                                                                                                                                                                       |
  | TextClassificationTask                              | 1. `SequenceClassification`                    | 1. (Work in progress..)                                                                                                                                                                                                                                                                                                                |
  | TokenClassificationTask                             | 1. `FilteredSpanClassification`                | 1. (Work in progress..)                                                                                                                                                                                                                                                                                                                |
  | TokenizationTask                                    | 1. `RegexSentenceSplitter`                     | 1. Demo purposes only                                                                                                                                                                                                                                                                                                                  |
  | EmbeddingTask <br> EmbeddingTasks                   | 1. `TextEmbedding`                             | 1. TextEmbedding returns a text embedding vector from a local sentence-transformers model <br> 2. EmbeddingTasks takes multiple input texts and returns a corresponding list of vectors.
  | SentenceSimilarityTask <br> SentenceSimilarityTasks | 1. `TextEmbedding`                             | 1. SentenceSimilarityTask compares one source_sentence to a list of sentences and returns similarity scores in order of the sentences. <br> 2. SentenceSimilarityTasks uses a list of source_sentences (each to be compared to same list of sentences) and returns corresponding lists of outputs.                                     |
  | RerankTask <br> RerankTasks                         | 1. `TextEmbedding`                             | 1. RerankTask compares a query to a list of documents and returns top_n scores in order of relevance with indexes to the source documents and optionally returning the documents. <br> 2. RerankTasks takes multiple queries as input and returns a corresponding list of outputs. The same list of documents is used for all queries. |





  To help you quickly get started with using Caikit, we have prepared a [Jupyter notebook](examples/Caikit_Getting_Started.ipynb) that can be run in Google Colab. Caikit-nlp is a powerful library that leverages prompt tuning and fine-tuning to add NLP domain capabilities to caikit.



  To install from git repo:

  ```bash
  python -m venv .venv
  source .venv/bin/activate
  pip install git+https://github.com/caikit/caikit-nlp
  ```



  `caikit_nlp` can use  Hugging Face models, allowing for direct download and bootstrapping.

  For example, to use [google/flan-t5-small](https://huggingface.co/google/flan-t5-small):

  ```python
  import os

  os.environ['ALLOW_DOWNLOADS'] = "1"

  import caikit_nlp

  model_name = "google/flan-t5-small"
  model = caikit_nlp.text_generation.TextGeneration.bootstrap(model_name)
  model.save(f"{model_name}-caikit") # optionally save the model
  ```



  To serve models, the following basic configuration can be used:

  ```yaml

  runtime:
    library: caikit_nlp
    local_models_dir: ./models

  log:
    formatter: pretty # optional: log formatter is set to json by default
  ```

  Start the server:

  ```bash
  env CONFIG_FILES=./config.yml python -m caikit.runtime
  ```

  The model can now be queried at `localhost:8080` via http or at `localhost:8085` via grpc.

  For example, using the http server and using curl to send a POST request:

  ```bash
  curl --json '{
      "model_id": "flan-t5-small-caikit",
      "inputs": "At what temperature does liquid Nitrogen boil?"
  }' localhost:8080/api/v1/task/text-generation
  ```

  We get the following response:

  ```json
  {
    "generated_text": "74 degrees F",
    "generated_tokens": 5,
    "finish_reason": "MAX_TOKENS",
    "producer_id": {
      "name": "Text Generation",
      "version": "0.1.0"
    },
    "input_token_count": 10,
    "seed": null
  }
  ```

  All the available API endpoints and protos can be dumped using [`scripts/dump_apis.sh`](/scripts/dump_apis.sh).



  To build the docker image:

  ```bash
  python -m build --wheel
  docker build -t caikit-nlp:latest .
  ```

  A volume can be mounted at `/caikit` providing configuration and (optionally) models:

  ```bash
  mkdir -p caikit
  $EDITOR caikit/config.yml # edit as required
  cp -r <path/to/models> ./caikit/models
  docker run -e CONFIG_FILES=/caikit/config.yml -v $PWD/caikit/:/caikit -p 8080:8080 -p 8085:8085 python -m caikit.runtime
  ```



  In order to start the serving runtime:

  ```bash
  docker run -e CONFIG_FILES=/caikit/config.yml \
      -v $PWD/caikit/:/caikit -p 8080:8080 -p 8085 \
      python -m caikit.runtime
  ```

  Assuming the standard configuration with port `8080` for the http server and `8085` for the grpc server.



  Configuration can be provided via environment variables or by providing a yaml configuration file thanks to [`alchemy-config`](https://github.com/IBM/alchemy-config).

  For example, to set the caikit runtime, setting `RUNTIME_LIBRARY=caikit_nlp` via environment variables or providing the following yaml configuration is equivalent.

  ```yaml

  runtime:
    library: caikit_nlp
  ```

  For configuration options see `caikit_nlp`'s example config: [`config.yml`](/caikit_nlp/config/config.yml) or `caikit`'s example [`caikit.yml`](https://github.com/caikit/caikit/blob/main/caikit/config/config.yml).



  We welcome contributions from the community! If you would like to contribute to `caikit-nlp`, please read the guidelines in the main project's [CONTRIBUTING.md](CONTRIBUTING.md) file. It includes information on submitting bug reports, feature requests, and pull requests. Make sure to follow our coding standards, [code of conduct](code-of-conduct.md), [security standards](https://github.com/caikit/community/blob/main/SECURITY.md), and documentation guidelines to streamline the contribution process.



  This project is licensed under the [ASFv2 License](LICENSE).



  A list of terms that either may be unfamiliar or that have nebulous definitions based on who and where you hear them, defined for how they are used/thought of in the `caikit`/`caikit-nlp` project:

  * Fine tuning - trains the base model onto new data etc; this changes the base model.
  * Prompt engineering - (usually) manually crafting texts that make models do a better job that's left appended to the input text. E.g., if you wanted to do something like sentiment on movie reviews, you might come up with a prompt like The movie was: _____ and replace the _____  with the movie review you're consider to try to get something like happy/sad out of it.
  * PEFT - library by Huggingface containing implementations of different tuning methods that scale well - things like prompt tuning, and MPT live there. So PEFT itself isn't an approach even though parameter efficient fine-tuning sounds like one.
  Prompt tuning - learning soft prompts. This is different from prompt engineering in that you're not trying to learn tokens. Instead, you're basically trying to learn new embedded representations (sometimes called virtual tokens) that can be concatenated onto your embedded input text to improve the performance. This can work well, but also can be sensitive to initialization.
  * Multitask prompt tuning (MPT) - Tries to fix some of the issues with prompt tuning by allowing you to effectively learn 'source prompts' across different tasks & leverage them to initialize your prompt tuning etc. More information on MPT can be found at: https://arxiv.org/abs/2303.02861

  The important difference between fine tuning and capabilities like prompt tuning/multi-taskprompt tuning is that the latter doesn't change the base model's weights at all. So when you run inference for prompt tuned models, you can have n prompts to 1 base model, and just inject the prompt tensors you need when they're requested instead of having _n_ separate fine-tuned models.



  [Runtime Performance Benchmarking](./benchmarks/README.md) for tuning various models.



  - Currently causal language models and sequence-to-sequence models are supported.


pkgId: e0b8bc2c968f4320dfd045b8ea06150617c7e3f0916e7fd6c1900a904563a4d1
name: python-caikit-tgis-backend
arch: src
version: 0.1.38
epoch: 0
release: 1
summary: Caikit module backend for models run in TGIS
url: https://pypi.org/project/caikit-tgis-backend/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caikit-tgis-backend-0.1.38-1.src.rpm
checksum_type: sha256
description:
  This project provides a Caikit module backend that manages models run in TGIS



  Sample configuration using the `MULTI` finder and a remote `TGIS` backend):

  ```yaml
  runtime:
    library: caikit_nlp
    local_models_dir: /path/to/models
    lazy_load_local_models: true

  model_management:
    finders:
      default:
        type: MULTI
        config:
          finder_priority:
            - local
            - tgis-auto
    initializers:
      default:
        type: LOCAL
        config:
          backend_priority:
            - type: TGIS
              config:
                connection:
                  hostname: "localhost:8033"
                  connect_timeout: 30
                test_connections: true

  log:
    formatter: pretty
  ```


pkgId: 626cb6c02295e0345477ac554572d73cdcd13cad0fd09ea7b876f8f46564e348
name: python-caiman
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A build system for MicroPython projects
url: https://github.com/andreicsp/caiman
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caiman-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A build system for MicroPython applications.



  - Define named targets for MicroPython sources, third party dependencies, and config resources
  - Selectively tag targets for mpy compilation or freezing
  - Dependency management using mip with dual install locations for development and deployment
  - Maintains a build copy on your development machine for code completion
  - Build code deployment to target devices using `mpremote`


  - Python 3.9+ for local development
  - MicroPython installed and added to `PATH` on your local machine
  - MicroPython installed on your target device


  1. In your development environment, install caiman in a Python virtual environment:

      ```bash
      pip install caiman
      ```

  2. Install a MicroPython port on your development machine.
     * If developing on a Mac, you can use brew:

      ```bash
      brew install micropython
      ```

  3. Flash the MicroPython firmware on your target device.



  * Installing caiman in your local Python environment will make the `caiman` command available.
  * All `caiman` commands are run from the root of your project directory.
  * `caiman` is configured using a `caiman.yaml` file in the root of your project.

  Run the following command from the root of a new project directory:

  ```bash
  caiman init
  ```
  An interactive prompt will guide you through the setup process.
  At the end, a `caiman.yaml` file will be created in the root of your project,
  together with a basic directory structure.

  Your project directory should look like this:

  * `caiman.yaml` the project configuration file with your build targets and project metadata.
  * `build` folder. Contains the build copy of your project, together with dependency artifacts and manifest files for your targets. Add this to `.gitignore`!
  * `venv/mip-packages`folder which stores local copies of your `mip` installed dependencies for code completion. Add this to `.gitignore` and to your `PYTHONPATH`. This folder will be copied over to the build folder when the build command runs.
  * `venv/tools` `mip` installed dependencies for development only. Not deployed to the device.
  * `micropython` an example folder for your MicroPython source target. You can rename this folder from `caiman.yaml` or define additional source targets. Add this to `PYTHONPATH` for code completion.


  To build all targets in your project, run the following command from the root of your project:

  ```bash
  caiman build
  ```

  This will copy and selectively compile or freeze all targets defined in your `caiman.yaml` file to the `build` folder.
  Nothing is deployed on your device at this point.

  The following sections will explain how to define your build targets.



  To define a MicroPython source target, add a new entry to your `caiman.yaml` file.
  A sample source was created in the `micropython` folder during project initialization.

  ```yaml
  sources:
  - name: micropython # the name of the target
    parent: micropython # the parent directory of MicroPython sources
    frozen: false # whether to tag the target for freezing to firmware (separate firmware build required)
    compile: true # whether to compile the target to mpy
    files: # paths to component files relative to the parent directory
    - '**/*.py'
    version: '' # optional - version of the target
  ```

  To build all source targets, run the following command from the root of your project:

  ```bash
  caiman build --target=sources
  ```

  This will copy matching source files from all source targets into the `build/micropython` folder.
  Sources tagged for compilation will be compiled to mpy format at this point.



  Any files that are not MicroPython sources can be defined as resources.
  These can be config files, images, or other data files that your application needs.

  To define a resource target, add a new entry to your `caiman.yaml` file in the `resources` section.

  ```yaml
  resources:
  - name: resources # the name of the target
    parent: resources # the parent directory of resources
  ```
  The above example will copy all files from the `resources` folder to the `build/micropython` folder.

  To build all resource targets, run the following command from the root of your project:

  ```bash
  caiman build --target=resources
  ```



  > A local install of MicroPython is required for dependency management. Make sure it's discoverable on the `PATH`

  Dependencies are managed using `mip`, a MicroPython package manager.
  They are specified in the `caiman.yaml` file in the `dependencies` section.

  Example:
  ```yaml
  dependencies:
  - name: logging
    version: latest
    frozen: false # whether to tag the target for freezing to firmware (separate firmware build required)
    compile: true # whether to compile the target to mpy. Local install is always not compiled.
  ```

  This example will install the `logging` package from the MicroPython package index.

  To install all dependencies, run the following command from the root of your project:

  ```bash
  caiman build --target=dependencies
  ```

  You can also define specific files that you want to fetch from a dependency.

  Example:

  ```yaml
  dependencies:
    - name: github:T0ha/uprotobuf
      version: main
      files:
        - protobuf/uprotobuf.py
  ```

  This will only install the specified files from the `uprotobuf` github repository.



  Tools are dependencies that are only required for development and are not deployed to the device.
  They are specified in the `caiman.yaml` file in the `tools` section.
  You can use parts of a dependency for development only by specifying the files you need.

  Example:
  ```yaml
  tools:
    - name: github:T0ha/uprotobuf
      version: main
      compile: false
      files:
        - scripts/uprotobuf_plugin.py
  ```

  Building all tools:

  ```bash
  caiman build --target=tools
  ```

  This command will copy the specified files from the dependency to the `venv/tools` folder.



  > Ensure your device is connected via USB and is discoverable: `ls -latr /dev | grep tty.usbmodem` on OSX.

  > Ensure no other processes are using the serial port when deploying to the device. This includes any IDE plugins.


  The deployment operation copies the contents of `build/micropython` to the target device.

  To deploy all targets, run the following command from the root of your project:

  ```bash
  caiman deploy
  ```





  ```bash
  caiman walk --target=/
  ```



  > *WARNING*: This will remove all files from the device!

  ```bash
  caiman rmtree --target=/
  ```



  ```bash
  caiman cat --target=/boot.py
  ```

  To do this without logging (useful for parsing):

  ```bash
  caiman --silent cat --target=/boot.py
  ```



  ```bash
  caiman run --target=boot
  ```


pkgId: 81523ea4b40784b10f67dbd4b22393490a971801688fb3cff36a833f2e81ea26
name: python-caimira
arch: src
version: 4.17.6
epoch: 0
release: 1
summary: CAiMIRA - CERN Airborne Model for Indoor Risk Assessment
url: https://gitlab.cern.ch/caimira/caimira
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caimira-4.17.6-1.src.rpm
checksum_type: sha256
description:
  CAiMIRA is a risk assessment tool developed to model the concentration of viruses in enclosed spaces, in order to inform space-management decisions.

  CAiMIRA models the concentration profile of potential virions in enclosed spaces , both as background (room) concentration and during close-proximity interactions, with clear and intuitive graphs.
  The user can set a number of parameters, including room volume, exposure time, activity type, mask-wearing and ventilation.
  The report generated indicates how to avoid exceeding critical concentrations and chains of airborne transmission in spaces such as individual offices, meeting rooms and labs.

  The risk assessment tool simulates the airborne spread SARS-CoV-2 virus in a finite volume, assuming a homogenous mixture and a two-stage exhaled jet model, and estimates the risk of COVID-19 infection therein.
  The results DO NOT include the other known modes of SARS-CoV-2 transmission, such as fomite or blood-bound.
  Hence, the output from this model is only valid when the other recommended public health & safety instructions are observed, such as good hand hygiene and other barrier measures.

  The model used is based on scientific publications relating to airborne transmission of infectious diseases, dose-response exposures and aerosol science, as of February 2022.
  It can be used to compare the effectiveness of different airborne-related risk mitigation measures.
  Note that this model applies a deterministic approach, i.e., it is assumed at least one person is infected and shedding viruses into the simulated volume.
  Nonetheless, it is also important to understand that the absolute risk of infection is uncertain, as it will depend on the probability that someone infected attends the event.
  The model is most useful for comparing the impact and effectiveness of different mitigation measures such as ventilation, filtration, exposure time, physical activity, amount and nature of close-range interactions and
  the size of the room, considering both long- and short-range airborne transmission modes of COVID-19 in indoor settings.

  This tool is designed to be informative, allowing the user to adapt different settings and model the relative impact on the estimated infection probabilities.
  The objective is to facilitate targeted decision-making and investment through comparisons, rather than a singular determination of absolute risk.
  While the SARS-CoV-2 virus is in circulation among the population, the notion of 'zero risk' or 'completely safe scenario' does not exist.
  Each event modelled is unique, and the results generated therein are only as accurate as the inputs and assumptions.



  The CAiMIRA Calculator can be accessed online [here](https://caimira.web.cern.ch/), provided you have CERN SSO (Single Sign-On) credentials. For local usage, please refer to the [documentation](#documentation) on how to install and run the calculator locally.



  All instructions for installation, deployment, usage, and model assumptions and references can be found in the [official documentation](https://caimira.docs.cern.ch/).



  Contributions are welcome on our [GitHub repository](https://github.com/CERN/CAiMIRA).



  Developed by CERN's HSE, Beams, and IT departments, in collaboration with WHO.

  © Copyright 2020 CERN. All rights not expressly granted are reserved.<br>
  Licensed under the Apache License, Version 2.0

  See the full [license](caimira/LICENSE) for details.


pkgId: 1f3825452a0fd80e2ce0fa4222be0f5509d168e81ebbde2001e81152c79bce63
name: python-cairocffi
arch: src
version: 1.7.1
epoch: 0
release: 1
summary: cffi-based cairo bindings for Python
url: https://pypi.org/project/cairocffi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cairocffi-1.7.1-1.src.rpm
checksum_type: sha256
description:
  cairocffi is a `CFFI`_-based drop-in replacement for Pycairo_,
  a set of Python bindings and object-oriented API for cairo_.
  Cairo is a 2D vector graphics library with support for multiple backends
  including image buffers, PNG, PostScript, PDF, and SVG file output.

  Additionally, the ``cairocffi.pixbuf`` module uses GDK-PixBuf_
  to decode various image formats for use in cairo.

  .. _CFFI: https://cffi.readthedocs.org/
  .. _Pycairo: https://pycairo.readthedocs.io/
  .. _cairo: http://cairographics.org/
  .. _GDK-PixBuf: https://gitlab.gnome.org/GNOME/gdk-pixbuf

  * Free software: BSD license
  * For Python 3.8+, tested on CPython and PyPy
  * Documentation: https://doc.courtbouillon.org/cairocffi/
  * Changelog: https://doc.courtbouillon.org/cairocffi/stable/changelog.html
  * Code, issues, tests: https://github.com/Kozea/cairocffi
  * Code of conduct: https://www.courtbouillon.org/code-of-conduct
  * Professional support: https://www.courtbouillon.org
  * Donation: https://opencollective.com/courtbouillon
  * API partially compatible with Pycairo.
  * Works with any version of cairo.

  cairocffi has been created and developed by Kozea (https://kozea.fr).
  Professional support, maintenance and community management is provided by
  CourtBouillon (https://www.courtbouillon.org).

  Copyrights are retained by their contributors, no copyright assignment is
  required to contribute to cairocffi. Unless explicitly stated otherwise, any
  contribution intentionally submitted for inclusion is licensed under the BSD
  3-clause license, without any additional terms or conditions. For full
  authorship information, see the version control history.


pkgId: eb6402596815fd76aaf2447c4bd70901e18f125e9904ee07d1abeaff8d35f6e5
name: python-caketool
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Common tools for MLOps
url: https://github.com/cake-digital-bank
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caketool-1.3.0-1.src.rpm
checksum_type: sha256
description:
  - Enviroment

  ```bash
  conda create -n caketool
  conda activate caketool
  pip-compile pyproject.toml
  pip-sync
  pip install pip-tools bumpver build twine ipykernel
  ```

  - Publish libs

  ```bash
  bumpver update --major # Increment the MAJOR version when you make incompatible API changes.
  bumpver update --minor # Increment the MINOR version when you add functionality in a backwards compatible manner.
  bumpver update --patch # Increment the PATCH version when you make backwards compatible bug fixes.
  python -m pip install -e . # Install on local machine
  rm ./dist/*
  python -m build
  twine upload -r testpypi dist/*
  twine upload dist/*
  pip install caketool
  ```

rpm_license:
  MIT License  Copyright (c) 2018 Real Python  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: e11e0858a43761a56a24242a6b23f730dee17608e577827974e12f06c05af65c
name: python-cal-ai
arch: src
version: 0.2.0.9
epoch: 0
release: 1
summary: An end-to-end machine learning and data mining framework on Hadoop CAL.
url: https://github.paypal.com/haifwu/LiveBoxMonitor
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cal-ai-0.2.0.9-1.src.rpm
checksum_type: sha256
description:
  This is a project based on hadoop cal data, provide user the ability to explore boxes status and build models
  based on these data.


  http://10.176.5.126:9090/notebooks/cal_ai.ipynb


pkgId: 1ddea1531eed10b3b65d432a618e04f4b3e92ed6d90182ec8c328f1810235887
name: python-calabrio-py
arch: src
version: 0.1.31
epoch: 0
release: 1
summary: A Python client library for accessing the Calabrio API.
url: https://pypi.org/project/calabrio-py/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calabrio-py-0.1.31-1.src.rpm
checksum_type: sha256
description:
      A Python client library for accessing the Calabrio API.

      This library provides convenient methods for interacting with the Calabrio API,
      making it easy to retrieve data and perform actions using Python code.


pkgId: 2bd117731567a29806761b8ef5102621b700711f3b915037f15c36781b1b5126
name: python-calamus
arch: src
version: 0.4.2
epoch: 0
release: 1
url: https://github.com/SwissDataScienceCenter/calamus/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calamus-0.4.2-1.src.rpm
checksum_type: sha256
summary:
  calamus is a library built on top of marshmallow to allow (de-)Serialization of Python classes to JSON-LD.


pkgId: 8453d6c41a83ec04d0535342cbfcd5953059b392dfa5e81575342b8febb64e8a
name: python-calc-lib-test
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Test calculator
url: https://pypi.org/project/calc-lib-test/
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calc-lib-test-1.0.8-1.src.rpm
checksum_type: sha256
description:
  Библиотека для сложения двух чисел.
  Пример использования:
  >>> from calc_lib import add
  >>> add(1, 2)
  3


pkgId: cb946eb529e3b3dd0b719d9e4c63222ec078f29265bbb8ce0a5ab04844686955
name: python-calc-ultra
arch: src
version: 1.3.9
epoch: 0
release: 1
summary: A graphing calculator with a menu-based interface.
url: https://github.com/sudoer-Huatao/calc_ultra
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calc-ultra-1.3.9-1.src.rpm
checksum_type: sha256
description:
  [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/license/mit/) [![Version](https://img.shields.io/badge/Version-1.3.9-blue.svg)](https://pypi.org/project/calc-ultra/)

  > **Advanced math made easy**

  (Turn on dark mode for a better aesthetic) 📲

  Calc-Ultra is a multi-functional graphing calculator that uses a menu-based interface. Little Python background knowledge is needed to use this calculator! (Please star the GitHub repo if you find this project helpful! ❤️)

  Supports:

  - Simple calculations (complex numbers supported!)
  - Derivatives
  - Partials
  - Implicit differentiation
  - Extrema Calculator
  - Limits
  - Antiderivatives
  - Definite integrals
  - Improper integrals
  - Double integrals
  - Solving (sets) of equation(s)
  - Vector/matrix operations
  - Taylor Polynomial Approximations
  - Expression Simplifier
  - Grapher
  - Arc Length Calculator
  - **A perfect interface to do calculations!**



  Want to check out the Chinese version? Visit the Chinese version [here](https://github.com/sudoer-Huatao/calc_ultra-chinese) (Work in progress)! 🇨🇳



  > Run the calculus calculator with a single line of code

  Use the following command to install Calc-Ultra:

  `pip3 install calc-ultra`

  or

  `python3 -m pip install calc-ultra` if you have lower versions of pip.

  Due to Python import identifiers restrictions, please import Calc-Ultra as "calc_ultra" and not "calc-ultra".

  Import Calc-Ultra like so to use:

  `from calc_ultra import main`

  Please make sure you have the latest version installed. To update calc-ultra, run the following command:

  `pip3 install --upgrade calc-ultra`



  Calc-Ultra requires these modules/packages to be installed:

  - `sympy`
  - `numpy`
  - `matplotlib`
  - `scipy`
  - `rich`
  - `prompt-toolkit`

  If you do not have them installed, no need to worry! These modules should be installed automatically if you don't have them.



  > Without them, this would be impossible

  A big thank-you to all GitHub users who gave feedback and/or starred this repository. ⭐️ Your encouragement is our motivation.
  The following contributors deserve a SPECIAL THANK-YOU 👍❤️:

  - [@Haobot](https://github.com/Haobot) for troubleshooting and feedback!
  - [@FanboFB](https://github.com/FanboFB) for feedback and ideas for improvement!

  This program was made using `sympy` for calculation and `numpy`, `scipy`, and `matplotlib` for graphing.

  For more info about the current build, check the changelog.



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


pkgId: 456635117b84d8c744cc78e8366afcc86e585e5f1ad1f2ef1efeb1bf92b930b2
name: python-calcam
arch: src
version: 2.14.1
epoch: 0
release: 1
summary: Spatial calibration tools for science & engineering camera systems.
url: https://pypi.org/project/calcam/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calcam-2.14.1-1.src.rpm
checksum_type: sha256
description:
  Calcam is a Python package providing tools for "spatial calibration" of cameras used in science & engineering, i.e. determining the mapping between pixel coordinates in an image and real-world 3D sight lines & coordinates. The calibration method is based on the user matching features between an image to be calibrated and a 3D mesh of the scene being viewed, then using OpenCV’s camera calibration routines to fit a model relating the image and real world coordinates.
  It was written for use with camera-based plasma diagnostics on fusion experiments, but may be useful for other applications too. As well as calibrating existing cameras, it can also be used as part of a virtual diagnostic setup, e.g. to evaluate different possible viewing geometries during diagnostic design and/or  setting up synthetic imaging diagnostics for modeling codes.
  Calcam provides a set of GUI tools for calibrating images and doing some basic analysis using the results, and a Python API for making full use of the calibration information as part of a data analysis process.

rpm_license:
  European Union Public Licence  V. 1.1  EUPL (c) the European Community 2007  This European Union Public Licence (the "EUPL") applies to the Work or Software (as defined below) which is provided under the terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such use is covered by a right of the copyright holder of the Work).  The Original Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following notice immediately following the copyright notice for the Original Work: Licensed under the EUPL V.1.1 or has expressed by any other mean his willingness to license under the EUPL.  1. Definitions  In this Licence, the following terms have the following meaning:  - The Licence: this Licence.  - The Original Work or the Software: the software distributed and/or communicated by the Licensor under this Licence, available as Source Code and also as Executable Code as the case may be.  - Derivative Works: the works or software that could be created by the Licensee, based upon the Original Work or modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in the country mentioned in Article 15.  - The Work: the Original Work and/or its Derivative Works.  - The Source Code: the human-readable form of the Work which is the most convenient for people to study and modify.  - The Executable Code: any code which has generally been compiled and which is meant to be interpreted by a computer as a program.  - The Licensor: the natural or legal person that distributes and/or communicates the Work under the Licence.  - Contributor(s): any natural or legal person who modifies the Work under the Licence, or otherwise contributes to the creation of a Derivative Work.  - The Licensee or "You": any natural or legal person who makes any usage of the Software under the terms of the Licence.  - Distribution and/or Communication: any act of selling, giving, lending, renting, distributing, communicating, transmitting, or otherwise making available, on-line or off-line, copies of the Work or providing access to its essential functionalities at the disposal of any other natural or legal person.  2. Scope of the rights granted by the Licence  The Licensor hereby grants You a world-wide, royalty-free, non-exclusive, sublicensable licence to do the following, for the duration of copyright vested in the Original Work:  - use the Work in any circumstance and for all usage, - reproduce the Work, - modify the Original Work, and make Derivative Works based upon the Work, - communicate to the public, including the right to make available or display the Work or copies thereof to the public and perform publicly, as the case may be, the Work, - distribute the Work or copies thereof, - lend and rent the Work or copies thereof, - sub-license rights in the Work or copies thereof.  Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the applicable law permits so.  In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed by law in order to make effective the licence of the economic rights here above listed.  The Licensor grants to the Licensee royalty-free, non exclusive usage rights to any patents held by the Licensor, to the extent necessary to make use of the rights granted on the Work under this Licence.  3. Communication of the Source Code  The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to distribute and/or communicate the Work.  4. Limitations on copyright  Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the exclusive rights of the rights owners in the Original Work or Software, of the exhaustion of those rights or of other applicable limitations thereto.  5. Obligations of the Licensee  The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those obligations are the following:  Attribution right: the Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the Licence with every copy of the Work he/she distributes and/or communicates. The Licensee must cause any Derivative Work to carry prominent notices stating that the Work has been modified and the date of modification.  Copyleft clause: If the Licensee distributes and/or communicates copies of the Original Works or Derivative Works based upon the Original Work, this Distribution and/or Communication will be done under the terms of this Licence or of a later version of this Licence unless the Original Work is expressly distributed only under this version of the Licence. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the Work or Derivative Work that alter or restrict the terms of the Licence.  Compatibility clause: If the Licensee Distributes and/or Communicates Derivative Works or copies thereof based upon both the Original Work and another work licensed under a Compatible Licence, this Distribution and/or Communication can be done under the terms of this Compatible Licence. For the sake of this clause, "Compatible Licence" refers to the licences listed in the appendix attached to this Licence. Should the Licensee’s obligations under the Compatible Licence conflict with his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.  Provision of Source Code: When distributing and/or communicating copies of the Work, the Licensee will provide a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available for as long as the Licensee continues to distribute and/or communicate the Work.  Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the copyright notice.  6. Chain of Authorship  The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.  Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.  Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions to the Work, under the terms of this Licence.  7. Disclaimer of Warranty  The Work is a work in progress, which is continuously improved by numerous contributors. It is not a finished work and may therefore contain defects or "bugs" inherent to this type of software development.  For the above reason, the Work is provided under the Licence on an "as is" basis and without warranties of any kind concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this Licence.  This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.  8. Disclaimer of Liability  Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.  9. Additional agreements  While distributing the Original Work or Derivative Works, You may choose to conclude an additional agreement to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or services consistent with this Licence. However, in accepting such obligations, You may act only on your own behalf and on your sole responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by the fact You have accepted any such warranty or additional liability.  10. Acceptance of the Licence  The provisions of this Licence can be accepted by clicking on an icon "I agree" placed under the bottom of a window displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms and conditions.  Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution and/or Communication by You of the Work or copies thereof.  11. Information to the public  In case of any Distribution and/or Communication of the Work by means of electronic communication by You (for example, by offering to download the Work from a remote location) the distribution channel or media (for example, a website) must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence and the way it may be accessible, concluded, stored and reproduced by the Licensee.  12. Termination of the Licence  The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms of the Licence. Such a termination will not terminate the licences of any person who has received the Work from the Licensee under the Licence, provided such persons remain in full compliance with the Licence.  13. Miscellaneous  Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the Work licensed hereunder.  If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or enforceability of the Licence as a whole. Such provision will be construed and/or reformed so as necessary to make it valid and enforceable.  The European Commission may publish other linguistic versions and/or new versions of this Licence, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence. New versions of the Licence will be published with a unique version number.  All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take advantage of the linguistic version of their choice.  14. Jurisdiction  Any litigation resulting from the interpretation of this License, arising between the European Commission, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice of the European Communities, as laid down in article 238 of the Treaty establishing the European Community.  Any litigation arising between Parties, other than the European Commission, and resulting from the interpretation of this License, will be subject to the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.  15. Applicable Law  This Licence shall be governed by the law of the European Union country where the Licensor resides or has his registered office.  This licence shall be governed by the Belgian law if:  - a litigation arises between the European Commission, as a Licensor, and any Licensee; - the Licensor, other than the European Commission, has no residence or registered office inside a European Union country.


pkgId: 8fa6aa778f974e53a5b6a0408c7e4277c7fea6b530161c5ab4f72e8d3fed8250
name: python-calcasa-api
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Calcasa Public API v1
url: https://github.com/calcasa/api-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calcasa-api-1.3.1-1.src.rpm
checksum_type: sha256
description:
  *AdressenApi* | [**get_adres**](docs/AdressenApi.md#get_adres) | **GET** /api/v1/adressen/{bagNummeraanduidingId} | Adres info op basis van BAG Nummeraanduiding Id.
  *AdressenApi* | [**search_adres**](docs/AdressenApi.md#search_adres) | **POST** /api/v1/adressen/zoeken | Zoek adres info op basis van het gegeven adres.
  *BestemmingsplannenApi* | [**get_bestemming_by_id**](docs/BestemmingsplannenApi.md#get_bestemming_by_id) | **GET** /api/v1/bestemmingsplannen/{bagNummeraanduidingId} | Gegevens over de bestemmingsplannen op de locatie van een adres (BAG Nummeraanduiding ID).
  *BodemApi* | [**get_bodem_by_id**](docs/BodemApi.md#get_bodem_by_id) | **GET** /api/v1/bodem/{bagNummeraanduidingId} | Gegevens over de bodemkwaliteit op de locatie van een adres (BAG Nummeraanduiding ID).
  *BuurtApi* | [**get_buurt**](docs/BuurtApi.md#get_buurt) | **GET** /api/v1/buurt/{buurtCode} | Gegevens over een buurt en de wijk, gemeente en land waarin deze buurt gesitueerd is.
  *CallbacksApi* | [**add_or_update_callback_subscription**](docs/CallbacksApi.md#add_or_update_callback_subscription) | **POST** /api/v1/callbacks/inschrijvingen | Voeg een callback inschrijving toe (of werk bij) voor de huidige client voor een adres.
  *CallbacksApi* | [**delete_notification_subscription**](docs/CallbacksApi.md#delete_notification_subscription) | **DELETE** /api/v1/callbacks/inschrijvingen/{bagNummeraanduidingId} | Verwijder de callback inschrijving voor deze client, dit adres en optioneel een geldverstrekker.
  *CallbacksApi* | [**get_notification_subscription**](docs/CallbacksApi.md#get_notification_subscription) | **GET** /api/v1/callbacks/inschrijvingen/{bagNummeraanduidingId} | Haal de callback inschrijving op voor deze client, dit adres en eventueel opgegeven geldverstrekker.
  *CallbacksApi* | [**get_notification_subscriptions**](docs/CallbacksApi.md#get_notification_subscriptions) | **GET** /api/v1/callbacks/inschrijvingen | Haal de callback inschrijvingen binnen voor deze client.
  *ConfiguratieApi* | [**get_callbacks**](docs/ConfiguratieApi.md#get_callbacks) | **GET** /api/v1/configuratie/callbacks | Haal de geconfigureerde callback URL&#39;s op voor de huidige client.
  *ConfiguratieApi* | [**update_callbacks**](docs/ConfiguratieApi.md#update_callbacks) | **POST** /api/v1/configuratie/callbacks | Configureer callback URL voor een specifieke API versie voor de huidige client.
  *FacturenApi* | [**get_factuur**](docs/FacturenApi.md#get_factuur) | **GET** /api/v1/facturen/{id} | Factuur op basis van een waardering Id.
  *FotosApi* | [**get_foto**](docs/FotosApi.md#get_foto) | **GET** /api/v1/fotos/{id} | Foto op basis van een foto Id.
  *FunderingenApi* | [**get_fundering_by_id**](docs/FunderingenApi.md#get_fundering_by_id) | **GET** /api/v1/funderingen/{bagNummeraanduidingId} | Gegevens over de fundering op de locatie van een adres (BAG Nummeraanduiding ID).
  *GeldverstrekkersApi* | [**get_geldverstrekkers**](docs/GeldverstrekkersApi.md#get_geldverstrekkers) | **GET** /api/v1/geldverstrekkers/{productType} | Alle geldverstrekkers die te gebruiken zijn voor aanvragen.
  *RapportenApi* | [**get_rapport**](docs/RapportenApi.md#get_rapport) | **GET** /api/v1/rapporten/{id} | Rapport op basis van waardering Id.
  *WaarderingenApi* | [**create_waardering**](docs/WaarderingenApi.md#create_waardering) | **POST** /api/v1/waarderingen | Creërt een waardering.
  *WaarderingenApi* | [**get_waardering**](docs/WaarderingenApi.md#get_waardering) | **GET** /api/v1/waarderingen/{id} | Waardering op basis van Id.
  *WaarderingenApi* | [**get_waardering_ontwikkeling**](docs/WaarderingenApi.md#get_waardering_ontwikkeling) | **GET** /api/v1/waarderingen/{id}/ontwikkeling | Waardering ontwikkeling op basis van waardering Id.
  *WaarderingenApi* | [**patch_waarderingen**](docs/WaarderingenApi.md#patch_waarderingen) | **PATCH** /api/v1/waarderingen/{id} | Patcht een waardering.
  *WaarderingenApi* | [**search_waarderingen**](docs/WaarderingenApi.md#search_waarderingen) | **POST** /api/v1/waarderingen/zoeken | Zoek waardering op basis van input parameters.

   - [Aanvraagdoel](docs/Aanvraagdoel.md)
   - [Adres](docs/Adres.md)
   - [AdresInfo](docs/AdresInfo.md)
   - [Bestemmingsdata](docs/Bestemmingsdata.md)
   - [BodemStatusType](docs/BodemStatusType.md)
   - [Bodemdata](docs/Bodemdata.md)
   - [BusinessRulesCode](docs/BusinessRulesCode.md)
   - [BusinessRulesProblemDetails](docs/BusinessRulesProblemDetails.md)
   - [Callback](docs/Callback.md)
   - [CallbackInschrijving](docs/CallbackInschrijving.md)
   - [CbsIndeling](docs/CbsIndeling.md)
   - [DeelWaarderingWebhookPayload](docs/DeelWaarderingWebhookPayload.md)
   - [Energielabel](docs/Energielabel.md)
   - [EnergielabelData](docs/EnergielabelData.md)
   - [Factuur](docs/Factuur.md)
   - [Foto](docs/Foto.md)
   - [FunderingDataBron](docs/FunderingDataBron.md)
   - [FunderingHerstelType](docs/FunderingHerstelType.md)
   - [FunderingRisico](docs/FunderingRisico.md)
   - [FunderingRisicoLabel](docs/FunderingRisicoLabel.md)
   - [FunderingSoortBron](docs/FunderingSoortBron.md)
   - [FunderingType](docs/FunderingType.md)
   - [FunderingTypering](docs/FunderingTypering.md)
   - [Funderingdata](docs/Funderingdata.md)
   - [Gebiedsdata](docs/Gebiedsdata.md)
   - [Geldverstrekker](docs/Geldverstrekker.md)
   - [InvalidArgumentProblemDetails](docs/InvalidArgumentProblemDetails.md)
   - [JsonPatchDocument](docs/JsonPatchDocument.md)
   - [KlantwaardeType](docs/KlantwaardeType.md)
   - [Kwartaal](docs/Kwartaal.md)
   - [Modeldata](docs/Modeldata.md)
   - [NotFoundProblemDetails](docs/NotFoundProblemDetails.md)
   - [Notitie](docs/Notitie.md)
   - [Notities](docs/Notities.md)
   - [Objectdata](docs/Objectdata.md)
   - [Omgevingsdata](docs/Omgevingsdata.md)
   - [Operation](docs/Operation.md)
   - [OperationType](docs/OperationType.md)
   - [PermissionsDeniedProblemDetails](docs/PermissionsDeniedProblemDetails.md)
   - [ProblemDetails](docs/ProblemDetails.md)
   - [ProductType](docs/ProductType.md)
   - [Rapport](docs/Rapport.md)
   - [Referentieobject](docs/Referentieobject.md)
   - [ResourceExhaustedProblemDetails](docs/ResourceExhaustedProblemDetails.md)
   - [Taxatiedata](docs/Taxatiedata.md)
   - [Taxatiestatus](docs/Taxatiestatus.md)
   - [ValidationProblemDetails](docs/ValidationProblemDetails.md)
   - [VerkoopBijzonderheden](docs/VerkoopBijzonderheden.md)
   - [VorigeVerkoop](docs/VorigeVerkoop.md)
   - [Waardering](docs/Waardering.md)
   - [WaarderingInputParameters](docs/WaarderingInputParameters.md)
   - [WaarderingOntwikkeling](docs/WaarderingOntwikkeling.md)
   - [WaarderingOntwikkelingKwartaal](docs/WaarderingOntwikkelingKwartaal.md)
   - [WaarderingStatus](docs/WaarderingStatus.md)
   - [WaarderingWebhookPayload](docs/WaarderingWebhookPayload.md)
   - [WaarderingZoekParameters](docs/WaarderingZoekParameters.md)
   - [WoningType](docs/WoningType.md)


  - **Type**: OAuth
  - **Flow**: application
  - **Authorization URL**:
  - **Scopes**:
   - **all**: Full permissions for all areas.
   - **api:all**: Full permissions for all areas of the public API.
   - **api:bestemmingsplannen:all**: Full permissions for the bestemmingsplannen area of the public API.
   - **api:bodem:all**: Full permissions for the bodem area of the public API.
   - **api:buurt:all**: Full permissions for the buurt area of the public API.
   - **api:configuratie:all**: Full permissions for the configuratie area of the public API.
   - **api:callback:all**: Full permissions for the callback area of the public API.
   - **api:facturen:all**: Full permissions for the facturen area of the public API.
   - **api:fotos:all**: Full permissions for the fotos area of the public API.
   - **api:funderingen:all**: Full permissions for the funderingen area of the public API.
   - **api:rapporten:all**: Full permissions for the rapporten area of the public API.
   - **api:waarderingen:all**: Full permissions for the waarderingen area of the public API.
   - **api:adressen:read**: Read permissions for the adressen area of the public API.
   - **api:bestemmingsplannen:read**: Read permissions for the bestemmingsplannen area of the public API.
   - **api:bodem:read**: Read permissions for the bodem area of the public API.
   - **api:buurt:read**: Read permissions for the buurt area of the public API.
   - **api:configuratie:read**: Read permissions for the configuratie area of the public API.
   - **api:configuratie:write**: Write permissions for the configuratie area of the public API.
   - **api:callback:read**: Read permissions for the callback area of the public API.
   - **api:callback:write**: Write permissions for the callback area of the public API.
   - **api:facturen:read**: Read permissions for the facturen area of the public API.
   - **api:fotos:read**: Read permissions for the fotos area of the public API.
   - **api:funderingen:read**: Read permissions for the funderingen area of the public API.
   - **api:geldverstrekkers:read**: Read permissions for the geldverstrekkers area of the public API.
   - **api:rapporten:read**: Read permissions for the rapporten area of the public API.
   - **api:waarderingen:create**: Create permissions for the waarderingen area of the public API.
   - **api:waarderingen:patch**: Patch permissions for the waarderingen area of the public API.
   - **api:waarderingen:read**: Read permissions for the waarderingen area of the public API.
   - **api:waarderingen:ontwikkeling**: Read permissions for the ontwikkelingen endpoint in the waarderingen area of the public API.

  - **Type**: OAuth
  - **Flow**: accessCode
  - **Authorization URL**: https://authentication.01.staging.calcasa.nl/oauth2/v2.0/authorize
  - **Scopes**:
   - **all**: Full permissions for all areas.
   - **api:all**: Full permissions for all areas of the public API.
   - **api:bestemmingsplannen:all**: Full permissions for the bestemmingsplannen area of the public API.
   - **api:bodem:all**: Full permissions for the bodem area of the public API.
   - **api:buurt:all**: Full permissions for the buurt area of the public API.
   - **api:configuratie:all**: Full permissions for the configuratie area of the public API.
   - **api:callback:all**: Full permissions for the callback area of the public API.
   - **api:facturen:all**: Full permissions for the facturen area of the public API.
   - **api:fotos:all**: Full permissions for the fotos area of the public API.
   - **api:funderingen:all**: Full permissions for the funderingen area of the public API.
   - **api:rapporten:all**: Full permissions for the rapporten area of the public API.
   - **api:waarderingen:all**: Full permissions for the waarderingen area of the public API.
   - **api:adressen:read**: Read permissions for the adressen area of the public API.
   - **api:bestemmingsplannen:read**: Read permissions for the bestemmingsplannen area of the public API.
   - **api:bodem:read**: Read permissions for the bodem area of the public API.
   - **api:buurt:read**: Read permissions for the buurt area of the public API.
   - **api:configuratie:read**: Read permissions for the configuratie area of the public API.
   - **api:configuratie:write**: Write permissions for the configuratie area of the public API.
   - **api:callback:read**: Read permissions for the callback area of the public API.
   - **api:callback:write**: Write permissions for the callback area of the public API.
   - **api:facturen:read**: Read permissions for the facturen area of the public API.
   - **api:fotos:read**: Read permissions for the fotos area of the public API.
   - **api:funderingen:read**: Read permissions for the funderingen area of the public API.
   - **api:geldverstrekkers:read**: Read permissions for the geldverstrekkers area of the public API.
   - **api:rapporten:read**: Read permissions for the rapporten area of the public API.
   - **api:waarderingen:create**: Create permissions for the waarderingen area of the public API.
   - **api:waarderingen:patch**: Patch permissions for the waarderingen area of the public API.
   - **api:waarderingen:read**: Read permissions for the waarderingen area of the public API.
   - **api:waarderingen:ontwikkeling**: Read permissions for the ontwikkelingen endpoint in the waarderingen area of the public API.

  info@calcasa.nl

  If the OpenAPI document is large, imports in calcasa.api.apis and calcasa.api.models may fail with a
  RecursionError indicating the maximum recursion limit has been exceeded. In that case, there are a couple of solutions:
  Solution 1:
  Use specific imports for apis and models like:
  - `from calcasa.api.api.default_api import DefaultApi`
  - `from calcasa.api.model.pet import Pet`
  Solution 2:
  Before importing the package, adjust the maximum recursion limit as shown below:
  ```
  import sys
  sys.setrecursionlimit(1500)
  import calcasa.api
  from calcasa.api.apis import *
  from calcasa.api.models import *
  ```


pkgId: 155afdab41a9032c1a6891b0371faa04709ce9a314a6d207746dc7234a3c110f
name: python-calcipy
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Python package to simplify development
url: https://github.com/kyleking/calcipy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calcipy-4.1.0-1.src.rpm
checksum_type: sha256
description:
  ![./calcipy-banner-wide.svg](https://raw.githubusercontent.com/KyleKing/calcipy/main/docs/calcipy-banner-wide.svg)

  `calcipy` is a Python package that implements best practices such as code style (linting, auto-fixes), documentation, CI/CD, and logging. Like the calcium carbonate in hard coral, packages can be built on the `calcipy` foundation.

  `calcipy` has some configurability, but is tailored for my particular use cases. If you want the same sort of functionality, there are a number of alternatives to consider:

  - [pyscaffold](https://github.com/pyscaffold/pyscaffold) is a much more mature project that aims for the same goals, but with a slightly different approach and tech stack (tox vs. nox, cookiecutter vs. copier, etc.)
  - [tidypy](https://github.com/jayclassless/tidypy#features), [pylama](https://github.com/klen/pylama), and [codecheck](https://pypi.org/project/codecheck/) offer similar functionality of bundling and running static checkers, but makes far fewer assumptions
  - [pytoil](https://github.com/FollowTheProcess/pytoil) is a general CLI tool for developer automation
  - And many more such as [pyta](https://github.com/pyta-uoft/pyta), [prospector](https://github.com/PyCQA/prospector), [wemake-python-styleguide](https://github.com/wemake-services/wemake-python-styleguide) / [cjolowicz/cookiecutter-hypermodern-python](https://github.com/cjolowicz/cookiecutter-hypermodern-python), [formate](https://github.com/python-formate/formate), [johnthagen/python-blueprint](https://github.com/johnthagen/python-blueprint), [oxsecurity/megalinter](https://github.com/oxsecurity/megalinter), [trialandsuccess/su6](https://github.com/trialandsuccess/su6), etc.



  Calcipy needs a few static files managed using copier and a template project: [kyleking/calcipy_template](https://github.com/KyleKing/calcipy_template/)

  You can quickly use the template to create a new project or add calcipy to an existing one:

  ```sh

  pipx install copier


  copier copy gh:KyleKing/calcipy_template new_project
  cd new_project


  cd my_project
  copier copy gh:KyleKing/calcipy_template .
  copier update
  ```



  Additionally, `calcipy` can be run as a CLI application without adding the package as a dependency.

  Quick Start:

  ```sh

  pipx install 'calcipy[lint,tags]'


  calcipy-tags tags --help
  calcipy-tags tags --base-dir=~/path/to/my_project


  pipx list
  ```

  ```txt
  venvs are in ~/.local/pipx/venvs
  apps are exposed on your $PATH at ~/.local/bin
     package calcipy 1.4.0, installed using Python 3.11.4
      - calcipy
      - calcipy-lint
      - calcipy-pack
      - calcipy-tags
      - calcipy-types
  ```

  Note: the CLI output below is compressed for readability, but you can try running each of these commands locally to see the most up-to-date documentation and the full set of options. The "Usage", "Core options", and "Global Task Options" are the same for each subsequent command, so they are excluded for brevity.

  ```txt
  > calcipy-lint
  Usage: calcipy-lint [--core-opts] <subcommand> [--subcommand-opts] ...

  Core options:

    --complete                         Print tab-completion candidates for given parse remainder.
    --hide=STRING                      Set default value of run()'s 'hide' kwarg.
    --print-completion-script=STRING   Print the tab-completion script for your preferred shell (bash|zsh|fish).
    --prompt-for-sudo-password         Prompt user at start of session for the sudo.password config value.
    --write-pyc                        Enable creation of .pyc files.
    -d, --debug                        Enable debug output.
    -D INT, --list-depth=INT           When listing tasks, only show the first INT levels.
    -e, --echo                         Echo executed commands before running.
    -f STRING, --config=STRING         Runtime configuration file to use.
    -F STRING, --list-format=STRING    Change the display format used when listing tasks. Should be one of: flat (default), nested, json.
    -h [STRING], --help[=STRING]       Show core or per-task help and exit.
    -l [STRING], --list[=STRING]       List available tasks, optionally limited to a namespace.
    -p, --pty                          Use a pty when executing shell commands.
    -R, --dry                          Echo commands instead of running.
    -T INT, --command-timeout=INT      Specify a global command execution timeout, in seconds.
    -V, --version                      Show version and exit.
    -w, --warn-only                    Warn, instead of failing, when shell commands fail.

  Subcommands:

    lint.check (lint)   Run ruff as check-only.
    lint.fix            Run ruff and apply fixes.
    lint.pre-commit     Run pre-commit.
    lint.watch          Run ruff as check-only.

  Global Task Options:

    *file_args             List of Paths available globally to all tasks. Will resolve paths with working_dir
    --keep-going           Continue running tasks even on failure
    --working_dir=STRING   Set the cwd for the program. Example: "../run --working-dir .. lint test"
    -v,-vv,-vvv            Globally configure logger verbosity (-vvv for most verbose)

  > calcipy-pack

  Subcommands:

    pack.bump-tag                  Experiment with bumping the git tag using `griffe` (experimental).
    pack.check-licenses            Check licenses for compatibility with `licensecheck`.
    pack.install-extras            Run poetry install with all extras.
    pack.lock                      Ensure poetry.lock is  up-to-date.
    pack.publish                   Build the distributed format(s) and publish.
    pack.sync-pyproject-versions   Experiment with setting the pyproject.toml dependencies to the version from poetry.lock (experimental).

  > calcipy-tags

  Subcommands:

    tags.collect-code-tags (tags)   Create a `CODE_TAG_SUMMARY.md` with a table for TODO- and FIXME-style code comments.

  > calcipy-types

  Subcommands:

    types.mypy      Run mypy.
    types.pyright   Run pyright using the config in `pyproject.toml`.
  ```



  `calcipy` can also be used as a `pre-commit` task by adding the below snippet to your `pre-commit` file:

  ```yaml
  repos:
    - repo: https://github.com/KyleKing/calcipy
      rev: main
      hooks:
        - id: tags
        - id: lint-fix
        - id: types
  ```



  See the `Open Issues` and/or the [CODE_TAG_SUMMARY]. For release history, see the [CHANGELOG].



  We welcome pull requests! For your pull request to be accepted smoothly, we suggest that you first open a GitHub issue to discuss your idea. For resources on getting started with the code base, see the below documentation:

  - [DEVELOPER_GUIDE]
  - [STYLE_GUIDE]



  We follow the [Contributor Covenant Code of Conduct][contributor-covenant].



  We try to reasonably meet most aspects of the "OpenSSF scorecard" from [Open Source Insights](https://deps.dev/pypi/calcipy)



  If you have any security issue to report, please contact the project maintainers privately. You can reach us at [dev.act.kyle@gmail.com](mailto:dev.act.kyle@gmail.com).



  [LICENSE]

  [changelog]: https://calcipy.kyleking.me/docs/CHANGELOG
  [code_tag_summary]: https://calcipy.kyleking.me/docs/CODE_TAG_SUMMARY
  [contributor-covenant]: https://www.contributor-covenant.org
  [developer_guide]: https://calcipy.kyleking.me/docs/DEVELOPER_GUIDE
  [license]: https://github.com/kyleking/calcipy/blob/main/LICENSE
  [style_guide]: https://calcipy.kyleking.me/docs/STYLE_GUIDE


pkgId: 47aa5ab26ec39afc4cc0642e54fcbc093ad8239f5e97a4d18406ce0b96eb9714
name: python-calcipy
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: Python package to simplify development
url: https://github.com/kyleking/calcipy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calcipy-5.0.0-1.src.rpm
checksum_type: sha256
description:
  ![./calcipy-banner-wide.svg](https://raw.githubusercontent.com/KyleKing/calcipy/main/docs/calcipy-banner-wide.svg)

  `calcipy` is a Python package that implements best practices such as code style (linting, auto-fixes), documentation, CI/CD, and logging. Like the calcium carbonate in hard coral, packages can be built on the `calcipy` foundation.

  `calcipy` has some configurability, but is tailored for my particular use cases. If you want the same sort of functionality, there are a number of alternatives to consider:

  - [pyscaffold](https://github.com/pyscaffold/pyscaffold) is a much more mature project that aims for the same goals, but with a slightly different approach and tech stack (tox vs. nox, cookiecutter vs. copier, etc.)
  - [tidypy](https://github.com/jayclassless/tidypy#features), [pylama](https://github.com/klen/pylama), and [codecheck](https://pypi.org/project/codecheck/) offer similar functionality of bundling and running static checkers, but makes far fewer assumptions
  - [pytoil](https://github.com/FollowTheProcess/pytoil) is a general CLI tool for developer automation
  - And many more such as [pyta](https://github.com/pyta-uoft/pyta), [prospector](https://github.com/PyCQA/prospector), [wemake-python-styleguide](https://github.com/wemake-services/wemake-python-styleguide) / [cjolowicz/cookiecutter-hypermodern-python](https://github.com/cjolowicz/cookiecutter-hypermodern-python), [formate](https://github.com/python-formate/formate), [johnthagen/python-blueprint](https://github.com/johnthagen/python-blueprint), [oxsecurity/megalinter](https://github.com/oxsecurity/megalinter), [trialandsuccess/su6](https://github.com/trialandsuccess/su6), etc.



  Calcipy needs a few static files managed using copier and a template project: [kyleking/calcipy_template](https://github.com/KyleKing/calcipy_template/)

  You can quickly use the template to create a new project or add calcipy to an existing one:

  ```sh




  uvx copier copy gh:KyleKing/calcipy_template new_project
  cd new_project


  cd my_project
  uvx copier copy gh:KyleKing/calcipy_template .
  uvx copier update
  ```



  Additionally, `calcipy` can be run as a CLI application without adding the package as a dependency.

  Quick Start:

  ```sh

  uv tool install 'calcipy[lint,tags]'


  calcipy-tags tags --help
  calcipy-tags tags --base-dir=~/path/to/my_project
  ```

  Note: the CLI output below is compressed for readability, but you can try running each of these commands locally to see the most up-to-date documentation and the full set of options. The "Usage", "Core options", and "Global Task Options" are the same for each subsequent command, so they are excluded for brevity.

  ```txt
  > calcipy-lint
  Usage: calcipy-lint [--core-opts] <subcommand> [--subcommand-opts] ...

  Core options:

    --complete                         Print tab-completion candidates for given parse remainder.
    --hide=STRING                      Set default value of run()'s 'hide' kwarg.
    --print-completion-script=STRING   Print the tab-completion script for your preferred shell (bash|zsh|fish).
    --prompt-for-sudo-password         Prompt user at start of session for the sudo.password config value.
    --write-pyc                        Enable creation of .pyc files.
    -d, --debug                        Enable debug output.
    -D INT, --list-depth=INT           When listing tasks, only show the first INT levels.
    -e, --echo                         Echo executed commands before running.
    -f STRING, --config=STRING         Runtime configuration file to use.
    -F STRING, --list-format=STRING    Change the display format used when listing tasks. Should be one of: flat (default), nested, json.
    -h [STRING], --help[=STRING]       Show core or per-task help and exit.
    -l [STRING], --list[=STRING]       List available tasks, optionally limited to a namespace.
    -p, --pty                          Use a pty when executing shell commands.
    -R, --dry                          Echo commands instead of running.
    -T INT, --command-timeout=INT      Specify a global command execution timeout, in seconds.
    -V, --version                      Show version and exit.
    -w, --warn-only                    Warn, instead of failing, when shell commands fail.

  Subcommands:

    lint.check (lint)   Run ruff as check-only.
    lint.fix            Run ruff and apply fixes.
    lint.pre-commit     Run pre-commit.
    lint.watch          Run ruff as check-only.

  Global Task Options:

    *file_args             List of Paths available globally to all tasks. Will resolve paths with working_dir
    --keep-going           Continue running tasks even on failure
    --working_dir=STRING   Set the cwd for the program. Example: "../run --working-dir .. lint test"
    -v,-vv,-vvv            Globally configure logger verbosity (-vvv for most verbose)

  > calcipy-pack

  Subcommands:

    pack.bump-tag                  Experiment with bumping the git tag using `griffe` (experimental).
    pack.install-extras            Run poetry install with all extras.
    pack.lock                      Ensure poetry.lock is  up-to-date.
    pack.publish                   Build the distributed format(s) and publish.
    pack.sync-pyproject-versions   Experiment with setting the pyproject.toml dependencies to the version from poetry.lock (experimental).

  > calcipy-tags

  Subcommands:

    tags.collect-code-tags (tags)   Create a `CODE_TAG_SUMMARY.md` with a table for TODO- and FIXME-style code comments.

  > calcipy-types

  Subcommands:

    types.mypy      Run mypy.
    types.pyright   Run pyright using the config in `pyproject.toml`.
  ```



  `calcipy` can also be used as a `pre-commit` task by adding the below snippet to your `pre-commit` file:

  ```yaml
  repos:
    - repo: https://github.com/KyleKing/calcipy
      rev: main
      hooks:
        - id: tags
        - id: lint-fix
        - id: types
  ```



  See the `Open Issues` and/or the [CODE_TAG_SUMMARY]. For release history, see the [CHANGELOG].



  We welcome pull requests! For your pull request to be accepted smoothly, we suggest that you first open a GitHub issue to discuss your idea. For resources on getting started with the code base, see the below documentation:

  - [DEVELOPER_GUIDE]
  - [STYLE_GUIDE]



  We follow the [Contributor Covenant Code of Conduct][contributor-covenant].



  We try to reasonably meet most aspects of the "OpenSSF scorecard" from [Open Source Insights](https://deps.dev/pypi/calcipy)



  If you have any security issue to report, please contact the project maintainers privately. You can reach us at [dev.act.kyle@gmail.com](mailto:dev.act.kyle@gmail.com).



  [LICENSE]

  [changelog]: https://calcipy.kyleking.me/docs/CHANGELOG
  [code_tag_summary]: https://calcipy.kyleking.me/docs/CODE_TAG_SUMMARY
  [contributor-covenant]: https://www.contributor-covenant.org
  [developer_guide]: https://calcipy.kyleking.me/docs/DEVELOPER_GUIDE
  [license]: https://github.com/kyleking/calcipy/blob/main/LICENSE
  [style_guide]: https://calcipy.kyleking.me/docs/STYLE_GUIDE


pkgId: 4cf7fb5ecc2eac170ea02a757728e66614bf9b587d07018bfe16decf0558d9e3
name: python-calcu
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Very simple Python calculator for your terminal
url: https://pypi.org/project/calcu/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calcu-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![publish](https://github.com/carderne/calcu/actions/workflows/publish.yml/badge.svg)](https://github.com/carderne/calcu/actions/workflows/publish.yml)

  A simple calculator for your CLI.

  (It uses Python's `eval()` and spits out the result, with some prettifying.)

  ![example-gif](usage.gif)


  ```bash
  pip install calcu
  ```


  Type `c` followed by your expression.

  Example:
  ```bash
  c 2+2
               = 4
  ```

  Refer to the result of the previous calculation with an underscore `_`:
  ```bash
  c _+10
               = 14
  ```

  Do multiplication and exponentiation:
  ```bash
  c 2 x 3^2
               = 18



  ```

  And dividing and brackets:
  ```bash
  c [2+10]/10
               = 1.2



  ```

  Use any function from Python's `math` library:
  ```bash
  c log[e] x pi
               = 3.141592654
  ```

  It returns the appropriate number of decimal values, up to 9.

rpm_license:
  MIT License Copyright (c) 2020 Chris Arderne 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: 5d32dd3b39715a4f387c4f31259c0e030c60d525a9a28f09be62a2b47c674416
name: python-calculate-savings
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: How much can you save in 10 years by predicting your salary?
url: https://github.com/takenakayuuki0901/calculate_savings.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calculate-savings-0.1.4-1.src.rpm
checksum_type: sha256
description:
  __calculate-savings__<br>
  Using data from Japan's Monthly Survey of Labour Statistics, the salary in 10 years' time is predicted using scikit-learn linear regression from 55 years' salary. Based on this, the amount of savings in 10 years' time is predicted using cost of living and extra expenditure as inputs.

  __How to run calculate_savings__<br>
  $ calculate_savings

  __output__
  -  Savings till 10 years(yen): xxxxx
  -  result.png

  __Use of data__<br>
  出典：「毎月勤労統計調査」厚生労働省<br>
  https://www.e-stat.go.jp/stat-search/files?page=1&layout=datalist&toukei=00450071&tstat=000001011791&cycle=0&tclass1=000001035519&tclass2=000001144508&tclass3val=0


pkgId: 2f02794d9f8523c09500832c2a6c4b93d20d88bf76c79dafd86b465369740b41
name: python-calculator_ab
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A calculator.
url: https://pypi.org/project/calculator_ab/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calculator_ab-0.5.0-1.src.rpm
checksum_type: sha256
description:
  > Perform basic math operations

  [![PyPI Version][pypi-image]][pypi-url]


  `Calculator` performs:
   - addition
   - subraction
   - multiplication
   - division
   - n root of a number



  ```sh
  pip install calculator_ab
  ```



  Initializing the Calculator:
  ```python
  >>> from calculator_ab import Calculator
  >>> calculator = Calculator()
  ```

  An example of adding the number:
  ```python
  >>> calculator.add(5)
  ```

  An example of subtraction:
  ```python
  >>> calculator.subtract(4)
  ```

  An example of multiplication:
  ```python
  >>> calculator.multiply(2)
  ```

  An example of division:
  ```python
  >>> calculator.divide(3)
  ```

  An example of n root:
  ```python
  >>> calculator.n_root(2)
  ```

  Reseting the memory:
  ```python
  >>> calculator.reset()
  ```



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

  Make sure to add or update tests as appropriate.

  Use [Black](https://black.readthedocs.io/en/stable/) for code formatting and [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0-beta.4/) for commit messages.





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

  <!-- Badges -->

  [pypi-image]: https://img.shields.io/pypi/v/podsearch
  [pypi-url]: https://pypi.org/project/calculator_ab/


pkgId: 76798456267b0a1b152b6990b7da4bdb69cfed64b7753b9ed3d58d7175085162
name: python-caldav
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: CalDAV (RFC4791) client library
url: https://github.com/python-caldav/caldav
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-caldav-1.4.0-1.src.rpm
checksum_type: sha256
description:
  This project is a CalDAV ([RFC4791](http://www.ietf.org/rfc/rfc4791.txt)) client library for Python.

  Features:

   * create, modify calendar
   * create, update and delete event
   * search events by dates
   * etc.

  See the file [examples/basic_usage_examples.py](examples/basic_usage_examples.py) to get started.

  Links:

   * [Pypi](https://pypi.org/project/caldav)
   * [Documentation](docs/source/index.rst) - should be automatically mirrored on https://caldav.readthedocs.io/en/latest/

  Licences:

  Caldav is dual-licensed under the [GNU GENERAL PUBLIC LICENSE Version 3](COPYING.GPL) and the [Apache License 2.0](COPYING.APACHE).


pkgId: a18ccc07993c0373d09b0088b8a7580c0db2167299bf3f0eed1744d5cdc8d99e
name: python-calendly
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A Python wrapper for the Calendly API (https://developer.calendly.com/docs/)
url: https://github.com/kevteg/calendly-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-calendly-1.1.1-1.src.rpm
checksum_type: sha256
description:
  <a href="https://codeclimate.com/github/kevteg/calendly-python/maintainability"><img src="https://api.codeclimate.com/v1/badges/8d96f6b46f140f3d178b/maintainability" /></a> [![CircleCI](https://circleci.com/gh/kevteg/calendly-python/tree/master.svg?style=svg)](https://circleci.com/gh/kevteg/calendly-python/tree/master)


  Python package to use the [Calendly](http://calendly.com) API  🚀




      pip install calendly




  See [Calendly docs](https://developer.calendly.com/docs/getting-your-authentication-token) to get your auth token

      from calendly import Calendly
      calendly = Calendly(api_key)



  	calendly.echo()




      calendly.create_webhook('https://your-webhook.com', events=['canceled', 'invited'])

   - **Note:** the `events` variable is a list
   - **Note:** possible values are: `canceled` and `invited`
   - **Note:** by default the `events` list contains the 2 possible values



      calendly.get_webhook('webhook_id')



      calendly.list_webhooks()



      calendly.remove_webhook('webhook_id')

  - **Note**: the response will be `{'success': True}` if the webhook was successfully removed, otherwise it will be `{'success': False, "type": "calendly type", "message": "reason it failed"}`



      calendly.event_types()



      calendly.about()


  - **Note:** All the responses are dictionaries with the calendly response, except for the remove webhook method that also contains the `success` key. Check their [docs](https://developer.calendly.com/docs/) to know the possible responses!


  Next steps for this package:
  - [ ] Improve how the methods return the responses: proccess Calendly responses and make them objects, so that users can manage the information in an easier way
  - [ ] Support for version 2 <3
  - [ ] Creating reusable exceptions for error messages


