# packages

pkgId: de156e15179f3fe9f4cd50366ea6535d854333d4f4802273b05403633e2949a4
name: python-json-ld-test-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for json-ld-test
url: https://pypi.org/project/json-ld-test/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-json-ld-test-0.0.2-1.src.rpm
location_href: Packages/python-json-ld-test-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Makes it easy to test the conformance of your JSON-LD parser by providing the official JSON-LD test suite as a Python package.



  ```
  pip install json-ld-test
  ```



  ```python
  from json_ld_test import get_all_tests, get_test_file

  for test_case in get_all_tests():
      input = get_test_file(test_case.input)
      context = get_test_file(test_case.context)
      output = get_test_file(test_case.expected)
      assert parse_input(input, context) == output
  ```



  This repo also includes a LinkML schema for describing the official JSON-LD test suite.
  Feel free to re-use this for generating code that relates to these entities.



  API docs are available at **<https://multimeric.github.io/json-ld-test/>**.



  Use of the JSON-LD test suite, originally from https://w3c.github.io/json-ld-api/tests/ is licensed under the [W3C Software and Document License](https://www.w3.org/copyright/software-license-2023/).

rpm_license:
  MIT License  Copyright (c) 2024 Michael Milton  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: 0c40e1bfc498fb2c3ef3f8489ba6d621ca4a3cd0e5fa3038175150cae44b0928
name: python-json-repair-help
arch: noarch
version: 0.32.0
epoch: 0
release: 1
summary: Development documents and examples for json-repair
url: https://github.com/mangiucugna/json_repair/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-json-repair-0.32.0-1.src.rpm
location_href: Packages/python-json-repair-help-0.32.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2023 Stefano Baccianella  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: 52eb580b0f12e36da6804d2d47ac54566fbccb07b9ceb4dd7512ff410900ed30
name: python-json-trans-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for json-trans
url: https://github.com/liyown/json-trans
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-json-trans-0.1.1-1.src.rpm
location_href: Packages/python-json-trans-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  - 在保持结构的同时翻译JSON文件
  - 同时支持百度和谷歌翻译服务
  - 自动处理嵌套的JSON结构
  - 支持自定义翻译字段
  - 提供类型提示以获得更好的IDE支持
  - 全面的测试覆盖

  ```bash
  pip install json-trans
  ```


  ```python
  from json_trans import translate_json_baidu
  translate_json_baidu(
      input_file="input.json",
      output_file="output.json",
      app_id="your_baidu_app_id",
      secret_key="your_baidu_secret_key",
      fields_to_translate=["title", "content", "description"]  # Required | 必需
  )
  ```

  ```python
  from json_trans import translate_json_google
  translate_json_google(
      input_file="input.json",
      output_file="output.json",
      fields_to_translate=["summary", "details", "text"],  # Required | 必需
      credentials_path="path/to/google_credentials.json"  # Optional | 可选
  )
  ```


  ```python
  from json_trans import BaseTranslator, JsonTranslator
  class MyCustomTranslator(BaseTranslator):
      def translate_to_chinese(self, english_text: str) -> str:
          
          return translated_text

  translator = MyCustomTranslator()
  json_translator = JsonTranslator(
      translator,
      fields_to_translate=["title", "content", "description"]  # Required | 必需
  )
  json_translator.translate_json_file("input.json", "output.json")
  ```

  Input | 输入:
  ```json
  {
      "title": "Product Manual",
      "description": "User guide for the product",
      "content": "Detailed content here",
      "sections": [
          {
              "title": "Getting Started",
              "description": "How to begin",
              "text": "Step by step guide"
          }
      ]
  }
  ```
  Output (with `fields_to_translate=["description", "text"]`) | 输出:
  ```json
  {
      "title": "Product Manual",
      "description": "产品使用指南",
      "content": "Detailed content here",
      "sections": [
          {
              "title": "Getting Started",
              "description": "如何开始",
              "text": "分步指南"
          }
      ]
  }
  ```



  Main class for handling JSON translation.
  用于处理JSON翻译的主类。
  ```python
  translator = JsonTranslator(translator_instance)
  translator.translate_json_file(input_filename, output_filename)
  ```

  Implementation for Baidu Translation API.
  百度翻译API的实现。
  ```python
  translator = BaiduTranslator(app_id, secret_key)
  result = translator.translate_to_chinese(text)
  ```

  Implementation for Google Cloud Translation API.
  谷歌云翻译API的实现。
  ```python
  translator = GoogleTranslator(credentials_path=None)
  result = translator.translate_to_chinese(text)
  ```

  - `translate_json_baidu(input_file, output_file, app_id, secret_key)`
  - `translate_json_google(input_file, output_file, credentials_path=None)`


  1. Register at [Baidu Translate](http://api.fanyi.baidu.com/api/trans/product/desktop)
  2. Get your APP ID and Secret Key


pkgId: 4d78215d779f49cb7f72bf31215f3dc0db7efb57a81affd1e3dc3ae119d1bd10
name: python-json2rdf-help
arch: noarch
version: 4
epoch: 0
release: 1
summary: Development documents and examples for json2rdf
url: https://pypi.org/project/json2rdf/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-json2rdf-4-1.src.rpm
location_href: Packages/python-json2rdf-help-4-1.noarch.rpm
checksum_type: sha256
description:
  Converts JSON to RDF

  ```python
  >>> from json2rdf.json2rdf import j2r
  >>> j = {'id':0, 'list': [1,2,3], 'nesting': {'id':1, 'property': 'abc' }}
  >>> print(j2r(j))
  ```
  ```turtle
  prefix rdf:                   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
  prefix id:      <urn:example:id:>
  prefix prefix:     <urn:example:prefix:>
  prefix meta:    <urn:example:meta:>

  id:0 prefix:id 0.
  id:0 prefix:list _:2432178001088.
  id:0 prefix:nesting id:1.
  id:1 prefix:id 1.
  id:1 prefix:property "abc".
  _:2432178001088 rdf:_0 1.
  _:2432178001088 rdf:_1 2.
  _:2432178001088 rdf:_2 3.
  ```




  Motivation: This was developed as part of [BIM2RDF](https://github.com/PNNL/BIM2RDF) where the main implementation language is Python and the data sizes from [Speckle](https://app.speckle.systems/) are not small.

  * [Prior implementation](https://github.com/AtomGraph/JSON2RDF)  is in java.
  * Don't want to use [JSON-LD](https://json-ld.org/playground/)
  (mentioned in above [documentation](https://github.com/AtomGraph/JSON2RDF/blob/master/README.md)  ).
  Furthermore, the [Python JSON-LD implementation](https://github.com/digitalbazaar/pyld) was found to be too slow.




  Traversing the (nested) JSON, a conversion is applied to
  'expand' data containers, lists and mappings, as triples.





  is 'entity-driven': data containers must have identifiers.
  When no identifier is given, an anoymous/blank node is used.
  This is close to the 'spirit' of the semantic web.

  However, this makes the conversion non-deterministic.
  Reprecussions must be handled by the user.

  TODO: list vs arrays.



  Optional:
  * **'meta triples'** as RDF-star: `<<{data triple}>> {meta} <<{meta triple}>>`
  * **Numerical Arrays**: Numerical lists can be represented as numpy-encoded strings.
  (This was motivated by the storage of geometry data from 3D design programs).



  * **KISS**: It should only address converting (given) JSON to RDF.
  Converting array data (above) is a special case.
  * **Minimal dependencies**: follows from above.
  Zero dependencies is possible and ideal.
  (This would make it easier for a compiled Python version to be created for more performance.)
  * List representation shall not be a [linked list](https://ontola.io/blog/ordered-data-in-rdf).


pkgId: a6cee02ac1e3b3a165969c648fae931bfe58896d1edba1d255b863fe74f4f2f7
name: python-jsonargparse-help
arch: noarch
version: 4.35.0
epoch: 0
release: 1
summary: Development documents and examples for jsonargparse
url: https://pypi.org/project/jsonargparse/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jsonargparse-4.35.0-1.src.rpm
location_href: Packages/python-jsonargparse-help-4.35.0-1.noarch.rpm
checksum_type: sha256
description:
  Docs: https://jsonargparse.readthedocs.io/ | Source: https://github.com/omni-us/jsonargparse/
  ``jsonargparse`` is a library for creating command-line interfaces (CLIs) and
  making Python apps easily configurable. It is a well-maintained project with
  frequent releases, adhering to high standards of development: semantic
  versioning, deprecation periods, changelog, automated testing, and full test
  coverage.
  Although ``jsonargparse`` might not be widely recognized yet, it already boasts
  a `substantial user base
  <https://github.com/omni-us/jsonargparse/network/dependents>`__. Most notably,
  it serves as the framework behind pytorch-lightning's `LightningCLI
  <https://lightning.ai/docs/pytorch/stable/cli/lightning_cli.html>`__.

rpm_license:
  The MIT License (MIT)  Copyright (c) 2019-present, Mauricio Villegas <mauricio@omnius.com>  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: ce90c0594ed6c0e3f0fb63452c2e4af24729947056c64ad1ab4a17215296dab5
name: python-jsonmaestro-help
arch: noarch
version: 0.0.3.1
epoch: 0
release: 1
summary: Development documents and examples for jsonmaestro
url: https://github.com/gbowne1/json-maestro
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jsonmaestro-0.0.3.1-1.src.rpm
location_href: Packages/python-jsonmaestro-help-0.0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Python](https://img.shields.io/badge/Python-3.7%2B-blue?style=for-the-badge&logo=python)
  ![Pylance](https://img.shields.io/badge/Pylance-Enabled-brightgreen?style=for-the-badge&logo=visual-studio-code)
  ![Pytest](https://img.shields.io/badge/Pytest-Passing-success?style=for-the-badge&logo=pytest)
  ![License](https://img.shields.io/github/license/gbowne1/json-maestro?style=for-the-badge)
  ![Version](https://img.shields.io/pypi/v/jsonmaestro?style=for-the-badge)


  JSONMaestro is a powerful Python tool designed to clean, process, and optimize JSON-like files. It handles various operations such as removing comments, eliminating duplicates, adding schema keys, and sorting keys. This utility is particularly useful for developers working with configuration files, API responses, or any JSON-structured data that needs refinement.

  Key features:

  - Supports JSON, JSONC, and VSCode settings.json files
  - Removes duplicate keys and comments
  - Adds schema keys for improved structure
  - Offers flexible key sorting options
  - Preserves data integrity while cleaning

  JSONMaestro streamlines the process of preparing JSON data for further analysis or integration, making it an essential tool for data preprocessing and configuration management tasks.





  1. Clone the repository

  ```bash
  git clone https://github.com/gbowne1/json-maestro.git # via https
  git clone git@github.com:gbowne1/json-maestro.git # via ssh
  ```

  2. navigate to the cloned repository

  ```bash
  cd /path/to/cloned/json-maestro
  ```

  3. install requirements

  ```bash
  pip install -r requirements.txt
  pip install -r dev.requirements
  pip install --upgrade build
  ```

  4. build json maestro

  ```bash
  python3 -m build
  ```

  5. install json maestro using your prefered method (NOTE: both are shown here, either one should work)

  ```bash
  pip install .

  ```


  See [CONTRIBUTING.md](CONTRIBUTING.md)

  If you would like to work on issues and new features, we welcome your issues and Pull Requests.



  MIT

  [See the License](./LICENSE)


pkgId: 8914f9b1c72f7a3aa3246cf78d7f4d53495c4f4cce94c5568d4102642baa178b
name: python-jsonpickle-help
arch: noarch
version: 4.0.1
epoch: 0
release: 1
summary: Development documents and examples for jsonpickle
url: https://jsonpickle.readthedocs.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jsonpickle-4.0.1-1.src.rpm
location_href: Packages/python-jsonpickle-help-4.0.1-1.noarch.rpm
checksum_type: sha256
description:
  jsonpickle is a library for the two-way conversion of complex Python objects
  and `JSON <http://json.org/>`_.  jsonpickle builds upon existing JSON
  encoders, such as simplejson, json, and ujson.
     jsonpickle can execute arbitrary Python code.
     Please see the Security section for more details.
  For complete documentation, please visit the
  `jsonpickle documentation <http://jsonpickle.readthedocs.io/>`_.
  Bug reports and merge requests are encouraged at the
  `jsonpickle repository on github <https://github.com/jsonpickle/jsonpickle>`_.


pkgId: 3c1cea2e5fb0d7a30c35b3a7edfaf80cf25535a482c92401b479155bc05cb928
name: python-jsonschema-gentypes-help
arch: noarch
version: 2.9.2
epoch: 0
release: 1
summary: Development documents and examples for jsonschema-gentypes
url: https://github.com/camptocamp/jsonschema-gentypes
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jsonschema-gentypes-2.9.2-1.src.rpm
location_href: Packages/python-jsonschema-gentypes-help-2.9.2-1.noarch.rpm
checksum_type: sha256
description:
  kk
  Tools to generate Python types based on TypedDict from a JSON schema



  install:

  ```bash
  python3 -m pip install --user jsonschema-gentypes
  ```

  Convert a JSON schema to a Python file contains the types:

  ```bash
  jsonschema-gentypes --json-schema=<JSON schema> --python=<destination Python file>
  ```



  You can also write a config file named `jsonschema-gentypes.yaml` with:

  ```yaml
  headers: >
    

  callbacks:
    - - black
    - - isort
  generate:
    - # JSON schema file path
      source: jsonschema_gentypes/schema.json
      
      destination: jsonschema_gentypes/configuration.py
      
      root_name: Config
      
      api_arguments:
        additional_properties: Only explicit
      
      name_mapping: {}
      
      
      
      python_version: '3.11'
  ```

  And just run:

  ```bash
  jsonschema-gentypes
  ```



  The default values are exported in the Python file, then you can do something like that:

  ```python
  value_with_default = my_object.get('field_name', my_schema.FIELD_DEFAULT)
  ```



  Requires Python 3.8

  See the [issues with label "limitation"](https://github.com/camptocamp/jsonschema-gentypes/issues?q=is%3Aissue+is%3Aopen+label%3Alimitation).



  This project provides pre-commit hooks to automatically generate the files.

  ```yaml
  repos:
    - repo: https://github.com/camptocamp/jsonschema-gentypes
      rev: <version> # Use the ref you want to point at
      hools:
        - id: jsonschema-gentypes
          files: |
            (?x)^(
                jsonschema-gentypes\.yaml|
                <schema_path>\.json
            )$
  ```

  See also the pre_commit section in the configuration to run the pre-commit just after the generation, for example with:

  ```yaml
  pre_commit:
    enabled: true
    arguments:
      - --color=never
  ```



  We can also generate types for OpenAPI3 schemas (automatically detected).

  The result of our example in `tests/openapi3.json` can be used in pyramid with for example:

  ```python
  import pyramid.request
  from pyramid.view import view_config
  from openaoi3 import *

  def open_api(func):
      def wrapper(request: pyramid.request.Request, **kwargs) -> Any:
          typed_request = {}
          try:
              typed_request{'request_body'} = request.json
          except Exception as e:
              pass
          typed_request{'path'} = request.matchdict
          typed_request{'query'} = request.params

          return = func(request, request_typed=typed_request, **kwargs)

      return wrapper


  @view_config(route_name="route_name", renderer="json")
  @open_api
  def view(
    request: pyramid.request.Request,
    request_typed: OgcapiCollectionsCollectionidGet,
  ) -> OgcapiCollectionsCollectionidGetResponse:
      return {...}
  ```



  Install the pre-commit hooks:

  ```bash
  pip install pre-commit
  pre-commit install --allow-missing-config
  ```

  The `prospector` tests should pass.

  The code should be typed.

  The code should be tested with `pytests`.


pkgId: fa0851889ffe2fe54812de83b0d8a6c2a04a8730ef73bde6d440f4cccbd522c2
name: python-jsrm-help
arch: noarch
version: 0.0.14
epoch: 0
release: 1
summary: Development documents and examples for jsrm
url: https://github.com/tud-cor-sr/jax-soft-robot-modelling
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jsrm-0.0.14-1.src.rpm
location_href: Packages/python-jsrm-help-0.0.14-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains symbolic derivations of the kinematics and dynamics of various soft robots using Sympy.
  The symbolic expressions are then implemented in JAX and can be used for fast, parallelizable, and differentiable simulations.
  So far, we have focused on planar settings and implemented the following soft robots:

  - [N-link pendulum](examples/simulate_pendulum.py)
  - [Planar Piecewise Constant Strain (PCS) continuum soft robot](examples/simulate_planar_pcs.py)
  - [Planar Handed Shearing Auxetics (HSA) robot](examples/simulate_planar_hsa.py)

  We are happy to receive contributions for other soft robots and/or other settings (e.g., 3D).



  This simulator is part of the publication **An Experimental Study of Model-based Control
  for Planar Handed Shearing Auxetics Robots** presented at the _18th International Symposium on Experimental Robotics_.
  You can find the publication online in the Springer Proceedings on Advanced Robotics (SPAR): https://doi.org/10.1007/978-3-031-63596-0_14

  Please use the following citation if you use our software in your (scientific) work:

  ```bibtex
  @inproceedings{stolzle2023experimental,
    title={An experimental study of model-based control for planar handed shearing auxetics robots},
    author={St{\"o}lzle, Maximilian and Rus, Daniela and Della Santina, Cosimo},
    booktitle={International Symposium on Experimental Robotics},
    pages={153--167},
    year={2023},
    organization={Springer}
  }
  ```



  The plugin can be installed from PyPI:

  ```bash
  pip install jsrm
  ```

  or locally from the source code:

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

  If you want to run the examples, you will also need to install the following dependencies:

  ```bash
  pip install -e ".[examples]"
  ```



  Always first source all necessary environment variables when opening a new terminal:

  ```bash
  source 01-configure-env-vars.sh
  ```

  Then, we can symbolically derive the pendulum kinematics and dynamics:

  ```bash
  python examples/derive_pendulum.py
  ```

  Finally, we can simulate the pendulum
  ```bash
  python examples/simulate_pendulum.py
  ```



  You might also be interested in the following repositories:
   - The [`jax-spcs-kinematics`](https://github.com/tud-phi/jax-spcs-kinematics) repository contains an implementation
   of the Selective Piecewise Constant Strain (SPCS) kinematics in JAX. We have shown in our paper that this kinematic
  model is suitable for representing the shape of HSA rods.
   - The [`HSA-PyElastica`](https://github.com/tud-phi/HSA-PyElastica) repository contains a plugin for PyElastica
  for the simulation of HSA robots.
   - The [`hsa-planar-control`](https://github.com/tud-phi/hsa-planar-control) repository contains JAX and ROS2 implementations
   of model-based control algorithms for planar HSA robots.

rpm_license:
  Copyright (c) 2016 The Python Packaging Authority (PyPA)  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: c90e9476073f1053b55b2dff1764e567644a673f4020c4fb240f099f4918b7b4
name: python-jsslib-help
arch: noarch
version: 1.0.17
epoch: 0
release: 1
summary: Development documents and examples for jsslib
url: https://pypi.org/project/jsslib/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jsslib-1.0.17-1.src.rpm
location_href: Packages/python-jsslib-help-1.0.17-1.noarch.rpm
checksum_type: sha256
description:
  JSON Structure Search library

  Example
  ```
  from jsslib import JSS

  jss = JSS()

  jss.LoadTable('./lang/table/table.lst')

  print(jss.RunSql("SELECT TOP 10 id, Zi FROM zi WHERE PinYin = 'ding1' and id > 2;"))
  ```

  Output
  ```
  [{'Zi': '丁', 'id': 4}, {'Zi': '灯', 'id': 2077}, {'Zi': '钉', 'id': 3123}, {'Zi': '仃', 'id': 3426}, {'Zi': '叮', 'id': 3725}, {'Zi': '町', 'id': 5646}, {'Zi': '盯', 'id': 5756}, {'Zi': '酊', 'id': 7027}, {'Zi': '玎', 'id': 7917}]
  ```


pkgId: 3303b2a011d667a35390451aeee13b1ce9251072e00afec447a5d4a76272f07a
name: python-jstreams-help
arch: noarch
version: 1.0.12
epoch: 0
release: 1
summary: Development documents and examples for jstreams
url: https://github.com/ctrohin/jstream
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jstreams-1.0.12-1.src.rpm
location_href: Packages/python-jstreams-help-1.0.12-1.noarch.rpm
checksum_type: sha256
description:
  jstreams is a Python library aiming to replicate the Java Streams and Optional functionality. The library is implemented with type safety in mind.



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install jstream.

  ```bash
  pip install jstreams
  ```





  ```python
  from jstreams import Stream


  print(Stream(["Test", "Best", "Lest"]).map(str.upper).collect())



  print(Stream(["Test", "Best", "Lest"])
              .filter(lambda s: s.startswith("T"))
              .collect())



  print(Stream(["Test", "Best", "Lest"])
              .filter(lambda s: s.startswith("T"))
              .isNotEmpty())



  print(Stream(["Test", "Best", "Lest"]).allMatch(lambda s: s.endswith("est")))


  print(Stream(["Test", "Best", "Lest"]).allMatch(lambda s: s.startswith("T")))



  print(Stream(["Test", "Best", "Lest"]).anyMatch(lambda s: s.startswith("T")))



  print(Stream(["Test", "Best", "Lest"]).noneMatch(lambda s: s.startswith("T")))



  print(Stream(["Test", "Best", "Lest"])
              .findFirst(lambda s: s.startswith("L"))
              .getActual())



  print(Stream(["Test", "Best", "Lest"]).first())




  print(Stream(["Test1", "Test2", 1, 2])
              .filter(lambda el: el == "Test1")
              
              .cast(str)
              .first())



  print(Stream([["a", "b"], ["c", "d"]]).flatMap(list).toList())





  print(Stream([1, 2, 3, 4, 20, 5, 6]).reduce(max).getActual())



  print(Stream(["A", None, "B", None, None, "C", None, None]).nonNull().toList())


  ```


  ```python
  from jstreams import Opt


  Opt(None).isPresent() # Will return False
  Opt("test").isPresent() # Will return True





  Opt("test").get() # Does not fail, and returns the string "test"
  Opt(None).get() # Raises ValueError since None cannot be casted to any type
  Opt(None).getActual() # Returns None, does not raise value error


  Opt("test").ifPresent(lambda s: print(s)) # Will print "test"
  Opt(None).ifPresent(lambda s: print(s)) # Does nothing, since the object is None


  Opt("test").getOrElse("test1") # Will return "test", since the value is not None
  Opt(None).getOrElse("test1") # Will return "test1", since the value is  None



  Opt("test").getOrElseGet(lambda: "test1") # Will return "test", since the value is not None
  Opt(None).getOrElseGet(lambda: "test1") # Will return "test1", since the value is  None


  Opt("test").stream() # Is equivalent with Stream(["test"])
  Opt(["test"]).stream() # Is equivalent with Stream([["test"]]). Notice the list stacking



  Opt("test").flatStream() # Is equivalent with Stream(["test"])
  Opt(["test", "test1", "test2"]).flatStream() # Is equivalent with Stream(["test", "test1", "test2"])

  ```


  ```python


  def throwErr() -> None:
      raise ValueError("Test")

  def returnStr() -> str:
      return "test"


  Try(throwErr).onFailure(lambda e: print(e)).get() # The onFailure is called

  Try(returnStr).andThen(lambda s: print(s)).get() # Will print out "test"



  Try.of("test").andThen(lambda s: print(s)).get() # Will print out "test"
  ```



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


pkgId: 03fa217387baf172d38bf3a121dba7d8ef2c832dbe508fda2377110082e281aa
name: python-ju-help
arch: noarch
version: 0.1.16
epoch: 0
release: 1
summary: Development documents and examples for ju
url: https://pypi.org/project/ju/
rpm_license: apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ju-0.1.16-1.src.rpm
location_href: Packages/python-ju-help-0.1.16-1.noarch.rpm
checksum_type: sha256
description:
  JSON schema Utils

  To install:	```pip install ju```

  [Documentation](https://i2mint.github.io/ju/)






  You have tools to extract JSON schema information from python objects, as well as
  to create python objects from them.


      >>> from ju import signature_to_json_schema, json_schema_to_signature
      >>>
      >>>
      >>> def earth(north: str, south: bool, east: int = 1, west: float = 2.0):
      ...     """Earth docs"""
      ...     return f'{north=}, {south=}, {east=}, {west=}'
      ...
      >>> schema = signature_to_json_schema(earth)
      >>> assert schema == {
      ...     'description': 'Earth docs',
      ...     'title': 'earth',
      ...     'type': 'object',
      ...     'properties': {
      ...         'north': {'type': 'string'},
      ...         'south': {'type': 'boolean'},
      ...         'east': {'type': 'integer', 'default': 1},
      ...         'west': {'type': 'number', 'default': 2.0},
      ...     },
      ...     'required': ['north', 'south'],
      ... }
      >>>
      >>> sig = json_schema_to_signature(schema)
      >>> sig
      <Sig (north: str, south: bool, east: int = 1, west: float = 2.0)>
      >>> sig.name
      'earth'
      >>> sig.docs
      'Earth docs'




  You can get a [react-jsonschema-form (rjsf)](https://github.com/rjsf-team/react-jsonschema-form)
  specification
  (see the [rjsf playground](https://rjsf-team.github.io/react-jsonschema-form/))
  from a python function.


      >>> def foo(
          ...     a_bool: bool,
          ...     a_float=3.14,
          ...     an_int=2,
          ...     a_str: str = 'hello',
          ...     something_else=None
          ... ):
          ...     '''A Foo function'''
          >>>
          >>> form_spec = func_to_form_spec(foo)
          >>> assert form_spec == {
          ...     'rjsf': {
          ...         'schema': {
          ...             'title': 'foo',
          ...             'type': 'object',
          ...             'properties': {
          ...                 'a_bool': {'type': 'boolean'},
          ...                 'a_float': {'type': 'number', 'default': 3.14},
          ...                 'an_int': {'type': 'integer', 'default': 2},
          ...                 'a_str': {'type': 'string', 'default': 'hello'},
          ...                 'something_else': {'type': 'string', 'default': None}
          ...             },
          ...             'required': ['a_bool'],
          ...             'description': 'A Foo function'
          ...         },
          ...         'uiSchema': {
          ...             'ui:submitButtonOptions': {
          ...                 'submitText': 'Run'
          ...             },
          ...             'a_bool': {'ui:autofocus': True}
          ...         },
          ...         'liveValidate': False,
          ...         'disabled': False,
          ...         'readonly': False,
          ...         'omitExtraData': False,
          ...         'liveOmit': False,
          ...         'noValidate': False,
          ...         'noHtml5Validate': False,
          ...         'focusOnFirstError': False,
          ...         'showErrorList': 'top'
          ...     }
          ... }




  Represents a collection of routes in an OpenAPI specification.

  Each instance of this class contains a list of `Route` objects, which can be accessed and manipulated as needed.


      >>> from yaml import safe_load
      >>> spec_yaml = '''
      ... openapi: 3.0.3
      ... paths:
      ...   /items:
      ...     get:
      ...       summary: List items
      ...       responses:
      ...         '200':
      ...           description: An array of items
      ...     post:
      ...       summary: Create item
      ...       responses:
      ...         '201':
      ...           description: Item created
      ... '''
      >>> spec = safe_load(spec_yaml)
      >>> routes = Routes(spec)
      >>> len(routes)
      2
      >>> list(routes)
      [('get', '/items'), ('post', '/items')]
      >>> r = routes['get', '/items']
      >>> r
      Route(method='get', endpoint='/items')
      >>> r.method_data
      {'summary': 'List items', 'responses': {'200': {'description': 'An array of items'}}}


pkgId: 9f8cb19924dff15ec1a28e332a53b5d4a21aea6ae45d13abed9e66c457629480
name: python-judges-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for judges
url: https://pypi.org/project/judges/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-judges-0.0.4-1.src.rpm
location_href: Packages/python-judges-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  | Judge Type | Category                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                              | Reference Paper                                                                                                                                                             | Python Import                                                                                                                           |
  |------------|--------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
  | grader     | Factual Correctness            | Evaluates the correctness of a response in an Absolute Grading setting, according to a scoring rubric.                                                                                                                                                                                                                                                                                                                                 | [Prometheus: Inducing Fine-grained Evaluation Capability in Language Models](https://arxiv.org/abs/2310.08491)                                                               | `from judges.graders.correctness import PrometheusAbsoluteCoarseCorrectness`                                                        |
  | grader     | Empathy Evaluation             | Evaluates the response of a model based on its ability to recognize implicit emotions in a statement, using a 3-point scale.                                                                                                                                                                                                                                                                                                                  | [EmotionQueen: A Benchmark for Evaluating Empathy of Large Language Models](https://arxiv.org/abs/2409.13359)                                                             | `from judges.graders.empathy import EmotionQueenImplicitEmotionRecognition`                                                          |
  | grader     | Empathy Evaluation             | Evaluates the response of a model based on its ability to recognize the hidden intention in a statement, using a 3-point scale.                                                                                                                                                                                                                                                                                                                   | [EmotionQueen: A Benchmark for Evaluating Empathy of Large Language Models](https://arxiv.org/abs/2409.13359)                                                             | `from judges.graders.empathy import EmotionQueenIntentionRecognition`                                                               |
  | grader     | Empathy Evaluation             | Evaluates the response of a model based on its ability to recognize the key event in a statement, using a 3-point scale.                                                                                                                                                                                                                                                                                                                              | [EmotionQueen: A Benchmark for Evaluating Empathy of Large Language Models](https://arxiv.org/abs/2409.13359)                                                             | `from judges.graders.empathy import EmotionQueenKeyEventRecognition`                                                                 |
  | grader     | Empathy Evaluation             | Evaluates the response of a model based on its ability to recognize both the significant and trivial events in a statement, using a 3-point scale.                                                                                                                                                                                                                                                                                                | [EmotionQueen: A Benchmark for Evaluating Empathy of Large Language Models](https://arxiv.org/abs/2409.13359)                                                             | `from judges.graders.empathy import EmotionQueenMixedEventRecognition`                                                               |
  | grader     | Information Coverage Evaluation | Determines whether a specific reference insight is fully, partially, or not covered within a provided list of bullet points, ensuring comprehensive coverage of key information.                                                                                                                                                                                                                                                                 | [Summary of a Haystack: A Challenge to Long-Context LLMs and RAG Systems](https://arxiv.org/abs/2407.01370)                                                                 | `from judges.graders.information_coverage import HaystackBulletPointCoverageCorrectness`                                               |
  | grader     | Content Moderation             | Categorizes user input texts into predefined categories such as hate, self-harm, sexual content, etc., determining the appropriate category based on the content's nature and intent.                                                                                                                                                                                                                                                       | [OR-Bench: An Over-Refusal Benchmark for Large Language Models](https://arxiv.org/abs/2405.20947)                                                                        | `from judges.graders.moderator import ORBenchUserInputModeration`                                                                   |
  | grader     | Content Moderation             | Classifies model output texts into one of eleven predefined categories related to content sensitivity and appropriateness, ensuring responses adhere to ethical and safety guidelines.                                                                                                                                                                                                                                                 | [OR-Bench: An Over-Refusal Benchmark for Large Language Models](https://arxiv.org/abs/2405.20947)                                                                        | `from judges.graders.moderator import ORBenchUserOutputModeration`                                                                  |
  | grader     | Query Quality Evaluation       | Assesses the quality of user queries based on clarity, specificity, and coherence, ensuring that queries are well-structured to facilitate accurate and relevant responses.                                                                                                                                                                                                                                                                  | [Magpie: Alignment Data Synthesis from Scratch by Prompting Aligned LLMs with Nothing](https://api.semanticscholar.org/CorpusID:270391432)                                   | `from judges.graders.query_quality import MagpieQueryQuality`                                                                         |
  | grader     | Refusal Evaluation             | Classifies AI assistant responses into direct_answer, direct_refusal, or indirect_refusal, evaluating whether the assistant appropriately refuses to answer certain prompts based on ethical guidelines.                                                                                                                                                                                                                                         | [Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena](https://arxiv.org/abs/2306.05685)                                                                               | `from judges.graders.refusal_detection import ORBenchRefusalDetection`                                                                 |
  | grader     | Relevance Evaluation           | Evaluates the relevance of a passage to a query based on a four-point scale: Irrelevant, Related, Highly relevant, Perfectly relevant. Ensures that the passage adequately addresses the query with varying degrees of relevance.                                                                                                                                                                                                          | [Reliable Confidence Intervals for Information Retrieval Evaluation Using Generative A.I.](https://doi.org/10.1145/3637528.3671883)                                         | `from judges.graders.relevance import ReliableCIRelevance`                                                                             |


pkgId: a99351288f8bf43ddaae3337bcda76731bdec46a57e6db3bf57f1ba49dc50026
name: python-juju-help
arch: noarch
version: 3.6.1.0
epoch: 0
release: 1
summary: Development documents and examples for juju
url: https://juju.is/docs/sdk
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-juju-3.6.1.0-1.src.rpm
location_href: Packages/python-juju-help-3.6.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Source code: https://github.com/juju/python-libjuju
  Bug reports: https://github.com/juju/python-libjuju/issues
  Documentation: https://pythonlibjuju.readthedocs.io/en/latest/
  Supported Python versions: 3.8 through 3.13
  Supported Juju versions: 3.1 through 3.6

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 Canonical Ltd.  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: 262ba50f9197cdd0f2879714be96af48133353b9dda56a2d2dd42cf20c79c4fc
name: python-jukebox-fm-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for jukebox-fm
url: https://github.com/polarhive/jukebox
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jukebox-fm-0.2.1-1.src.rpm
location_href: Packages/python-jukebox-fm-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Play LastFM music recommendations using: mpd, yt-dlp and python



  ```sh
  curl -fsSL https://raw.githubusercontent.com/polarhive/jukebox/refs/heads/main/setup.sh | bash
  ```

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright © 2007 Free Software Foundation, Inc. <http://fsf.org/>  Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  “This License” refers to version 3 of the GNU General Public License.  “Copyright” also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  “The Program” refers to any copyrightable work licensed under this License. Each licensee is addressed as “you”. “Licensees” and “recipients” may be individuals or organizations.  To “modify” a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a “modified version” of the earlier work or a work “based on” the earlier work.  A “covered work” means either the unmodified Program or a work based on the Program.  To “propagate” a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To “convey” a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays “Appropriate Legal Notices” to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code. The “source code” for a work means the preferred form of the work for making modifications to it. “Object code” means any non-source form of a work.  A “Standard Interface” means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The “System Libraries” of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A “Major Component”, in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The “Corresponding Source” for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to “keep intact all notices”.  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an “aggregate” if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A “User Product” is either (1) a “consumer product”, which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, “normally used” refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  “Installation Information” for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms. “Additional permissions” are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered “further restrictions” within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License.  An “entity transaction” is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents. A “contributor” is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's “contributor version”.  A contributor's “essential patent claims” are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, “control” includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a “patent license” is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To “grant” such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. “Knowingly relying” means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is “discriminatory” if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License “or any later version” applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the “copyright” line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) <year>  <name of author> This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an “about box”.  You should also get your employer (if you work as a programmer) or school, if any, to sign a “copyright disclaimer” for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <http://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.


pkgId: d9b6de672baf236a7f543c246f68cd19f96bf5aeeef83b9544bfa383fbd2e7f7
name: python-julep-help
arch: noarch
version: 1.46.1
epoch: 0
release: 1
summary: Development documents and examples for julep
url: https://github.com/julep-ai/python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-julep-1.46.1-1.src.rpm
location_href: Packages/python-julep-help-1.46.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/julep.svg)](https://pypi.org/project/julep/)

  The Julep Python library provides convenient access to the Julep REST API from any Python 3.8+
  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.julep.ai](https://docs.julep.ai/). The full API of this library can be found in [api.md](https://github.com/julep-ai/python-sdk/tree/main/api.md).



  ```sh

  pip install julep
  ```



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

  ```python
  import os
  from julep import Julep

  client = Julep(
      api_key=os.environ.get("JULEP_API_KEY"),  # This is the default and can be omitted
      
      environment="production",
  )

  resource_created = client.tasks.create(
      agent_id="dad00000-0000-4000-a000-000000000000",
      main=[{"evaluate": {"foo": ["string"]}}],
      name="name",
  )
  print(resource_created.id)
  ```

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



  Simply import `AsyncJulep` instead of `Julep` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from julep import AsyncJulep

  client = AsyncJulep(
      api_key=os.environ.get("JULEP_API_KEY"),  # This is the default and can be omitted
      
      environment="production",
  )


  async def main() -> None:
      resource_created = await client.tasks.create(
          agent_id="dad00000-0000-4000-a000-000000000000",
          main=[{"evaluate": {"foo": ["string"]}}],
          name="name",
      )
      print(resource_created.id)


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



  List methods in the Julep API are paginated.

  This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:

  ```python
  from julep import Julep

  client = Julep()

  all_agents = []

  for agent in client.agents.list(
      limit=100,
      offset=0,
  ):
      
      all_agents.append(agent)
  print(all_agents)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from julep import AsyncJulep

  client = AsyncJulep()


  async def main() -> None:
      all_agents = []
      
      async for agent in client.agents.list(
          limit=100,
          offset=0,
      ):
          all_agents.append(agent)
      print(all_agents)


  asyncio.run(main())
  ```

  Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:

  ```python
  first_page = await client.agents.list(
      limit=100,
      offset=0,
  )
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.items)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.agents.list(
      limit=100,
      offset=0,
  )
  for agent in first_page.items:
      print(agent.id)


  ```



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

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

  All errors inherit from `julep.APIError`.

  ```python
  import julep
  from julep import Julep

  client = Julep()

  try:
      client.agents.create_or_update(
          agent_id="dad00000-0000-4000-a000-000000000000",
          instructions=["Protect Leia", "Kick butt"],
          model="o1-preview",
          name="R2D2",
      )
  except julep.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except julep.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except julep.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 5 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 julep import Julep


  client = Julep(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).agents.create_or_update(
      agent_id="dad00000-0000-4000-a000-000000000000",
      instructions=["Protect Leia", "Kick butt"],
      model="o1-preview",
      name="R2D2",
  )
  ```



  By default requests time out after 2 minutes. 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 julep import Julep


  client = Julep(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).agents.create_or_update(
      agent_id="dad00000-0000-4000-a000-000000000000",
      instructions=["Protect Leia", "Kick butt"],
      model="o1-preview",
      name="R2D2",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/julep-ai/python-sdk/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 `JULEP_LOG` to `info`.

  ```shell
  $ export JULEP_LOG=info
  ```

  Or to `debug` for more verbose logging.



  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 julep import Julep

  client = Julep()
  response = client.agents.with_raw_response.create_or_update(
      agent_id="dad00000-0000-4000-a000-000000000000",
      instructions=["Protect Leia", "Kick butt"],
      model="o1-preview",
      name="R2D2",
  )
  print(response.headers.get('X-My-Header'))

  agent = response.parse()  # get the object that `agents.create_or_update()` would have returned
  print(agent.id)
  ```

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

  The async client returns an [`AsyncAPIResponse`](https://github.com/julep-ai/python-sdk/tree/main/src/julep/_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.agents.with_streaming_response.create_or_update(
      agent_id="dad00000-0000-4000-a000-000000000000",
      instructions=["Protect Leia", "Kick butt"],
      model="o1-preview",
      name="R2D2",
  ) 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](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from julep import Julep, DefaultHttpxClient

  client = Julep(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="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/julep-ai/python-sdk/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 julep
  print(julep.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/julep-ai/python-sdk/tree/main/./CONTRIBUTING.md).


pkgId: 33aa5bc73988d90022f7344f03492131d6e3ec64adc9e6f5d350889aedf1a671
name: python-jupyter-events-help
arch: noarch
version: 0.11.0
epoch: 0
release: 1
summary: Development documents and examples for jupyter-events
url: http://jupyter.org
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyter-events-0.11.0-1.src.rpm
location_href: Packages/python-jupyter-events-help-0.11.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/jupyter/jupyter_events/actions/workflows/python-tests.yml/badge.svg?query=branch%3Amain++)](https://github.com/jupyter/jupyter_events/actions/workflows/python-tests.yml/badge.svg?query=branch%3Amain++)
  [![Documentation Status](https://readthedocs.org/projects/jupyter-events/badge/?version=latest)](http://jupyter-events.readthedocs.io/en/latest/?badge=latest)

  _An event system for Jupyter Applications and extensions._

  Jupyter Events enables Jupyter Python Applications (e.g. Jupyter Server, JupyterLab Server, JupyterHub, etc.) to emit **events**—structured data describing things happening inside the application. Other software (e.g. client applications like JupyterLab) can _listen_ and respond to these events.



  Install Jupyter Events directly from PyPI:

  ```
  pip install jupyter_events
  ```

  or conda-forge:

  ```
  conda install -c conda-forge jupyter_events
  ```



  Documentation is available at [jupyter-events.readthedocs.io](https://jupyter-events.readthedocs.io).



  The Jupyter Development Team is the set of all contributors to the Jupyter project.
  This includes all of the Jupyter subprojects.

  The core team that coordinates development on GitHub can be found here:
  https://github.com/jupyter/.



  Jupyter uses a shared copyright model. Each contributor maintains copyright
  over their contributions to Jupyter. But, it is important to note that these
  contributions are typically only changes to the repositories. Thus, the Jupyter
  source code, in its entirety is not the copyright of any single person or
  institution. Instead, it is the collective copyright of the entire Jupyter
  Development Team. If individual contributors want to maintain a record of what
  changes/contributions they have specific copyright on, they should indicate
  their copyright in the commit message of the change, when they commit the
  change to one of the Jupyter repositories.

  With this in mind, the following banner should be used in any source code file
  to indicate the copyright and license terms:

  ```


  ```

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


pkgId: 7017259f81c9bc7db209ffc36e31786c5b41b179974940ba219ebdee898f2985
name: python-jupyter-jsc-custom-help
arch: noarch
version: 0.11.8
epoch: 0
release: 1
summary: Development documents and examples for jupyter-jsc-custom
url: https://pypi.org/project/jupyter-jsc-custom/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyter-jsc-custom-0.11.8-1.src.rpm
location_href: Packages/python-jupyter-jsc-custom-help-0.11.8-1.noarch.rpm
checksum_type: sha256
rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Forschungszentrum Juelich GmbH  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 74d83f4f01b7465728064e022911d4b16c8744884f20d1b76b818d62f97c6d14
name: python-jupyter-kernel-client-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for jupyter-kernel-client
url: https://pypi.org/project/jupyter-kernel-client/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyter-kernel-client-0.4.0-1.src.rpm
location_href: Packages/python-jupyter-kernel-client-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  <!--
    ~ Copyright (c) 2023-2024 Datalayer, Inc.
    ~
    ~ BSD 3-Clause License
  -->

  [![Datalayer](https://assets.datalayer.tech/datalayer-25.svg)](https://datalayer.io)

  [![Become a Sponsor](https://img.shields.io/static/v1?label=Become%20a%20Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=1ABC9C)](https://github.com/sponsors/datalayer)



  [![Github Actions Status](https://github.com/datalayer/jupyter-kernel-client/workflows/Build/badge.svg)](https://github.com/datalayer/jupyter-kernel-client/actions/workflows/build.yml)
  [![PyPI - Version](https://img.shields.io/pypi/v/jupyter-kernel-client)](https://pypi.org/project/jupyter-kernel-client)

  Jupyter Kernel Client allows you to connect via WebSocket and HTTP to Jupyter Kernels. It also provide a easy to use interactive Konsole (console for **K**ernels).

  To install the library, run the following command.

  ```sh
  pip install jupyter_kernel_client
  ```



  Check you have a Jupyter Server with ipykernel running somewhere. You can install those packages using:

  ```sh
  pip install jupyter-server ipykernel
  ```



  1. Start a Jupyter Server.

  ```sh
  jupyter server --port 8888 --IdentityProvider.token MY_TOKEN
  ```

  2. Launch `python` in a terminal and execute the following snippet (update the server_url and token).

  ```py
  import os

  from platform import node
  from jupyter_kernel_client import KernelClient


  with KernelClient(server_url="http://localhost:8888", token="MY_TOKEN") as kernel:
      reply = kernel.execute(
          """import os
  from platform import node
  print(f"Hey {os.environ.get('USER', 'John Smith')} from {node()}.")
  """
      )
      assert reply["execution_count"] == 1
      assert reply["outputs"] == [
          {
              "output_type": "stream",
              "name": "stdout",
              "text": f"Hey {os.environ.get('USER', 'John Smith')} from {node()}.\n",
          }
      ]
      assert reply["status"] == "ok"
  ```



  This package can be used to open a Jupyter Console to a Jupyter Kernel 🐣.

  1. Install the optional dependencies.

  ```sh
  pip install jupyter-kernel-client[konsole]
  ```

  2. Start a Jupyter Server.

  ```sh
  jupyter server --port 8888 --IdentityProvider.token MY_TOKEN
  ```

  3. Start the konsole and execute code.

  ```sh
  jupyter konsole --url http://localhost:8888 --token MY_TOKEN
  ```

  ```sh
  [KonsoleApp] KernelHttpManager created a new kernel: ...
  Jupyter Kernel console 0.2.0

  Python 3.12.7 | packaged by conda-forge | (main, Oct  4 2024, 16:05:46) [GCC 13.3.0]
  Type 'copyright', 'credits' or 'license' for more information
  IPython 8.30.0 -- An enhanced Interactive Python. Type '?' for help.

  In [1]: print("hello")
  hello

  In [2]:
  ```



  To remove the library, execute:

  ```sh
  pip uninstall jupyter_kernel_client
  ```





  ```sh




  pip install -e ".[konsole,test,lint,typing]"
  ```



  Install dependencies:

  ```sh
  pip install -e ".[test]"
  ```

  To run the python tests, use:

  ```sh
  pytest
  ```



  ```sh
  pip uninstall jupyter_kernel_client
  ```



  See [RELEASE](RELEASE.md)

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


pkgId: e397ea40e43f44d1e2ca6cba12ef0eec98b5472c3c2bc9f7957487835478d393
name: python-jupyter-nbmodel-client-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for jupyter-nbmodel-client
url: https://pypi.org/project/jupyter-nbmodel-client/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyter-nbmodel-client-0.4.0-1.src.rpm
location_href: Packages/python-jupyter-nbmodel-client-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  <!--
    ~ Copyright (c) 2023-2024 Datalayer, Inc.
    ~
    ~ BSD 3-Clause License
  -->

  [![Datalayer](https://assets.datalayer.tech/datalayer-25.svg)](https://datalayer.io)

  [![Become a Sponsor](https://img.shields.io/static/v1?label=Become%20a%20Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=1ABC9C)](https://github.com/sponsors/datalayer)



  [![Github Actions Status](https://github.com/datalayer/jupyter-nbmodel-client/workflows/Build/badge.svg)](https://github.com/datalayer/jupyter-nbmodel-client/actions/workflows/build.yml)
  [![PyPI - Version](https://img.shields.io/pypi/v/jupyter-nbmodel-client)](https://pypi.org/project/jupyter-nbmodel-client)

  Client to interact with a Jupyter Notebook model.

  To install the library, run the following command.

  ```bash
  pip install jupyter_nbmodel_client
  ```



  1. Ensure you have the needed packages in your environment to run the example here after.

  ```sh
  pip install jupyterlab jupyter-collaboration ipykernel matplotlib
  ```

  2. Start a JupyterLab server, setting a `port` and a `token` to be reused by the agent, and create a notebook `test.ipynb`.

  ```sh
  jupyter lab --port 8888 --IdentityProvider.token MY_TOKEN
  ```

  3. Open a Python REPL and execute the following snippet to add a cell.

  ```py
  from jupyter_nbmodel_client import NbModelClient

  with NbModelClient(server_url="http://localhost:8888", token="MY_TOKEN", path="test.ipynb") as notebook:
      notebook.add_code_cell("print('hello world')")
  ```

  > Check `test.ipynb` in JupyterLab.

  5. The previous example does not involve kernels. Put that now in the picture, adding a cell and executing within a kernel process.

  ```py
  from jupyter_kernel_client import KernelClient
  from jupyter_nbmodel_client import NbModelClient

  with KernelClient(server_url="http://localhost:8888", token="MY_TOKEN") as kernel:
      with NbModelClient(server_url="http://localhost:8888", token="MY_TOKEN", path="test.ipynb") as notebook:
          cell_index = notebook.add_code_cell("print('hello world')")
          results = notebook.execute_cell(cell_index, kernel)

          assert results["status"] == "ok"
          assert len(results["outputs"]) > 0
  ```

  > Check `test.ipynb` in JupyterLab.

  You can go further and create a plot with Matplotlib.

  ```py
  from jupyter_kernel_client import KernelClient
  from jupyter_nbmodel_client import NbModelClient

  CODE = """import matplotlib.pyplot as plt

  fig, ax = plt.subplots()

  fruits = ['apple', 'blueberry', 'cherry', 'orange']
  counts = [40, 100, 30, 55]
  bar_labels = ['red', 'blue', '_red', 'orange']
  bar_colors = ['tab:red', 'tab:blue', 'tab:red', 'tab:orange']

  ax.bar(fruits, counts, label=bar_labels, color=bar_colors)

  ax.set_ylabel('fruit supply')
  ax.set_title('Fruit supply by kind and color')
  ax.legend(title='Fruit color')

  plt.show()
  """

  with KernelClient(server_url="http://localhost:8888", token="MY_TOKEN") as kernel:
      with NbModelClient(server_url="http://localhost:8888", token="MY_TOKEN", path="test.ipynb") as notebook:
          cell_index = notebook.add_code_cell(CODE)
          results = notebook.execute_cell(cell_index, kernel)

          assert results["status"] == "ok"
          assert len(results["outputs"]) > 0
  ```

  > Check `test.ipynb` in JupyterLab.

  > [!NOTE]
  >
  > Instead of using the clients as context manager, you can call the ``start()`` and ``stop()`` methods.

  ```py
  from jupyter_nbmodel_client import NbModelClient

  kernel = KernelClient(server_url="http://localhost:8888", token="MY_TOKEN")
  kernel.start()

  try:
      notebook = NbModelClient(server_url="http://localhost:8888", token="MY_TOKEN", path="test.ipynb"):
      notebook.start()
      try:
          cell_index = notebook.add_code_cell("print('hello world')")
          results = notebook.execute_cell(cell_index, kernel)
      finally:
          notebook.stop()
  finally:
      kernel.stop()
  ```



  To remove the library, run the following.

  ```bash
  pip uninstall jupyter_nbmodel_client
  ```





  ```bash




  pip install -e ".[test,lint,typing]"
  ```



  Install dependencies:

  ```bash
  pip install -e ".[test]"
  ```

  To run the python tests, use:

  ```bash
  pytest
  ```



  ```bash
  pip uninstall jupyter_nbmodel_client
  ```



  See [RELEASE](RELEASE.md)

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


pkgId: ee1d46c47488273a59db2ee6ed94e046388f7b5e0086f0fc51edf6a62789d9dd
name: python-jupyter-play-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for jupyter-play
url: https://pypi.org/project/jupyter-play/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyter-play-0.1.0-1.src.rpm
location_href: Packages/python-jupyter-play-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This package contains a number of basic HTML/CSS/JS games you can play in your jupyter notebook!

  All credit for making the original game files goes to [Steven Lambert](https://gist.github.com/straker).

  ![snake_preview.gif](snake_preview.gif)



  ```bash
  pip install jupyter-play
  ```

  I recommend [uv](https://docs.astral.sh/uv/) to all python users for managing their dependencies and virtual environments.

  ```bash
  uv init # optional, creates a pyproject.toml
  uv venv --python 3.11
  source .venv/bin/activate
  uv add --group fun jupyter-play # e.g. add a "fun" group under your development dependencies
  ```

  The package source distribution includes a `.zip` of html games to play. `setup.py` includes a custom build step to unzip the game files from this `html_games.zip`; this means the files are unzipped in the installed version of the package (the "wheel"). More information on source distributions vs wheels can be found [here](https://packaging.python.org/en/latest/discussions/package-formats/#package-formats).

  - *To packaging workshop attendees (12/20/24):* see if you can figure out how to exclude `.zip` from the installed state!

  `download_games.sh` is the script to download and zip the game files from the original github gists.



  ```python


  from jupyter_play import PLAY


  print(PLAY.list_games())


  PLAY.SNAKE()
  ```

  You can also run your own games (right now just from a string)

  ```python

  from jupyter_play import play
  with open('my_one_file_game.html', 'r') as file:
      game_html = file.read()
  play(game_html)
  ```

  Please note that this package is only meant to work with basic, self-contained, one-file `.html` games in a jupyter notebook environment (i.e. with a running ipykernel).



  The games' creator intentionally left some core features lacking as an exercise for the reader. I may be making some of these additions myself, but if you're excited to contribute yourself please feel free to open a PR and edit one of the base game files in `source_games`.

  I have other ideas for feature additions as well:

  * Basic AIs to play the games for you in a screensaver-like fashion.
  * Configure difficulty and speed settings.
  * Introduce new games.
  * Add new levels (procedurally generated?)


pkgId: 73e4fdd9dfaa69b707545caad68d71616419614423540610e8a756013c74c8ba
name: python-jupyter-suggestions-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for jupyter-suggestions
url: https://pypi.org/project/jupyter-suggestions/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyter-suggestions-0.1.1-1.src.rpm
location_href: Packages/python-jupyter-suggestions-help-0.1.1-1.noarch.rpm
checksum_type: sha256
rpm_license:
  BSD 3-Clause License  Copyright (c) 2024, QuantStack Copyright (c) 2024, JupyterLab Contrib Team All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 4da6a388947e9a22558444392c49124cd5a6c7fd26694220a730b790b8fa254d
name: python-jupyterhub-outpostspawner-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for jupyterhub-outpostspawner
url: https://pypi.org/project/jupyterhub-outpostspawner/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyterhub-outpostspawner-1.0.3-1.src.rpm
location_href: Packages/python-jupyterhub-outpostspawner-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/jupyterhub-outpostspawner/badge/?version=latest)](https://jupyterhub-outpostspawner.readthedocs.io/en/latest/?badge=latest)



  The OutpostSpawner in combination with the [JupyterHub Outpost service](https://github.com/kreuzert/jupyterhub-outpost) enables JupyterHub to spawn single-user notebook servers on multiple remote resources.



  Link to [documentation](https://jupyterhub-outpostspawner.readthedocs.io).



  The JupyterHub community created many useful [JupyterHub Spawner](https://jupyterhub.readthedocs.io/en/latest/reference/spawners.html#examples) over the past years, to allow JupyterHub to use the specific resources of different systems. For most of these Spawners JupyterHub has to run at the system itself. The OutpostSpawner enables the use of these Spawners on remote systems.

  Other Spawners like [SSHSpawner](https://github.com/NERSC/sshspawner) can spawn single-user servers on remote systems, but are not able to use system-specific features like [KubeSpawner](https://github.com/jupyterhub/kubespawner) or [BatchSpawner](https://github.com/jupyterhub/batchspawner).

  The JupyterHub Outpost service in combination with the OutpostSpawner enables a single JupyterHub to offer multiple remote systems of different types.

  - Use one JupyterHub to offer single-user servers on multiple systems.
  - Each system may use a different JupyterHub Spawner.
  - Integrated SSH port forwarding solution to reach remote single-user server.
  - supports the JupyterHub `internal_ssl` feature.
  - shows events gathered by the remote Spawner to the user.
  - Users can override the configuration of the remote Spawner at runtime (e.g. to select a different Docker Image).
  - One JupyterHub Outpost can be connected to multiple JupyterHubs, without interfering with each other.



  JupyterHub must run on a Kubernetes Cluster (recommended is the use of Zero2JupyterHub).
  The JupyterHub Outpost must fulfill the requirements of the configured Spawner class.

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


pkgId: 21fb3142271454464b0cd835425d6444b1383f387379ba6322d5b7a63a1da751
name: python-jupyterlab-a11y-checker
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: A JupyterLab extension.
url: https://github.com/github_username/jupyterlab-a11y-checker
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyterlab-a11y-checker-0.1.3-1.src.rpm
location_href: Packages/python-jupyterlab-a11y-checker-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  This tool performs multiple accessibility checks on Jupyter notebook/Lab cells containing images and headings. It verifies the presence of alt-text for images, ensuring that visually impaired users can understand their content. Additionally, it calculates the color contrast ratio to ensure readability for users with low vision and identifies any transparency issues in images. Furthermore, it evaluates the heading structure to align with WCAG standards, ensuring that headers (h1, h2, etc.) are appropriately structured for optimal accessibility.


  WCAG 2.0/2.1 Guideline 1.1.1: Provide text alternatives for any non-text content so that it can be changed into other forms people need, such as large print, braille, speech, symbols or simpler language.

  ![alt-checker](https://github.com/berkeley-dsep-infra/jupyterlab-a11y-checker/assets/8241358/c3100644-9bb7-4c87-b5c7-7aff84d3be23)
  Upon activating the a11y-cell-checker button, any cells that contain images lacking alt text, in accordance with guideline 1.1.1, are distinctly marked with a dark red circle on the left. This visual indicator underscores the accessibility (a11y) issue that needs to be addressed.


  WCAG 2.0/2.1 Guideline 2.4: Provide ways to help users navigate, find content, and determine where they are.

  ![headings](https://github.com/berkeley-dsep-infra/jupyterlab-a11y-checker/assets/8241358/5088ecb3-52a6-4a2d-94a8-3515f3c01a71")
  Should the headings fail to adhere to the structure outlined in guideline 2.4, the extension precisely pinpoints the locations where the content structure is flawed.



  ![transparency](https://github.com/berkeley-dsep-infra/jupyterlab-a11y-checker/assets/2306166/b6f25067-fd8d-4ffb-b0f0-76bec74d1318)
  Should the color contrast ratio deviate from the standards set in guideline 1.4.3, the extension promptly identifies the specific cell exhibiting color contrast and transparency discrepancies.

  WCAG 2.0/2.1 Guideline 1.4.3: The visual presentation of text and images of text has a contrast ratio of at least 4.5:1, except for the following: (Level AA)
  Large Text: Large-scale text and images of large-scale text have a contrast ratio of at least 3:1;, Incidental: Text or images of text that are part of an inactive user interface component, that are pure decoration, that are not visible to anyone, or that are part of a picture that contains significant other visual content, have no contrast requirement, Logotypes: Text that is part of a logo or brand name has no minimum contrast requirement.



  For step by step approach to use the extension, see the [following snapshots](https://scribehow.com/shared/Using_A11Y_Checker_for_Accessibility_Compliance__VBJ2gzstRb-dY9dKhzcFiw
  )



  https://pypi.org/project/jupyterlab-a11y-checker/



  A JupyterLab extension.



  - JupyterLab >= 4.0.0



  To install the extension, execute:

  ```bash
  pip install jupyterlab_a11y_checker
  ```




  ```bash


  conda activate <env-name>
  pip install cookie cutter
  python -m pip install jupyterlab notebook --pre
  mamba install -c conda-forge nodejs=18
  node -v #to check version


  OR
  cookiecutter https://github.com/jupyterlab/extension-cookiecutter-ts --checkout 4.0

  jlpm
  jlpm run build
  jupyter labextension develop . --overwrite
  python -m pip install -e .
  pip list #to verify it has been installed in editable mode
  jupyter labextension list #to verify it has been installed

  jupyter lab --no-browser #run a jupyterlab server


  ```



  ```bash
  jlpm build:prod
  npm pack #creates a tarball (*.tgz file) containing your project as it would be uploaded to the npm registry. This file can be shared and installed locally.
  jupyter labextension install </path/to/your-package.tgz>




  conda activate <env-name>
  jupyter labextension install </path/to/your-package.tgz>
  jupyter lab #this will open a local server of jupyterlab with all current extensions installed.
  ```


  ```bash
  pip install twine


  [distutils]
  index-servers =
  	pypi

  [pypi]
  repository: https://upload.pypi.org/legacy/
  username: __token__
  password: your-api-token


  twine upload your-package.whl
  ```



  ```bash
  pip uninstall jupyterlab_a11y_checker
  ```

  In development mode, you will also need to remove the symlink created by `jupyter labextension develop`
  command. To find its location, you can run `jupyter labextension list` to figure out where the `labextensions`
  folder is located. Then you can remove the symlink named `jupyterlab-a11y-checker` within that folder.

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


pkgId: 3d056c6a4d1aec4d33ae0d2252e3f971e36834017c449b79761deab993c73b1f
name: python-jupyterlite-core-help
arch: noarch
version: 0.4.5
epoch: 0
release: 1
summary: Development documents and examples for jupyterlite-core
url: https://pypi.org/project/jupyterlite-core/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyterlite-core-0.4.5-1.src.rpm
location_href: Packages/python-jupyterlite-core-help-0.4.5-1.noarch.rpm
checksum_type: sha256
description:
  [![docs-badge]][docs]

  [docs-badge]: https://readthedocs.org/projects/jupyterlite/badge/?version=latest
  [docs]: https://jupyterlite.readthedocs.io/en/latest/?badge=latest

  The `jupyterlite-core` package provides the core functionality for building JupyterLite
  websites, the `jupyter-lite` CLI, and
  [extension points](https://jupyterlite.readthedocs.io/en/latest/howto/extensions/cli-addons.html)
  for authoring custom addons.



  To get started with JupyterLite, please refer to the
  [Getting Started Guide](https://jupyterlite.readthedocs.io/en/latest/quickstart/index.html).



  For more information about how to use JupyterLite, we recommend reading the
  [official documentation](https://jupyterlite.readthedocs.io/).



  If you're interested in contributing to JupyterLite, please refer to the
  [Contributing Guide](https://jupyterlite.readthedocs.io/en/latest/contributing.html).



  `jupyterlite-core` is licensed under the
  [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause). For more
  information, please see the
  [LICENSE](https://github.com/jupyterlite/jupyterlite/blob/main/LICENSE) file.

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


pkgId: 034942f3435c4be0a2d6908e7b69794399a48985c819179bf6f590e2a989f832
name: python-jupyterlite-help
arch: noarch
version: 0.4.5
epoch: 0
release: 1
summary: Development documents and examples for jupyterlite
url: https://pypi.org/project/jupyterlite/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jupyterlite-0.4.5-1.src.rpm
location_href: Packages/python-jupyterlite-help-0.4.5-1.noarch.rpm
checksum_type: sha256
description:
  [![ci-badge]][ci] [![lite-badge]][lite] [![binder-badge]][binder] [![docs-badge]][docs]

  [ci-badge]: https://github.com/jupyterlite/jupyterlite/workflows/Build/badge.svg
  [lite-badge]: https://jupyterlite.rtfd.io/en/latest/_static/badge.svg
  [lite]: https://jupyterlite.rtfd.io/en/stable/try/lab
  [ci]: https://github.com/jupyterlite/jupyterlite/actions?query=branch%3Amain
  [binder-badge]: https://mybinder.org/badge_logo.svg
  [binder]: https://mybinder.org/v2/gh/jupyterlite/jupyterlite/main?urlpath=lab
  [docs-badge]: https://readthedocs.org/projects/jupyterlite/badge/?version=latest
  [docs]: https://jupyterlite.readthedocs.io/en/stable/?badge=latest

  JupyterLite is a JupyterLab distribution that **runs entirely in the browser** built
  from the ground-up using JupyterLab components and extensions.



  Although JupyterLite is currently being developed by core Jupyter developers, the
  project is still _unofficial_.

  Not all the usual features available in JupyterLab and the Classic Notebook will work
  with JupyterLite, but many already do!

  Don't hesitate to check out the
  [documentation](https://jupyterlite.readthedocs.io/en/stable/howto/index.html) for more
  information and project updates.



  JupyterLite works with both [JupyterLab](https://github.com/jupyterlab/jupyterlab) and
  [Jupyter Notebook](https://github.com/jupyter/notebook).

  | [Try it with JupyterLab!] | [Try it with Jupyter Notebook!] |
  | :-----------------------: | :-----------------------------: |
  |     ![lab-screenshot]     |     ![notebook-screenshot]      |

  [try it with jupyterlab!]: https://jupyterlite.readthedocs.io/en/stable/try/lab
  [lab-screenshot]:
    https://github.com/jupyterlite/jupyterlite/assets/591645/8cd26a4e-59db-4b34-bf9b-cd2e9cbc7f98
  [try it with jupyter notebook!]: https://jupyterlite.readthedocs.io/en/stable/try/tree
  [notebook-screenshot]:
    https://github.com/jupyterlite/jupyterlite/assets/591645/39acb251-69aa-4e2e-8768-6f33fc32b3e2



  You can build your own JupyterLite website in a couple of minutes, with custom
  extensions and packages.

  See the
  [documentation](https://jupyterlite.readthedocs.io/en/stable/quickstart/deploy.html) for
  more details.



  JupyterLite is all about accessible browser-based interactive computing:

  - Python kernel backed by [Pyodide](https://pyodide.org) running in a Web Worker
    - Initial support for interactive visualization libraries such as `altair`, `bqplot`,
      `ipywidgets`, `matplotlib`, and `plotly`
  - JavaScript kernel running in a Web Worker
  - View hosted example Notebooks and other files, then edit, save, and download from the
    browser's `IndexDB` (or `localStorage`)
  - Support for saving settings for JupyterLab/Lite core and federated extensions
  - Basic session and kernel management to have multiple kernels running at the same time
  - Support for
    [Code Consoles](https://jupyterlab.readthedocs.io/en/stable/user/code_console.html)

  [p5.js]: https://p5js.org/



  - Served via well-cacheable, static HTTP(S), locally or on most static web hosts
  - Embeddable within larger applications
  - Requires no dedicated _application server_ much less a container orchestrator
  - Fine-grained configurability of page settings, including reuse of federated extensions





  ![widgets](https://user-images.githubusercontent.com/591645/123929339-086f6180-d98f-11eb-8ab0-c7f9661ff41e.gif)



  ![image](https://user-images.githubusercontent.com/591645/123927543-3d7ab480-d98d-11eb-9e7e-eb47baf76bc0.png)



  ![image](https://user-images.githubusercontent.com/591645/123927611-4d929400-d98d-11eb-9201-c46dd47b9047.png)



  ![altair](https://user-images.githubusercontent.com/591645/123929321-04dbda80-d98f-11eb-9d5f-c5429d7aeb51.gif)



  ![plotly](https://user-images.githubusercontent.com/591645/123929332-06a59e00-d98f-11eb-8c51-4a094859c128.gif)



  See the
  [contributing guide](https://github.com/jupyterlite/jupyterlite/blob/main/CONTRIBUTING.md)
  for a development installation.



  JupyterLite is a reboot of several attempts at making a full static Jupyter distribution
  that runs in the browser, without having to start the Python Jupyter Server on the host
  machine.

  The goal is to provide a lightweight computing environment accessible in a matter of
  seconds with a single click, in a web browser and without having to install anything.

  This project is a collection of packages that can be remixed together in variety of ways
  to create new applications and distributions. Most of the packages in this repo focus on
  providing server-like components that run in the browser (to manage kernels, files and
  settings), so existing JupyterLab extensions and plugins can be reused out of the box.

  See also:

  - [p5-notebook](https://github.com/jtpio/p5-notebook): A minimal Jupyter Notebook UI for
    p5.js kernels running in the browser
  - [jyve](https://github.com/deathbeds/jyve): Jupyter Kernels, right inside JupyterLab
  - [Starboard Notebook](https://github.com/gzuidhof/starboard-notebook): In-browser
    literal notebooks
  - [Basthon](https://basthon.fr/about.html): A Jupyter notebook implementation using
    Pyodide



  <div align="center">
    <a href="https://github.com/jupyterlite/jupyterlite/graphs/contributors">
      <img src="https://contrib.rocks/image?repo=jupyterlite/jupyterlite&max=100&columns=10" style="margin: 5px;" />
    </a>
    <p>Join our community and become a contributor today! 🚀 </p>
  </div>

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


pkgId: 8e14041001b36714d6ed5962e99da454e287f2f8ce201bab4e3a01ee6e4159da
name: python-just-semantic-search-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for just-semantic-search
url: https://pypi.org/project/just-semantic-search/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-just-semantic-search-0.0.4-1.src.rpm
location_href: Packages/python-just-semantic-search-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/just-semantic-search.svg)](https://badge.fury.io/py/just-semantic-search)
  [![Python Version](https://img.shields.io/pypi/pyversions/just-semantic-search.svg)](https://pypi.org/project/just-semantic-search/)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Downloads](https://static.pepy.tech/badge/just-semantic-search)](https://pepy.tech/project/just-semantic-search)

  LLM-agnostic semantic-search library with hybrid search support and multiple backends.



  - 🔍 Hybrid search combining semantic and keyword search
  - 🚀 Multiple backend support (Meilisearch, more coming soon)
  - 📄 Smart document splitting with semantic awareness
  - 🔌 LLM-agnostic - works with any embedding model
  - 🎯 Optimized for scientific and technical content
  - 🛠 Easy to use API and CLI tools



  Make sure you have at least Python 3.11 installed.



  ```bash
  pip install just-semantic-search        # Core package
  pip install just-semantic-search-meili  # Meilisearch backend
  ```



  ```bash
  poetry add just-semantic-search        # Core package
  poetry add just-semantic-search-meili  # Meilisearch backend
  ```



  ```bash

  curl -sSL https://install.python-poetry.org | python3 -


  git clone https://github.com/your-username/just-semantic-search.git
  cd just-semantic-search


  poetry install


  poetry shell
  ```



  The project includes a Docker Compose configuration for running Meilisearch. Simply run:

  ```bash
  ./bin/meili.sh
  ```

  This will start a Meilisearch instance with vector search enabled and persistent data storage.





  ```python
  from just_semantic_search.article_semantic_splitter import ArticleSemanticSplitter
  from sentence_transformers import SentenceTransformer


  model = SentenceTransformer('thenlper/gte-base')
  splitter = ArticleSemanticSplitter(model)


  documents = splitter.split_file(
      "path/to/document.txt",
      embed=True,
      title="Document Title",
      source="https://source.url"
  )
  ```



  ```python
  from just_semantic_search.meili.rag import MeiliConfig, MeiliRAG


  config = MeiliConfig(
      host="127.0.0.1",
      port=7700,
      api_key="your_api_key"
  )


  rag = MeiliRAG(
      "test_index",
      "thenlper/gte-base",
      config,
      create_index_if_not_exists=True
  )


  rag.add_documents_sync(documents)
  results = rag.search(
      text_query="What are CAD-genes?",
      vector=model.encode("What are CAD-genes?")
  )
  ```



  The project consists of multiple components:

  - `core`: Core interfaces for hybrid search implementations
  - `meili`: Meilisearch backend implementation




  Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.



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



  If you use this software in your research, please cite:

  ```bibtex
  @software{just_semantic_search,
    title = {just-semantic-search: LLM-agnostic semantic search library},
    author = {Karmazin, Alex and Kulaga, Anton},
    year = {2024},
    url = {https://github.com/your-username/just-semantic-search}
  }
  ```


pkgId: 9b94c7c2393ff058df70ba5e922490ad38e92e2409318f301f1d896af6faa48d
name: python-just-semantic-search-meili-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for just-semantic-search-meili
url: https://pypi.org/project/just-semantic-search-meili/
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-just-semantic-search-meili-0.0.3-1.src.rpm
location_href: Packages/python-just-semantic-search-meili-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  This submodule provides hybrid search functionality using Meilisearch, combining the power of full-text search with vector similarity search for enhanced search results.


pkgId: d271e174b6f5f3ce506428c00386233cd18baa83539e5cbd5733c2bc25addc75
name: python-justement-help
arch: noarch
version: 0.1.0a7
epoch: 0
release: 1
summary: Development documents and examples for justement
url: https://github.com/justement-api/justement-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-justement-0.1.0a7-1.src.rpm
location_href: Packages/python-justement-help-0.1.0a7-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/justement.svg)](https://pypi.org/project/justement/)

  The Justement Python library provides convenient access to the Justement REST API from any Python 3.8+
  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 [justement.ch](https://justement.ch/api/docs). The full API of this library can be found in [api.md](https://github.com/justement-api/justement-python/tree/main/api.md).



  ```sh

  pip install --pre justement
  ```



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

  ```python
  import os
  from justement import Justement

  client = Justement(
      api_key=os.environ.get("JUSTEMENT_API_KEY"),  # This is the default and can be omitted
  )

  page = client.document.search(
      language="de",
      query="art. 8 abs. 2 BV diskriminierung",
  )
  print(page.page)
  ```

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



  Simply import `AsyncJustement` instead of `Justement` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from justement import AsyncJustement

  client = AsyncJustement(
      api_key=os.environ.get("JUSTEMENT_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      page = await client.document.search(
          language="de",
          query="art. 8 abs. 2 BV diskriminierung",
      )
      print(page.page)


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



  List methods in the Justement API are paginated.

  This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:

  ```python
  from justement import Justement

  client = Justement()

  all_documents = []

  for document in client.document.search(
      language="de",
      page=2,
      query="art. 8 abs. 2 BV diskriminierung",
  ):
      
      all_documents.append(document)
  print(all_documents)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from justement import AsyncJustement

  client = AsyncJustement()


  async def main() -> None:
      all_documents = []
      
      async for document in client.document.search(
          language="de",
          page=2,
          query="art. 8 abs. 2 BV diskriminierung",
      ):
          all_documents.append(document)
      print(all_documents)


  asyncio.run(main())
  ```

  Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:

  ```python
  first_page = await client.document.search(
      language="de",
      page=2,
      query="art. 8 abs. 2 BV diskriminierung",
  )
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.results)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.document.search(
      language="de",
      page=2,
      query="art. 8 abs. 2 BV diskriminierung",
  )
  for document in first_page.results:
      print(document.doc_id)


  ```



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

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

  All errors inherit from `justement.APIError`.

  ```python
  import justement
  from justement import Justement

  client = Justement()

  try:
      client.document.search(
          query="art. 8 abs. 2 BV diskriminierung",
      )
  except justement.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except justement.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except justement.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 justement import Justement


  client = Justement(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).document.search(
      query="art. 8 abs. 2 BV diskriminierung",
  )
  ```



  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 justement import Justement


  client = Justement(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).document.search(
      query="art. 8 abs. 2 BV diskriminierung",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/justement-api/justement-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 `JUSTEMENT_LOG` to `info`.

  ```shell
  $ export JUSTEMENT_LOG=info
  ```

  Or to `debug` for more verbose logging.



  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 justement import Justement

  client = Justement()
  response = client.document.with_raw_response.search(
      query="art. 8 abs. 2 BV diskriminierung",
  )
  print(response.headers.get('X-My-Header'))

  document = response.parse()  # get the object that `document.search()` would have returned
  print(document.doc_id)
  ```

  These methods return an [`APIResponse`](https://github.com/justement-api/justement-python/tree/main/src/justement/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/justement-api/justement-python/tree/main/src/justement/_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.document.with_streaming_response.search(
      query="art. 8 abs. 2 BV diskriminierung",
  ) 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](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from justement import Justement, DefaultHttpxClient

  client = Justement(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="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.

  ```py
  from justement import Justement

  with Justement() as client:
    
    ...


  ```



  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/justement-api/justement-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 justement
  print(justement.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/justement-api/justement-python/tree/main/./CONTRIBUTING.md).


pkgId: 0e9f51c0223e891d898a6f2ccaaed6b7f8b7f6dd96867b547e361ca8ebd2a48d
name: python-juxtorpus-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for juxtorpus
url: https://github.com/Sydney-Informatics-Hub/juxtorpus
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-juxtorpus-0.3.2-1.src.rpm
location_href: Packages/python-juxtorpus-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  Compare and analyse two corpus.

  To run this notebook, click on the button below to launch a free binder instance.

  DH Day Workshop (14.Mar.23): [![Binder](https://binderhub.atap-binder.cloud.edu.au/badge_logo.svg)](https://binderhub.atap-binder.cloud.edu.au/v2/gh/Sydney-Informatics-Hub/juxtorpus/53ed632722a8a1be5af4547a6965e4b9aa1dfb85?labpath=notebooks%2FDH%20demo%2FDemo-final.ipynb)



  A quick way to set up your dev environment.
  ```shell
  ./init.dev.sh
  ```

  To build the `requirements.txt` file for binder:
  ```shell
  ./binder_poetry_to_requirements.sh
  ```


pkgId: e774d332b9bcb473f302b375ccfc18621c516329d6f8afc00860736bb1c0fc0a
name: python-jw8507
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: JW8507 is a device of optical attenator
url: https://github.com/JerryZheng89/jw8507_whl
rpm_license: CC BY-NC 4.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jw8507-0.1.2-1.src.rpm
location_href: Packages/python-jw8507-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://badge.fury.io/py/license.svg)
  ![LICENSE](https://licensebuttons.net/l/by-nc/4.0/88x31.png)


  This package is the library for device JW8507 or JW8507A
  [JW8507 Product Main Page](https://english.joinwit.com/product-info/JW8507A.html)


  JW8507 Multichannel Bench-top Optical Attenuator is a special test equipment designed by Joinwit for current optical transceiver and optical network integration test. JW8506 has a high-density design that significantly small size. The multi-channel stand-alone Optical attenuator channel provides higher test data throughput and test rate. The device also provides variety communication interface, can be integrated with many Joinwit products. JW8507 is the ideal solution of Optical Network, Optical transmission field to light sensitivity, error rate, attenuation test of the 40G / 100G optical module.


  1. Individual VOA modules
  2. More efficient testing and data processing ability
  3. Support for optical output locking
  4. Support internal OPM
  5. Maximum + 27dBm input optical power
  6. Provides RS232 interface
  7. Provide variety software protocols for easy system integration


  ```python
  from jw8507 import JW8507

  if __name__ == "__main__":
      jw = JW8507("/dev/cu.PL2303G-USBtoUART2110")
      if jw.open():
          dev_ver = jw.read_device_version()
          print(dev_ver)
          len_list = jw.read_optical_length(1)
          print(len_list)
          len_list = jw.read_optical_length(2)
          print(len_list)
          dev_status = jw.read_current_status(1)
          print(dev_status)
          dev_status = jw.read_current_status(2)
          print(dev_status)

          
          jw.set_attenuation(1100, 1)
          
          jw.set_attenuation(1100, 2)
          time.sleep(5)

          
          jw.dis_connection()
          time.sleep(15)


          
          jw.clear_attenuation(1)
          jw.clear_attenuation(2)
          time.sleep(5)
          
          if jw.close_full_screen():
              print("succ close full screen!")
          jw.close()
      else:
          print(f"open serial port:{opat_port} failed!")
  ```


pkgId: 06ce2abf5dd99b86f6439b13c84f23d433457339015dc24409b0c9bed63122b8
name: python-jwql-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for jwql
url: https://pypi.org/project/jwql/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jwql-1.3.0-1.src.rpm
location_href: Packages/python-jwql-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="logos/jwql_logo_full_transparent.png" width="400"/>
  </p>



  [![Current Release](https://img.shields.io/github/release/spacetelescope/jwql.svg)](https://github.com/spacetelescope/jwql/releases/latest/)
  [![PyPI - License](https://img.shields.io/pypi/l/Django.svg)](https://github.com/spacetelescope/jwql/blob/master/LICENSE)
  [![Python](https://img.shields.io/badge/Python-3.7-blue.svg)](https://www.python.org/)
  [![Build Status](https://github.com/spacetelescope/jwql/workflows/JWQL%20CI/badge.svg)](https://github.com/spacetelescope/jwql/actions)
  [![Documentation Status](https://readthedocs.org/projects/jwql/badge/?version=latest)](https://jwql.readthedocs.io/en/latest/?badge=latest)
  [![STScI](https://img.shields.io/badge/powered%20by-STScI-blue.svg?colorA=707170&colorB=3e8ddd&style=flat)](http://www.stsci.edu)
  [![DOI](https://zenodo.org/badge/109727729.svg)](https://zenodo.org/badge/latestdoi/109727729)
  [![codecov](https://codecov.io/gh/spacetelescope/jwql/branch/develop/graph/badge.svg)](https://codecov.io/gh/spacetelescope/jwql)


  The JWST Quicklook Application (`JWQL`) is a database-driven web application and automation framework for use by the JWST instrument teams to monitor and trend the health, stability, and performance of the JWST instruments.  The system is comprised of the following:
  1. A network file system that stores all uncalibrated and calibrated data products on disk in a centrally-located area, accessible to instrument team members (i.e. the MAST data cache)
  2. A relational database that stores observational metadata allowing for data discovery via relational queries (MAST database API).
  3. A software library that provides tools to support an automation framework in which to build automated instrument monitoring routines.
  4. A web application that allows users to visually inspect new and archival JWST data as well as instrument-specific monitoring and performance results.

  Official API documentation can be found on [ReadTheDocs](https://jwql.readthedocs.io)

  The `jwql` application is available at [https://jwql.stsci.edu](https://jwql.stsci.edu).  Please note that the application is currently restricted to specific JWST instrument team members.



  To install `jwql`, simply use `pip`:

  ```
  pip install jwql
  ```

  The section below describes a more detailed installation for users that wish to contribute to the `jwql` repository.



  Getting `jwql` up and running on your own computer requires four steps, detailed below:
  1. Cloning the GitHub repository
  2. Installing the `conda`environment
  3. Installing the python package
  4. Setting up the configuration file



  It is highly suggested that contributors have a working installation of `anaconda` or `miniconda` for Python 3.10+.  Downloads and installation instructions are  available here:

  - [Miniconda](https://conda.io/miniconda.html)
  - [Anaconda](https://www.continuum.io/downloads)

  Requirements for contributing to the `jwql` package will be included in the `jwql` `conda` environment, which is included in our installation instructions below. Further package requirements will be provided for `jwql` by a `pyproject.toml` file included in the repository.



  You first need to clone the current version of `jwql`. The simplest way to do this is to go to the directory you want your copy of the repository to be in and clone the repository there. Once you are in the directory you can do the following:

  ```
  git clone https://github.com/spacetelescope/jwql.git
  cd jwql
  ```

  or, if you would rather use `SSH` instead of `https`, type
  ```
  git clone git@github.com:spacetelescope/jwql.git
  cd jwql
  ```
  instead, and then proceed as stated.



  Following the download of the `jwql` repository, contributors can then install the `jwql` `conda` environment via the environment yaml file, which contains all of the dependencies for the project. First, if necessary, [install `conda`](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html). Next, ensure that your version of `conda` is up to date:

  ```
  conda update conda
  ```

  Next, activate the `base` or `root` environment (depending on your version of `conda`):

  ```
  source activate base/root
  ```

  **Note:** If you have added a step activating conda to your default terminal/shell (e.g. the `.bashrc`, `.zshrc`, or `.profile` file) then you don't need to do the above step.

  Lastly, create the `jwql` environment via one of the `environment.yml` files (currently `environment_python_3.9.yml`, for python 3.9, and `environment_python_3.10.yml`, for python 3.10, are supported by `jwql`):

  ```
  conda env create -f environment_python_3.10.yml
  ```

  or

  ```
  conda env create -f environment_python_3.11.yml
  ```



  Much of the `jwql` software depends on the existence of a `config.json` file within the `jwql` directory.  This file contains data that may be unique to users and/or contain sensitive information.  Please see the [Config File wiki page](https://github.com/spacetelescope/jwql/wiki/Config-file) for instructions on how to provide this file.




  If you use `JWQL` for work/research presented in a publication (whether directly,
  or as a dependency to another package), we recommend and encourage the following acknowledgment:

  ```
    This research made use of the open source Python package 'jwql' (Bourque et al, 2020).
  ```

  where (Bourque et al, 2020) is a citation of the Zenodo record available using the DOI badge above. By using the `Export` box in the lower right corner of the Zenodo page, you can export the citation in the format most convenient for you.




  There are two current pages to review before you begin contributing to the `jwql` development. The first is our [style guide](https://github.com/spacetelescope/jwql/blob/main/style_guide/README.md) and the second is our [suggested git workflow page](https://github.com/spacetelescope/jwql/wiki/git-&-GitHub-workflow-for-contributing), which contains an in-depth explanation of the workflow.

  Contributors are also encouraged to check out the [Checklist for Contributors Guide](https://github.com/spacetelescope/jwql/wiki/Checklist-for-Contributors-and-Reviewers-of-Pull-Requests) to ensure the pull request contains all of the necessary changes.

  The following is a bare-bones example of a best work flow for contributing to the project:

  1. Create a fork off of the `spacetelescope` `jwql` repository.
  2. Make a local clone of your fork.
  3. Ensure your personal fork is [pointing `upstream` properly](https://docs.github.com/en/free-pro-team@latest/github/collaborating-with-issues-and-pull-requests/configuring-a-remote-for-a-fork).
  4. Create a branch on that personal fork.
  5. Make your software changes.
  6. Push that branch to your personal GitHub repository (i.e. `origin`).
  7. On the `spacetelescope` `jwql` repository, create a pull request that merges the branch into `spacetelescope:develop`.
  8. Assign a reviewer from the team for the pull request.
  9. Iterate with the reviewer over any needed changes until the reviewer accepts and merges your branch.
  10. Delete your local copy of your branch.




  Users who wish to report an issue or request a new feature may do so through the following channels:

  1. Submit a new issue on GitHub (preferred method): https://github.com/spacetelescope/jwql/issues
  2. Submit a new ticket on Jira: https://jira.stsci.edu/projects/JWQL/




  Users and contributors to the `jwql` repository should adhere to the [Code of Conduct](https://github.com/spacetelescope/jwql/blob/main/CODE_OF_CONDUCT.md).  Any issues or violations pertaining to the Code of Conduct should be brought to the attention of a `jwql` team member or to `jwql@stsci.edu`.



  Any questions about the `jwql` project or its software can be directed to `jwql@stsci.edu`.



  - Bryan Hilbert (Project Manager, INS) [@bilhbert4](https://github.com/bhilbert4)
  - Mees Fix (Technical Lead, INS) [@mfixstsci](https://github.com/mfixstsci)
  - Misty Cracraft (INS) [@cracraft](https://github.com/cracraft)
  - Mike Engesser (INS) [@mengesser](https://github.com/mengesser)
  - Maria Pena-Guerrero [@penaguerrero](https://github.com/penaguerrero)
  - Ben Sunnquist (INS) [@bsunnquist](https://github.com/bsunnquist)
  - Brian York (INS) [@york-stsci](https://github.com/york-stsci)
  - Bradley Sappington (INS) [@bradleysappington](https://github.com/bradleysappington)
  - Melanie Clarke (INS) [@melanieclarke](https://github.com/melanieclarke)


  - Matthew Bourque (INS) [@bourque](https://github.com/bourque)
  - Lauren Chambers (INS) [@laurenmarietta](https://github.com/laurenmarietta)
  - Joe Filippazzo (INS) [@hover2pi](https://github.com/hover2pi)
  - Graham Kanarek (INS) [@gkanarek](https://github.com/gkanarek)
  - Teagan King (INS) [@tnking97](https://github.com/tnking97)
  - Sara Ogaz (DMD) [@SaOgaz](https://github.com/SaOgaz)
  - Catherine Martlin (INS) [@catherine-martlin](https://github.com/catherine-martlin)
  - Johannes Sahlmann (INS) [@Johannes-Sahlmann](https://github.com/johannes-sahlmann)
  - Shannon Osborne (INS) [@shanosborne](https://github.com/shanosborne)


  - Faith Abney (DMD)
  - Joshua Alexander (DMD) [@obviousrebel](https://github.com/obviousrebel)
  - Anastasia Alexov (DMD)
  - Sara Anderson (DMD)
  - Tracy Beck (INS)
  - Francesca Boffi (INS) [@frboffi](https://github.com/frboffi)
  - Clara Brasseur (DMD) [@ceb8](https://github.com/ceb8)
  - Matthew Burger (DMD)
  - Steven Crawford (DMD) [@stscicrawford](https://github.com/stscicrawford)
  - James Davies (DMD) [@jdavies-st](https://github.com/jdavies-st)
  - Rosa Diaz (INS) [@rizeladiaz](https://github.com/rizeladiaz)
  - Van Dixon (INS)
  - Larry Doering (ITSD)
  - Tom Donaldson (DMD) [@tomdonaldson](https://github.com/tomdonaldson)
  - Kim DuPrie (DMD)
  - Jonathan Eisenhamer (DMD) [@stscieisenhamer](https://github.com/stscieisenhamer)
  - Ben Falk (DMD) [@falkben](https://github.com/falkben)
  - Ann Feild (OPO)
  - Mike Fox (DSMO) [@mfox22](https://github.com/mfox22)
  - Scott Friedman (INS)
  - Alex Fullerton (INS) [@awfullerton](https://github.com/awfullerton)
  - Macarena Garcia Marin (INS)
  - Lisa Gardner (DMD)
  - Vera Gibbs (ITSD)
  - Catherine Gosmeyer (INS) [@cgosmeyer](https://github.com/cgosmeyer)
  - Phil Grant (ITSD)
  - Dean Hines (INS)
  - Sherie Holfeltz (INS) [@stholfeltz](https://github.com/stholfeltz)
  - Joe Hunkeler (DMD) [@jhunkeler](https://github.com/jhunkeler)
  - Catherine Kaleida (DMD) [@ckaleida](https://github.com/ckaleida)
  - Deborah Kenny (DMD)
  - Jenn Kotler (DMD) [@jenneh](https://github.com/jenneh)
  - Daniel Kühbacher (Goddard) [@DanielKuebi](https://github.com/DanielKuebi)
  - Mark Kyprianou (DMD) [@mkyp](https://github.com/mkyp)
  - Stephanie La Massa (INS)
  - Matthew Lallo (INS)
  - Karen Levay (DMD)
  - Crystal Mannfolk (SCOPE) [@cmannfolk](https://github.com/cmannfolk)
  - Greg Masci (ITSD)
  - Jacob Matuskey (DMD) [@jmatuskey](https://github.com/jmatuskey)
  - Margaret Meixner (INS)
  - Christain Mesh (DMD) [@cam72cam](https://github.com/cam72cam)
  - Prem Mishra (ITSD)
  - Don Mueller (ITSD)
  - Maria Antonia Nieto-Santisteban (SEITO)
  - Brian O'Sullivan (INS)
  - Joe Pollizzi (JWSTMO)
  - Lee Quick (DMD)
  - Anupinder Rai (ITSD)
  - Matt Rendina (DMD) [@rendinam](https://github.com/rendinam)
  - Massimo Robberto (INS) [@mrobberto](https://github.com/mrobberto)
  - Mary Romelfanger (DMD)
  - Elena Sabbi (INS)
  - Bernie Shiao (DMD)
  - Matthew Sienkiewicz (ITSD)
  - Arfon Smith (DSMO) [@arfon](https://github.com/arfon)
  - Linda Smith (INS)
  - Patrick Taylor (ITSD)
  - Dave Unger (ITSD)
  - Jeff Valenti (JWSTMO) [@JeffValenti](https://github.com/JeffValenti)
  - Jeff Wagner (ITSD)
  - Thomas Walker (ITSD)
  - Geoff Wallace (DMD)
  - Lara Wilkinson (OPO)
  - Alex Yermolaev (ITSD) [@alexyermolaev](https://github.com/alexyermolaev)
  - Joe Zahn (ITSD)

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


pkgId: 605a4237e8df385395e4918114657f3ee1b31fbe9be5ccdacfdaf6e990cdad80
name: python-jx3api-help
arch: noarch
version: 2024.12.15.post1
epoch: 0
release: 1
summary: Development documents and examples for jx3api
url: https://pypi.org/project/jx3api/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jx3api-2024.12.15.post1-1.src.rpm
location_href: Packages/python-jx3api-help-2024.12.15.post1-1.noarch.rpm
checksum_type: sha256
description:
  The Python SDK to the [JX3API](https://www.jx3api.com).




  ```bash
  pip install --no-cache -U jx3api
  ```


  ```bash
  pip install --no-cache -U git+https://github.com/JX3API/jx3api-py.git
  ```




  ```python
  from jx3api import JX3API

  api = JX3API(token=..., ticket=...)

  api.active_calendar(server="梦江南")
  ```


  ```python
  from jx3api import AsyncJX3API

  async_api = AsyncJX3API(token=..., ticket=...)

  await async_api.active_calendar(server="梦江南")
  ```


  The codes in this repository are all automatically generated by large language model.

  :)


pkgId: 1a930ba064057a2bf4c8a07a4481b65bef7b05a97eaff61a805d221af5364805
name: python-kaas-cli-help
arch: noarch
version: 0.1.191
epoch: 0
release: 1
summary: Development documents and examples for kaas-cli
url: https://pypi.org/project/kaas-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kaas-cli-0.1.191-1.src.rpm
location_href: Packages/python-kaas-cli-help-0.1.191-1.noarch.rpm
checksum_type: sha256
description:
  Our deployments can be found on [Pypi](https://pypi.org/project/kaas-cli/).


  `pip install --user kaas-cli`
  or
  `sudo pip install kaas-cli`



  Prerequisites: `python >= 3.10`, `pip >= 20.0.2`, `poetry >= 1.3.2`.



  To install the package using `pip`, start by building from [Source](https://github.com/runtimeverification/kaas)

  ```bash
  make build
  pip install dist/*.whl
  ```

  Configure the CLI by copying the example environment file and setting up the necessary environment variables:

  ```bash
  cp .flaskenv.example .flaskenv
  ```

  Then, edit the `.flaskenv` file to match your settings.



  Here's an overview of the environment variables:

  - **SERVER_URL**: The KaaS server API address for the main interaction within the CLI tool. This is a required field. For local development, use `http://localhost:5000`.
  - **DEFAULT_DIRECTORY**: The folder path for artifacts. This is an optional field. You can leave it empty.
  - **DEFAULT_VAULT_ID**: Artifacts should be associated with a project ID. This is an optional field. You can leave it empty.
  - **DEFAULT_KEY**: If the user is not the owner of the project, they are required to provide a security key. This is an optional field. You can leave it empty.



  After installing the dependencies with `poetry install`, you can spawn a shell using `poetry shell`, or alternatively, use `make`:

  ```bash
  make shell
  kaas-cli hello
  kaas-cli --version
  ```

  VAULT_SPEC is an important definition. This is used to access specific organizations and vaults with permission control limitng what tokens have access to.

  The spec follows the form of
  ```
  organization/vault_name
  ```

  To verify the installation, run `kaas-cli hello`. If you see the message `Hello World!`, the CLI is set up correctly.



  For detailed usage instructions of the `kaas-cli` tool, please refer to the official [documentation](https://docs.runtimeverification.com/kaas/guides/getting-started).


pkgId: 5493d2386415debfcfca518c37b6941b155e01b2c83ed7fc674ec43f69068fb4
name: python-kaggle-environments-help
arch: noarch
version: 1.16.10
epoch: 0
release: 1
summary: Development documents and examples for kaggle-environments
url: https://github.com/Kaggle/kaggle-environments
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kaggle-environments-1.16.10-1.src.rpm
location_href: Packages/python-kaggle-environments-help-1.16.10-1.noarch.rpm
checksum_type: sha256
description:
  ```bash
  pip install kaggle-environments
  ```



  ```python
  from kaggle_environments import make


  env = make("tictactoe")


  def my_agent(obs):
    return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]


  env.run([my_agent, "random"])


  env.render(mode="ipython")
  ```



  Kaggle Environments was created to evaluate episodes. While other libraries have set interface precedents (such as Open.ai Gym), the emphasis of this library focuses on:

  1. Episode evaluation (compared to training agents).
  2. Configurable environment/agent lifecycles.
  3. Simplified agent and environment creation.
  4. Cross language compatible/transpilable syntax/interfaces.



  ```python

  from kaggle_environments import make
  help(make)
  env = make("tictactoe")
  dir(env)
  help(env.reset)
  ```



  > A function which given an observation generates an action.



  Agent functions can have observation and configuration parameters and must return a valid action. Details about the observation, configuration, and actions can seen by viewing the specification.

  ```python
  from kaggle_environments import make
  env = make("connectx", {"rows": 10, "columns": 8, "inarow": 5})

  def agent(observation, configuration):
    print(observation) # {board: [...], mark: 1}
    print(configuration) # {rows: 10, columns: 8, inarow: 5}
    return 3 # Action: always place a mark in the 3rd column.


  env.run([agent, "random"])


  print(env.specification.observation)
  print(env.specification.configuration)
  print(env.specification.action)
  ```



  Agents are always functions, however there are some shorthand syntax options to make generating/using them easier.

  ```python

  def agent1(obs):
    return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]


  agent2 = "random"


  agent3 = """
  def act(obs):
    return [c for c in range(len(obs.board)) if obs.board[c] == 0][0]
  """


  agent4 = "C:\path\file.py"


  agent5 = 3


  agent6 = "http://localhost:8000/run/agent"
  ```



  Most environments contain default agents to play against. To see the list of available agents for a specific environment run:

  ```python
  from kaggle_environments import make
  env = make("tictactoe")


  print(*env.agents)


  env.run(["random", "reaction"])
  ```



  Open AI Gym interface is used to assist with training agents. The `None` keyword is used below to denote which agent to train (i.e. train as first or second player of connectx).

  ```python
  from kaggle_environments import make

  env = make("connectx", debug=True)


  trainer = env.train([None, "random"])

  obs = trainer.reset()
  for _ in range(100):
      env.render()
      action = 0 # Action for the agent being trained.
      obs, reward, done, info = trainer.step(action)
      if done:
          obs = trainer.reset()
  ```



  There are 3 types of errors which can occur from agent execution:

  1. **Timeout** - the agent runtime exceeded the allowed limit. There are 2 timeouts:
     1. `agentTimeout` - Used for initialization of an agent on first "act".
     2. `actTimeout` - Used for obtaining an action.
  2. **Error** - the agent raised and error during execution.
  3. **Invalid** - the agent action response didn't match the action specification or the environment deemed it invalid (i.e. playing twice in the same cell in tictactoe).

  To help debug your agent and why it threw the errors above, add the `debug` flag when setting up the environment.

  ```python
  from kaggle_environments import make

  def agent():
    return "Something Bad"

  env = make("tictactoe", debug=True)

  env.run([agent, "random"])

  ```



  > A function which given a state and agent actions generates a new state.

  | Name      | Description                          | Make                      |
  | --------- | ------------------------------------ | ------------------------- |
  | connectx  | Connect 4 in a row but configurable. | `env = make("connectx")`  |
  | tictactoe | Classic Tic Tac Toe                  | `env = make("tictactoe")` |
  | identity  | For debugging, action is the reward. | `env = make("identity")`  |



  An environment instance can be made from an existing specification (such as those listed above).

  ```python
  from kaggle_environments import make


  env = make(
    
    "connectx",

    
    configuration={"rows": 9, "columns": 10},

    
    steps=[],

    
    debug=True
  )
  ```



  There are two types of configuration: Defaults applying to every environment and those specific to the environment. The following is a list of the default configuration:

  | Name         | Description                                                     |
  | ------------ | --------------------------------------------------------------- |
  | episodeSteps | Maximum number of steps in the episode.                         |
  | agentTimeout | Maximum runtime (seconds) to initialize an agent.               |
  | actTimeout   | Maximum runtime (seconds) to obtain an action from an agent.    |
  | runTimeout   | Maximum runtime (seconds) of an episode (not necessarily DONE). |
  | maxLogLength | Maximum log length (number of characters, `None` -> no limit)   |

  ```python
  env = make("connectx", configuration={
    "columns": 19, # Specific to ConnectX.
    "actTimeout": 10,
  })
  ```



  Environments are reset by default after "make" (unless starting steps are passed in) as well as when calling "run". Reset can be called at anytime to clear the environment.

  ```python
  num_agents = 2
  reset_state = env.reset(num_agents)
  ```



  Execute an episode against the environment using the passed in agents until they are no longer running (i.e. status != ACTIVE).

  ```python
  steps = env.run([agent1, agent2])
  print(steps)
  ```



  Evaluation is used to run an episode (environment + agents) multiple times and just return the rewards.

  ```python
  from kaggle_environments import evaluate


  environment = "connectx"
  configuration = {"rows": 10, "columns": 8, "inarow": 5}
  steps = []


  agents = ["random", agent1]


  num_episodes = 10

  rewards = evaluate(environment, agents, configuration, steps, num_episodes)
  ```



  Running above essentially just steps until no agent is still active. To execute a singular game loop, pass in actions directly for each agent. Note that this is normally used for training agents (most useful in a single agent setup such as using the gym interface).

  ```python
  agent1_action = agent1(env.state[0].observation)
  agent2_action = agent2(env.state[1].observation)
  state = env.step([agent1_action, agent2_action])
  ```



  A few environments offer an interactive play against agents within jupyter notebooks. An example of this is using connectx:

  ```python
  from kaggle_environments import make

  env = make("connectx")

  env.play([None, "random"])
  ```



  The following rendering modes are supported:

  - json - Same as doing a json dump of `env.toJSON()`
  - ansi - Ascii character representation of the environment.
  - human - ansi just printed to stdout
  - html - HTML player representation of the environment.
  - ipython - html just printed to the output of a ipython notebook.

  ```python
  out = env.render(mode="ansi")
  print(out)
  ```



  ```sh
  > python main.py -h
  ```



  ```sh
  > python main.py list
  ```



  ```sh
  python main.py evaluate --environment tictactoe --agents random random --episodes 10
  ```



  ```sh
  > python main.py run --environment tictactoe --agents random /pathtomy/agent.py --debug True
  ```



  This is useful when converting an episode json output into html.

  ```sh
  python main.py load --environment tictactoe --steps [...] --render '{"mode": "html"}'
  ```



  The HTTP server contains the same interface/actions as the CLI above merging both POST body and GET params.



  ```bash
  python main.py http-server --port=8012 --host=0.0.0.0
  ```



  ```python

  import requests
  import json

  path_to_agent1 = "/home/ajeffries/git/playground/agent1.py"
  path_to_agent2 = "/home/ajeffries/git/playground/agent2.py"

  agent1_url = f"http://localhost:5001?agents[]={path_to_agent1}"
  agent2_url = f"http://localhost:5002?agents[]={path_to_agent2}"

  body = {
      "action": "run",
      "environment": "tictactoe",
      "agents": [agent1_url, agent2_url]
  }
  resp = requests.post(url="http://localhost:5000", data=json.dumps(body)).json()


  from kaggle_environments import make
  env = make("tictactoe", steps=resp["steps"], debug=True)
  env.render(mode="ipython")
  print(resp)
  ```


pkgId: e1ecfa9961eb2091386f3fb32563a79e0089c56b4545c0a553a801d6004789d5
name: python-kal-utils-help
arch: noarch
version: 2.0.8.17
epoch: 0
release: 1
summary: Development documents and examples for kal-utils
url: https://github.com/BarLanderK/kal-utils
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kal-utils-2.0.8.17-1.src.rpm
location_href: Packages/python-kal-utils-help-2.0.8.17-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/kal-utils.svg)](https://pypi.python.org/pypi/kal-utils)
  [![image](https://img.shields.io/conda/vn/conda-forge/kal-utils.svg)](https://anaconda.org/conda-forge/kal-utils)


  **Kaleidoo utils package**


  -   Free software: MIT License
  -   Documentation: https://BarLanderK.github.io/kal-utils




  -   TODO


pkgId: df56468d334af99c6b2b692a1fc60554617606c4d5c92d592f0a4d45bac19204
name: python-kala-quantum-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for kala-quantum
url: https://github.com/username/kala_quantum
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kala-quantum-1.1.1-1.src.rpm
location_href: Packages/python-kala-quantum-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ```python
  from Kala_Quantum import QuantumCircuit, QuantumGates

  qc = QuantumCircuit(num_qubits=3)

  qc.apply_gate(QuantumGates.H, qubit=0)

  qc.apply_gate(QuantumGates.tensor_gate(QuantumGates.X, num_qubits=3, target_qubit=1), qubit=1)

  result = qc.measure()
  print(f"Measurement outcome: {result}")
  ```

  ```python
  from Kala_Quantum import QuantumState, QuantumTrainer

  initial_state = QuantumState([1, 0, 0, 0])

  training_data = {
      "intents": [
          {"patterns": ["Hello", "Hi"], "responses": ["Hello there!", "Hi, how can I assist?"]}
      ]
  }

  trainer = QuantumTrainer(initial_state, training_data=training_data)

  target_state = [0, 1, 0, 1]
  trainer.train(target_state, epochs=500, learning_rate=0.1)

  query = "Hello"
  response = trainer.predict(query)
  print(f"Response: {response}")
  ```


pkgId: 3b159c057f4c210711798aaca0603e39501fcdd58eba78b7808699197a04a58f
name: python-kalib-help
arch: noarch
version: 0.20.1
epoch: 0
release: 1
summary: Development documents and examples for kalib
url: https://pypi.org/project/kalib/
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kalib-0.20.1-1.src.rpm
location_href: Packages/python-kalib-help-0.20.1-1.noarch.rpm
checksum_type: sha256
description:
  This module provides a comprehensive set of utilities for advanced Python programming, including HTTP communication, string handling, logging enhancements, introspection, dynamic importing, property descriptors, data class extensions, and serialization. It is designed to facilitate complex application development by offering robust tools that extend Python's standard capabilities.



  - [HTTP Communication Utilities](#http-communication-utilities)
  - [String Handling Enhancements](#string-handling-enhancements)
  - [Advanced Logging System](#advanced-logging-system)
  - [Introspection and Reflection Utilities](#introspection-and-reflection-utilities)
  - [Dynamic Importing Tools](#dynamic-importing-tools)
  - [Advanced Property Descriptors](#advanced-property-descriptors)
  - [Data Class Extensions and Configuration Handling](#data-class-extensions-and-configuration-handling)
  - [Serialization and Deserialization Utilities](#serialization-and-deserialization-utilities)





  This component provides a robust toolkit for handling HTTP communication. It includes advanced features for error handling, response parsing, cookie management, and URL processing. The utilities streamline building HTTP clients and services by abstracting common patterns and offering flexible, extensible components.



  - **HTTPException Hierarchy**: A comprehensive set of exception classes for handling HTTP errors, based on status codes and error types.
  - **Response Handling**: Utilities for parsing and processing HTTP responses, including automatic JSON decoding and error checking.
  - **Cookie Management**: Tools for managing HTTP cookies, including parsing and formatting.
  - **URL Processing**: Classes and functions for manipulating URLs, including query parameters and path components.
  - **Serialization Decorators**: Decorators to facilitate serialization and deserialization of complex objects within the HTTP context.
  - **Namespace Augmentation**: Enhancements to the HTTP namespace for convenient access to common utilities like `HTTP.URL`, `HTTP.Agent`, and `HTTP.Exception`.





  Provides advanced string handling utilities focused on character encoding detection, conversion, and manipulation. It defines the `Str` class, acting as a wrapper around string or bytes objects, offering methods to handle various encoding scenarios and to facilitate text processing.



  - **Encoding and Decoding**: Convert between bytes and string representations, handling different character encodings.
  - **Charset Detection**: Automatically detects the character encoding of input data using custom logic and libraries.
  - **Lazy Proxying**: Proxies common string methods to the underlying string representation, allowing `Str` instances to behave like regular strings.
  - **Tokenization**: Methods to split strings into tokens based on regular expression patterns.





  Enhances the standard Python logging system by introducing custom log levels, additional logging utilities, and a more flexible logger configuration. It provides advanced logging capabilities suitable for complex applications that require detailed logging and traceability.



  - **Custom Log Levels**: Defines additional log levels like `NOTICE`, `DEPRECATE`, and `VERBOSE` for finer-grained logging.
  - **Logger Configuration**: Supports configuration from files (e.g., `logging.toml`), environment variables, or default settings.
  - **Logger Extensions**: Provides a `Logger` class with enhanced methods for logging, including context-aware logging and deduplication of messages.
  - **Integration with Modules**: Automatically injects the custom logger into modules, ensuring consistent logging behavior across the application.





  Offers a collection of utility functions and classes for introspection, type checking, and reflection. It includes functions to analyze objects, their types, inheritance hierarchies, and modules.



  - **Type Checking Functions**: Utilities like `is_callable`, `is_collection`, and `is_iterable` for checking object types.
  - **Inheritance Utilities**: Functions to iterate over an object's MRO, get attributes from superclasses, and analyze class hierarchies.
  - **Module and Object Inspection**: Tools to get the module of an object, its fully qualified name, source file, and other metadata.
  - **Stack Inspection**: Functions to analyze the call stack, filter stack traces, and determine stack frame offsets.





  Provides utilities for dynamic importing of modules and objects, with support for caching, handling optional dependencies, and enhanced error reporting.



  - **Dynamic Importing**: Functions like `import_object` to import modules or objects by name at runtime.
  - **Caching Imports**: `cached_import` function to memoize imports and improve performance.
  - **Optional Dependencies**: `optional` function to handle optional imports gracefully, returning `None` or a default value if the module is not available.
  - **Error Handling**: Detailed logging and error messages to aid in debugging import issues, including suggestions for missing packages.





  Provides advanced property descriptors for Python classes, allowing the creation of instance, class, and mixed properties with optional caching capabilities. It includes decorators and base classes to facilitate the definition of properties that can behave differently depending on access context.



  - **Custom Property Decorators**: Decorators like `@prop` and `@pin` to define properties with custom behaviors.
  - **Caching Support**: Ability to cache property results, optimizing performance for expensive computations.
  - **Context-Aware Properties**: Properties that can differentiate between being accessed from an instance or a class.
  - **Async Support**: Supports both synchronous and asynchronous property methods.





  Extends the standard `dataclass` module with additional features such as validation, serialization, dynamic class creation, and integration with custom logging mechanisms.



  - **Custom Data Classes**: Enhanced `dataclass` decorator that supports extra parameters, memoization, and custom initialization.
  - **Validation**: Automatic validation of field types and default values against the defined schema.
  - **Serialization Methods**: Methods like `as_dict`, `as_json`, and `as_sql` for converting instances to different formats.
  - **Dynamic Class Creation**: Utilities like `autoclass` and `simple` to generate classes dynamically based on configuration schemas.
  - **Operator Overloading**: Overloaded operators (`&`, `|`, `^`, `-`, `+`) for combining and comparing data class instances.





  Provides advanced serialization and deserialization utilities, supporting multiple serialization backends, compression algorithms, and encoding schemes. It allows custom serialization of complex objects, automatic detection of serialization formats, and flexible data encoding and decoding options.



  - **Multiple Backends**: Supports serialization backends like `orjson` and standard `json`, with automatic selection.
  - **Custom Serialization**: Ability to register custom serialization functions for specific classes.
  - **Compression Support**: Utilizes compression libraries like `zstd` or `gzip` to compress serialized data.
  - **Flexible Encoding**: Supports multiple encoding schemes such as Base16, Base32, Base64, Base85, and Base2048.
  - **Automatic Backend Detection**: Deserialization functions automatically detect the serialization backend used.
  - **Error Handling**: Robust exception handling and context-aware suppression of errors.





  Requires: venv, update

  Runs all defined pre-commit hooks.

  ```bash
  uvx pre-commit run --config ci/.pre-commit-config.yaml --color always --all
  ```



  Run: once
  Requires: venv

  Update all pre-commit hook versions to latest releases.

  ```bash

      uvx pre-commit autoupdate --config ci/.pre-commit-config.yaml --color always

      uncommited="$(git diff --cached --name-only | sort -u | tr '\n' ' ' | xargs)"
      changes="$(git ls-files --deleted --modified --exclude-standard)"
      changes="$(printf "$changes" | sort -u | tr '\n' ' ' | xargs)"

      if [[ "$uncommited" =~ "\bci/\.pre-commit-config\.yaml\b" ]] || [[ "$changes" =~ "\bci/\.pre-commit-config\.yaml\b" ]]; then
          xc add-precommit
      fi
  ```



  Run: once
  Requires: venv, update

  Input: mode
  Environment: mode=patch

  Bumps project new version, build and publish the package to repository.

  ```bash

  xc bump "$mode"

  uv build
  uv publish
  rm -rf dist/ || true

  ```



  Run: once

  Clean up the project working directory: remove build/, .venv/, and .ruff_cache/ directories, as well as all .pyc files and __pycache__ directories.

  ```bash

      rm -rf dist/ || true
      rm -rf build/ || true
      rm -rf src/kalib.egg-info/ || true
      rm -rf .mypy_cache/ || true
      rm -rf .ruff_cache/ || true
      rm -rf .pytest_cache/ || true

      find . -name "*.pyc" -delete || true
      find . -name "__pycache__" -type d -exec rm -rf {} + || true
  ```



  Run: once

  Clean up the project working directory: remove build/, .venv/, and .ruff_cache/ directories, as well as all .pyc files and __pycache__ directories.

  ```bash

      xc clean
      rm log/* || true
      rm -rf .venv/ || true
  ```



  Run: once

  Make virtualenv for project build & test tools, install pre-push hook.

  ```bash
      if [ ! -d ".venv" ]; then
          uv venv
          uv sync --extra full

          uvx pre-commit install \
              --config ci/.pre-commit-config.yaml \
              --color always \
              --hook-type pre-push \
              --install-hooks \
              --overwrite
      else
          [ -f ".venv/bin/activate" ]

      fi
  ```



  Run: once

  Autoupdate pre-commit hooks if the last update was more than 7 days ago.

  ```bash

      ctime="$(date +%s)"
      mtime="$(git log -1 --format=%ct ci/.pre-commit-config.yaml)"

      result=$(((7*86400) - (ctime - mtime)))

      if [ "$result" -le 0 ]; then
          xc force-update
      fi
  ```



  Run: once
  Requires: venv

  Inputs: mode
  Environment: mode=patch

  Prepare and commit a version update in a Git repository. Checks for uncommitted changes, ensures the current branch is master, verifies if there are any changes since the last tag, and bumps the version number.

  After validating the readiness for an update, it prompts to proceed. Once confirmed, the script updates the pyproject.toml and .pre-commit-config.yaml files if necessary, commits the changes, tags the new version, and pushes the updates to the remote repository.

  ```bash


      uncommited="$(git diff --cached --name-only | sort -u | tr '\n' ' ' | xargs)"
      if [ -n "$uncommited" ]; then
          echo "uncommited changes found"
          exit 1
      fi

      

      branch="$(git rev-parse --quiet --abbrev-ref HEAD 2>/dev/null)"
      if [ -z "$branch" ]; then
          exit 1
      elif [ "$branch" == "master" ]; then
          echo "using main master mode"
      else
          exit 1
      fi

      

      changes="$(git ls-files --deleted --modified --exclude-standard)"
      changes="$(printf "$changes" | sort -u | tr '\n' ' ' | xargs)"

      if [ "$changes" == "README.md" ]; then
          echo "pipeline development mode"
      elif [ -n "$changes" ]; then
          echo "uncommited changes found"
          exit 1
      fi

      git fetch --tags --force
      current="$(git describe --tags --abbrev=0)" || retval="$?"
      if [ "$retval" -eq 128 ]; then
          current="0.0.0"
      elif [ "$retval" -gt 0 ]; then
          echo "something goes wrong on last used git tag fetch"
          exit "$retval"
      fi
      [ -z "$current" ] && exit 1

      if [ "$current" = '0.0.0' ]; then
          amount="1"
      else
          amount="$(git rev-list --count $current..HEAD)"
      fi

      uncommited="$(git diff --cached --name-only | sort -u | tr '\n' ' ' | xargs)"

      if [ "$amount" -eq 0 ] && [ -z "$uncommited" ]; then
          echo "no changes since $current"
          exit 1
      fi

      version="$(bump "$mode" "$current")"
      [ -z "$version" ] && exit 1

      revision="$(git rev-parse "$version" 2>/dev/null)" || retval="$?"

      if [ "$retval" -eq 128 ]; then
          echo "future tag $revision not found, continue"

      elif [ -z "$retval" ] && [ -n "$revision" ]; then

          echo "future tag $version already set to commit $revision, sync with remote branch!"
          exit 1

      else
          echo "something went wrong, version: '$version' revision: '$revision', retval: '$retval'"
          exit 2
      fi

      

      if [ -d "tests/" ]; then
          xc test
      fi

      xc lint
      git-restore-mtime --skip-missing || echo "datetime restoration failed, return: $?, skip"
      ls -la
      echo "we ready for bump $current -> $version, press ENTER twice to proceed or ESC+ENTER to exit"

      counter=0
      while : ; do
          read -r key

          if [[ $key == $'\e' ]]; then
              exit 1

          elif [ -z "$key" ]; then
              counter=$((counter + 1))
              if [ "$counter" -eq 2 ]; then
                  break
              fi
          fi
      done

      

      xc add-precommit

      xc update-pyproject "$current" "$version"
      xc add-pyproject

      uncommited="$(git diff --cached --name-only | sort -u | tr '\n' ' ' | xargs)"
      if [ -n "$uncommited" ]; then
          git commit -m "$branch: $version"
      fi

      git tag -a "$version" -m "$version"
      git push --tags
      git push origin "$branch"

      echo "version updated to $version"
  ```



  Requires: venv

  Check and format ci/.pre-commit-config.yaml. If any changes are made, it stages the file for the next commit.

  ```bash

      file="ci/.pre-commit-config.yaml"

      uvx pre-commit run check-yaml --config "$file" --color always --file "$file" || value="$?"

      while true; do
          value="0"
          uvx pre-commit run yamlfix --config "$file" --color always --file "$file" || value="$?"

          if [ "$value" -eq 0 ]; then
              break

          elif [ "$value" -eq 1 ]; then
              continue

          else
              exit "$value"

          fi
      done

      uncommited="$(git diff --cached --name-only | sort -u | tr '\n' ' ' | xargs)"
      changes="$(git ls-files --deleted --modified --exclude-standard)"
      changes="$(printf "$changes" | sort -u | tr '\n' ' ' | xargs)"

      if [[ "$uncommited" =~ "\bci/\.pre-commit-config\.yaml\b" ]] || [[ "$changes" =~ "\bci/\.pre-commit-config\.yaml\b" ]]; then
          git add "$file"
          git commit -m "(ci/cd): autoupdate pre-commit"
      fi
  ```



  Requires: venv

  Check and format pyproject.toml. If any changes are made, it stages the file for the next commit.

  ```bash

      file="pyproject.toml"

      uvx pre-commit run check-toml --config ci/.pre-commit-config.yaml --color always --file "$file" || value="$?"

      while true; do
          value="0"
          uvx pre-commit run pretty-format-toml --config ci/.pre-commit-config.yaml --color always --file "$file" || value="$?"

          if [ "$value" -eq 0 ]; then
              break

          elif [ "$value" -eq 1 ]; then
              continue

          else
              exit "$value"

          fi
      done

      changes="$(git diff "$file")" || exit "$?"
      changes="$(printf "$changes" | wc -l)"
      if [ "$changes" -ne 0 ]; then
          git add "$file"
      fi
  ```



  Run: once
  Requires: venv

  Update version in pyproject.toml file based on provided old and new version tags. It validates the version format and ensures the current tag matches the project's version before writing the new version.

  ```python

  from os import environ
  from sys import argv, exit
  from re import match
  from pathlib import Path

  import tomli_w

  try:
      import tomllib as reader
  except ImportError:
      import tomli as reader


  ROOT = Path(environ['PWD'])

  def get_version(string):
      try:
          return match(r'^(\d+\.\d+\.\d+)$', string).group(1)
      except Exception:
          print(f'could not parse version from {string}')
          exit(3)

  if __name__ == '__main__':
      try:
          current_tag = get_version(argv[1])
          version_tag = get_version(argv[2])
      except IndexError:
          print('usage: xc update-pyproject <old_tag> <new_tag>')
          exit(1)

      path = ROOT / 'pyproject.toml'
      try:
          with open(path, 'rb') as fd:
              data = reader.load(fd)

      except Exception:
          print(f'could not load {path}')
          exit(2)

      try:
          current_ver = get_version(data['project']['version'])
          print(f'project version: {current_ver}')

      except KeyError:
          print(f'could not find version in {data}')
          exit(2)

      if current_tag != current_ver:
          if current_ver == version_tag:
              print(f'current version {current_ver} == {version_tag}, no update needed')
              exit(0)

          print(f'current tag {current_tag} != {current_ver} current version')
          exit(4)

      data['project']['version'] = version_tag

      try:
          with open(path, 'wb') as fd:
              tomli_w.dump(data, fd)

          print(f'project version -> {version_tag}')

      except Exception:
          print(f'could not write {path} with {data=}')
          exit(5)
  ```



  Run: once
  Requires: venv

  ```bash

      uvx pytest -svx
  ```


pkgId: 844804a79557ec4410b15d688a63540f34ece2a2f55f0631c97a21dee25bbb85
name: python-kamu-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for kamu
url: https://kamu.dev
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kamu-0.1.2-1.src.rpm
location_href: Packages/python-kamu-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  ```bash
  pip install kamu
  ```


  Reading data into Pandas data frame:

  ```python
  import kamu
  import pandas

  con = kamu.connect("grpc+tls://node.demo.kamu.dev:50050")

  df = pandas.read_sql_query(
      r"""
      select
          *
      from 'kamu/net.rocketpool.reth.tokens-minted'
      limit 10
      """,
      con.as_adbc()
  )

  print(df)
  ```

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-2024 Spice AI, 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: f8d305c234be1c056e4d69218a1eca367652f2918d48a223cf7fbf00691eb45d
name: python-kamu-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for kamu
url: https://kamu.dev
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kamu-0.2.1-1.src.rpm
location_href: Packages/python-kamu-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  ```bash
  pip install kamu
  ```


  Quick start:

  ```python
  import kamu

  con = kamu.connect("grpc+tls://node.demo.kamu.dev:50050")


  df = con.query(
      """
      select
          event_time, open, close, volume
      from 'kamu/co.alphavantage.tickers.daily.spy'
      where from_symbol = 'spy' and to_symbol = 'usd'
      order by event_time
      """
  )

  print(df)
  ```

  The client library is based on modern [ADBC](https://arrow.apache.org/docs/format/ADBC.html) standard and the underlying connection can be used directly with other libraries supporting ADBC data sources:

  ```python
  import kamu
  import pandas

  con = kamu.connect("grpc+tls://node.demo.kamu.dev:50050")

  df = pandas.read_sql_query(
      "select 1 as x",
      con.as_adbc(),
  )
  ```

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-2024 Spice AI, 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: c5b891b3b72dbb9b431576ff7e9bf5b2c10975a9ab9d9361e03537449df8bae6
name: python-karya-client-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for karya-client
url: https://saumya-bhatt.github.io/karya-python-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-karya-client-0.0.1-1.src.rpm
location_href: Packages/python-karya-client-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This section highlights the steps to get started with the Karya Python client.

  The distribution files can be found on the latest releases on [Github](https://github.com/Saumya-Bhatt/karya-python-client/releases)

  A list of samples to configure different plans with various actions and hooks can be found [here](https://saumya-bhatt.github.io/karya-python-client/#usage-examples)

  Do refer to the [Client API Documentation](https://saumya-bhatt.github.io/karya-python-client/#module-karya.commons.client) to understand the various methods and classes provided by the client.
  1. Create a config object:
      ```python
      from karya.clients.config import ClientConfig
      from karya.entities.enums import Protocol
      
      config = ClientConfig(
          protocol=Portocol.HTTP,
          host='localhost',
          port=8080
      )
      
      ```
  2. Create a client object:
      ```python
      from karya.clients import KaryaRestClient
      client = KaryaRestClient(config)
      ```
  3. Creat a user. Only a user configured in the Karya server can be used to create a client object.
      ```python
      from karya.clients.requests import CreateUserRequest
      create_user_request = CreateUserRequest(name="python-client")
      user = await client.create_user(create_user_request)
      ```
  4. Specify the action that you would want to trigger once the task is scheduled.
      ```python
      from karya.entities.actions import RestApiRequest
      
      action = RestApiRequest(
          protocol=Protocol.HTTPS,  # Use HTTPS for secure communication
          base_url="localhost",  # Base URL for the REST API
          method=Method.POST,  # HTTP method for the request (POST)
          headers={"content-type": "application/json"},  # Set the content type to JSON
          body=RestApiRequest.JsonBody.from_dict(
              {"message": "Hello from python client"}
          ),  # JSON body to send in the request
          timeout=2000,  # Timeout for the request (in milliseconds)
      )
      ```
  5. Submit the plan to Karya.
      > `period_time` has to be in the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.
      ```python
      from karya.clients.requests SubmitPlanRequest
      from karya.entities.plan_types import Recurring
      
      plan_request = SubmitPlanRequest(
          user_id=user.id,  # Use the created user's ID
          description="Make a recurring API call from python client",  # Description of the plan
          period_time="PT7S",  # Time period between each execution (7 seconds)
          max_failure_retry=3,  # Retry count in case of failure
          plan_type=Recurring(  # Define a recurring plan
              end_at=None,  # No specific end time, so it will continue indefinitely
          ),
          action=rest_action,  # The action to be executed as part of the plan (REST API call)
      )
      plan = await client.submit_plan(plan_request)
      ```
  6. And you're done! The plan will be executed as per the schedule:
      - The action will be triggered every 7 seconds.
      - The action will make a POST request to `localhost` with the JSON body `{"message": "Hello from python client"}`


pkgId: d900bb62673e6035eabbab0f0277be64efdd602b013a9cf041d4084e11914f4c
name: python-karya-client-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for karya-client
url: https://saumya-bhatt.github.io/karya-python-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-karya-client-0.1.0-1.src.rpm
location_href: Packages/python-karya-client-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This section highlights the steps to get started with the Karya Python client.

  ```shell
      pip install karya-client
  ```
  The distribution files can also be found here - [Github Release](https://github.com/Saumya-Bhatt/karya-python-client/releases).

  A list of samples to configure different plans with various actions and hooks can be found [here](https://saumya-bhatt.github.io/karya-python-client/#usage-examples)

  Do refer to the [Client API Documentation](https://saumya-bhatt.github.io/karya-python-client/#module-karya.commons.client) to understand the various methods and classes provided by the client.
  1. Create a config object:
     ```python
     from karya.clients.config import ClientConfig
     from karya.entities.enums import Protocol
     
     config = ClientConfig(
         protocol=Portocol.HTTP,
         host='localhost',
         port=8080
     )
     
     ```
  2. Create a client object:
     ```python
     from karya.clients import KaryaRestClient
     client = KaryaRestClient(config)
     ```
  3. Creat a user. Only a user configured in the Karya server can be used to create a client object.
     ```python
     from karya.clients.requests import CreateUserRequest
     create_user_request = CreateUserRequest(name="python-client")
     user = await client.create_user(create_user_request)
     ```
  4. Specify the action that you would want to trigger once the task is scheduled.
     ```python
     from karya.entities.actions import RestApiRequest
     
     action = RestApiRequest(
         protocol=Protocol.HTTPS,  # Use HTTPS for secure communication
         base_url="localhost",  # Base URL for the REST API
         method=Method.POST,  # HTTP method for the request (POST)
         headers={"content-type": "application/json"},  # Set the content type to JSON
         body=RestApiRequest.JsonBody.from_dict(
             {"message": "Hello from python client"}
         ),  # JSON body to send in the request
         timeout=2000,  # Timeout for the request (in milliseconds)
     )
     ```
  5. Submit the plan to Karya.
     > `period_time` has to be in the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.
     ```python
     from karya.clients.requests SubmitPlanRequest
     from karya.entities.plan_types import Recurring
     
     plan_request = SubmitPlanRequest(
         user_id=user.id,  # Use the created user's ID
         description="Make a recurring API call from python client",  # Description of the plan
         period_time="PT7S",  # Time period between each execution (7 seconds)
         max_failure_retry=3,  # Retry count in case of failure
         plan_type=Recurring(  # Define a recurring plan
             end_at=None,  # No specific end time, so it will continue indefinitely
         ),
         action=rest_action,  # The action to be executed as part of the plan (REST API call)
     )
     plan = await client.submit_plan(plan_request)
     ```
  6. And you're done! The plan will be executed as per the schedule:
     - The action will be triggered every 7 seconds.
     - The action will make a POST request to `localhost` with the JSON body `{"message": "Hello from python client"}`


pkgId: 295088447b40efda6b058315bc3e982f20e4f16de91bf9b687ada74d8b49ddf4
name: python-kathara-lab-checker-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for kathara-lab-checker
url: https://pypi.org/project/kathara-lab-checker/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kathara-lab-checker-0.1.7-1.src.rpm
location_href: Packages/python-kathara-lab-checker-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  Kathará Lab Checker is a tool to automatically check Kathará network scenarios. The tool leverages on a configuration
  file (no coding) to specify the tests to run on the scenarios and then outputs files containing the results of the
  tests.

  The tool is very effective for automatically correct student homeworks, exams and network scenario configurations.



  ```bash
  python3 -m pip install kathara-lab-checker
  ```
  The Python version MUST be `>=3.11`.



  The Kathará Lab Checker takes in input a configuration file specifying the tests to perform and the expected values.
  To run the tool you only need to run the `main.py` passing the desired configuration file.

  ```bash
  python3 -m kathara_lab_checker --config <path-to-the-configuration-file> --labs <path-to-the-labs-directory>
  ```

  At this point, the tool parses the provided configuration file and executes the tests. For each network scenario the
  tool creates a `test_results.xlsx` file in the network scenario directory.

  The file is composed of three sheets:

  1. `Summary`: Contains a summary of the results.
  2. `All`: Contains the results for each test.
  3. `Failed`: Contains only the results of failed tests.

  After all the network scenarios are tested, the tool outputs an excell file `results.xlsx` in the network scenarios
  directory containing all the results for each network scenario, including the reasons for failed tests.



  The repository already provide a complete example with the results of the tests.

  - Check the test configuration by inspecting: [configuration_palabra.json](examples/palabra/correction.json).
  - Check the network topology and requisites: [palabra.pdf](examples/palabra/palabra.pdf)
  - Check final results summary: [results.xlsx](examples/palabra/results.xlsx)

  You can re-run the example by typing the following command in the root directory of the project:

  ```bash
  python3 -m kathara_lab_checker --config examples/palabra/correction.json --no-cache --labs examples/palabra/labs
  ```

  The `--no-cache` flag force to repeat already executed tests.



  In the following you will find the possible values for the configuration file.

  ```
  {
    "labs_path": "<path>", # path to the folder containing the network scenarios
    "convergence_time": "<sec>", # second to wait for routing convergence in the network scenarios
    "structure": "<path>", # path to a lab_conf file specifying the correct lab schema
    "default_image": "<image_name>", # Kathara image to use as default image in the network scenarios
    "test": {
      "requiring_startup": [
      "<device_name>" # Check the presence of startup files for the specified device
      ],
      "ip_mapping": {
        "<device_name>": {
          "<interface_name>>": "<ip/netmask>" # Check that the ip/netmask is configured on the interface of the device
          "<interface_num>>": "<ip/netmask>" # Check that the ip/netmask is configured on the interface eth# of the device
        },
      },
      "daemons": {
        "<device_name>": [
          "<daemon_name>", # check that the daemon is running on the device.>",
          "!<daemon_name>, # check that the daemon is not running on the device.>"
        ]
      },
      
      "kernel_routes": {
        "<device_name>": [
          "<route>", # Check the presence of the route in the data-plane of the device
          "[<route>, [<iface_name_1>, <iface_name_2>, <next_hop_1>]]" # Check the presence of the route in the data-plane of the device
                                                        
        ]
      },
      "protocols": { # Checks on routing protocols
        "bgpd": { # Specific checks for BGP
          "neighbors": { # Check that a peering is up
            "<device_name>": [
              {"ip": <neighbour_ip>, "asn": <neighbor_asn>}, # Check that a peering is up between the device and
                                                             
            ],
          },
          "networks": {
            "<device_name>": [
              "<route>" # Check that the device announce the route in BGP
            ],
          },
        },
        "<protocol_name>": { # General protocol checks
          "injections": { # Check injections into the protocol. Also valid for BGP
            "<device_name>": [
              "<protocol_name>", # Check that the protocol is injected in BGP by the device
              "!<protocol_name>" # Check that the protocol is not injected in BGP by the device
            ],
          }
        }
      },
      "applications": {
        "dns": { # Checks on DNS
          "authoritative": {
            "<zone>": [
              "<ip>" # Check that the authority for the zone is the specified ip
            ],
          },
          "local_ns": {
            "<local_ns_ip>": [
              "<device_name>", # Check if the device has the local_ns_ip as local name server.
            ]
          },
          "records": {
  		  "A": { # The software can check for every type of DNS records
  			"<dns_name>": [
  				"<ip>" # Check if the dns_name is resolved to the ip
  			]
  		  }
          }
        }
      },
      "reachability": { # Check reachability between devices
        "<device_name>": [
          "<ip>", # Check if the device reaches the ip
          "<dns_name>", # Check if the device reaches the dns_name
        ],
      },
  	"custom_commands": { # Execute a command inside a device and checks the output
  		"<device_name>": [
  			{
  				"command": "<command>", # Command to execute
  				"regex_match": "<regex>", # Check if the output matches the regex
  				"output": "<expected_output>", # Check if the output is the expected one
  				"exit_code": <expected_exit_code> # Check if the command exit code is the expected one
  			}
  		]
  	}
    }
  }
  ```

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


pkgId: 10203211a99219c3e8d8436b541c9c967378f393e0ec33afd76228386a0e1494
name: python-kaxe-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for kaxe
url: https://github.com/valteryde/kaxe
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kaxe-0.6.1-1.src.rpm
location_href: Packages/python-kaxe-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  ![BoxPlot](logo.png)

  Kaxe is an lightweight graphing tools for functions, equations, points and more written in pure python



  Kaxe is build to be simple, flexiable and equipped with an flat learning curve.
  Kaxe supports diffrent plotting windows including



  ![BoxPlot](tests/images/box.png)

  * A standard basis plotting window
  * Logaritchmic plot
  * Polar plot
  * Box plot
  * Empty plot



  ![3DPlot](tests/images/3d-box.png)

  * Boxed plot
  * Frame plot
  * Empty



  To get started create a plot object

  ```python
  import kaxe

  plt = kaxe.Plot(window:list)

  plt.save("plot.png")
  ```

  ![Standard plotting window](tests/images/theme_full.png)

  Alternatively other windows can be used


  ```python
  kaxe.PolarPlot(window:list)
  ```

  ![Polar plot](tests/images/polar.png)


  ```python
  kaxe.BoxPlot(window:list)
  ```


  ```python
  plt = kaxe.LogPlot(window:list, firstAxisLog:bool=False, secondAxisLog:bool=True)
  ```



  Adding objects to a window is as easy as
  ```python
  plt.add(obj:object)
  ```



  Kaxe supports diffrent objects

  To add a legend for any object do the following
  ```python
  obj.legend(text)
  ```



  ```python
  kaxe.Function(f:FunctionType,
      color:tuple=None,
      width:int=10,
      *args,
      **kwargs
  )
  ```

  To add a fill under a graph use the fill method
  ```python
  Function.fill(x0, x1)
  ```

  To add a tangent to the function use the tangent method
  ```python3
  Function.tangent(x0)
  ```

  ![Functions](tests/images/function.png)



  Points in two lists x and y can be added to windows using

  ```python
  kaxe.Points(
      x:list|tuple,
      y:list|tuple,
      color:tuple,
      size:int,
      symbol:str=symbols.CIRCLE,
      connect:bool=False
  )
  ```

  ![Points](tests/images/labels.png)



  Equations can be expressed as to functions

  ```python
  kaxe.Equation(
      left:FunctionType,
      right:FunctionType,
      color:tuple,
      width:int
  )
  ```

  E. g
  ```python
  kaxe.Equation(lambda x,y: 2*x, lambda x,y: y)
  ```

  ![Equations](tests/images/equation.png)



  For styles avaliable use
  ```python
  plot.help()
  ```

  For setting a style use
  ```python
  plot.style({"Marker.showLine":False}, width=2000)
  ```

  Or use a predetermined theme with
  ```python
  plot.theme(kaxe.themes.A4Half)
  ```

  Axis titles can be changed with
  ```python
  plot.title(*titles:str)
  ```



  ![Style3DPlot](tests/images/3d-box-style.png)
  ![PrettyPlot3D2](tests/images/3d-function-pretty-2.png)
  ![Style3DPlot3](tests/images/3d-function-pretty-3.png)


pkgId: 959b9703bdeb4b7652cfffa3a048a74b4ef793b05bb42b9a3e5c106cf38f126a
name: python-kbmc-help
arch: noarch
version: 2.4.33
epoch: 0
release: 1
summary: Development documents and examples for kbmc
url: https://github.com/kagepark/kBmc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kbmc-2.4.33-1.src.rpm
location_href: Packages/python-kbmc-help-2.4.33-1.noarch.rpm
checksum_type: sha256
description:
  - Install
  ```javascript
  pip install kbmc
  - Install```
  ```javascript
  pip3 install kbmc
  ```

  - Help
  ```javascript
  Usage: kBmc <command> [OPTION] [<args>]
  Version: 2.2
  Inteligent BMC Tool

  Supported <command>s are:
    is_up                              Is node UP?
    summary                            Show summary
    bootorder                          Set HDD boot mode
    is_admin_user                      Check current user is ADMINISTRATOR user
    lanmode                            Get current lanmode
    info                               Show info
    mac                                Get BMC Mac Address
    eth_mac                            Get Ethernet Mac Address
    reset                              Reset BMC
    power                              Send power signal
    vpower                             Send power signal and verify status
    redfish                            Redfish Command

  [OPTION]
     -h, --help                        Help
     -i, --ip=BMC_IP                   BMC IP Address(required)
     -u, --user=BMC_USER               BMC User(default:ADMIN)
     -p, --passwd=BMC_PW               BMC Password(default:ADMIN)
     -t                                misc tool path(default:/home/kage/.local/lib/python3.6/site-packages/kmisc)
    -si                                SMC IPMITOOL file

   * bootorder                       Set HDD boot mode
         --pxe
         --ipxe
         --bios
         --hdd

   * power                           Send power signal
     -r, --reset                       Send reset signal
     -f, --off                         Send reset signal
     -o, --on                          Send on signal
     -s, --shutdown                    Send shutdown signal
     -c, --cycle                       Send cycle signal
    -vr, --vreset                      Send reset signal
    -vf, --voff                        Send off signal
    -vo, --von                         Send on signal
   -vfo, --voff_on                     Send off and on signal
    -vs, --vshutdown                   Send shutdown signal
    -vc, --vcycle                      Send cycle signal

   * redfish                         Redfish Command
    -rp, --rpower=PW                   Send power signal(on/off)
    -ri, --rinfo                       Get System Information
   -rrb, --reset_bmc                   Reset BMC
   -rni, --net_info                    Show Network Interface
  ```


pkgId: 730e40811cb12a940b0a4f6103aedcf325dcc919ce7ae383d386d060d210b952
name: python-kcli-help
arch: noarch
version: 99.0.202412131031
epoch: 0
release: 1
summary: Development documents and examples for kcli
url: http://github.com/karmab/kcli
rpm_license: ASL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kcli-99.0.202412131031-1.src.rpm
location_href: Packages/python-kcli-help-99.0.202412131031-1.noarch.rpm
checksum_type: sha256
description:
  Provisioner/Manager for Libvirt/Vsphere/Aws/Gcp/Hcloud/Kubevirt/Ovirt/Openstack/IBM Cloud and containers


pkgId: 9c4685e3fc75066f7d966a6c7b794e79b00143b07a795701582c6c39e77779a5
name: python-keboola-streamlit-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for keboola-streamlit
url: https://pypi.org/project/keboola-streamlit/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-keboola-streamlit-0.0.8-1.src.rpm
location_href: Packages/python-keboola-streamlit-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  ![Alt text](https://assets-global.website-files.com/5e21dc6f4c5acf29c35bb32c/5e21e66410e34945f7f25add_Keboola_logo.svg)



  KeboolaStreamlit simplifies the use of Keboola Storage API within Streamlit apps, providing easy-to-use functions for authentication, data retrieval, event logging, and data loading.



  To install:

  ```bash
  pip install keboola-streamlit
  ```

  _If you are using `streamlit<=1.36.0`, please use version `0.0.5` of the keboola-streamlit package._





  Create an instance of the `KeboolaStreamlit` class, and initialize it with the required parameters from Streamlit secrets:

  ```python
  import streamlit as st
  from keboola_streamlit import KeboolaStreamlit

  URL = st.secrets["KEBOOLA_URL"]
  TOKEN = st.secrets["STORAGE_API_TOKEN"]

  keboola = KeboolaStreamlit(root_url=URL, token=TOKEN)
  ```



  If only selected roles can access the app, make sure the user is authorized by:

  ```python
  ROLE_ID = st.secrets["REQUIRED_ROLE_ID"]

  keboola.auth_check(required_role_id=ROLE_ID)
  ```

  Add a logout button to your app:

  ```python
  keboola.logout_button(sidebar=True, use_container_width=True)
  ```



  Read data from a Keboola Storage table and return it as a Pandas DataFrame:

  ```python
  df = keboola.read_table(table_id='YOUR_TABLE_ID')
  ```

  💡 _Wrap the function and use the `st.cache_data` decorator to prevent your data from being read every time you interact with the app. Learn more about caching [here](https://docs.streamlit.io/develop/concepts/architecture/caching)._



  Write data from a Pandas DataFrame to a Keboola Storage table:

  ```python
  keboola.write_table(table_id='YOUR_TABLE_ID', df=your_dataframe, is_incremental=False)
  ```



  Create an event in Keboola Storage to log activities:

  ```python
  keboola.create_event(message='Streamlit App Create Event', event_type='keboola_data_app_create_event')
  ```



  Add a table selection interface in your app:

  ```python
  df = keboola.add_table_selection(sidebar=True)
  ```



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


pkgId: 5b9a4cade839d2e6713d3403a1f69dd17376c39a1b48d3ea1d32505f103757f9
name: python-kedro-mlflow-help
arch: noarch
version: 0.13.4
epoch: 0
release: 1
summary: Development documents and examples for kedro-mlflow
url: https://github.com/Galileo-Galilei/kedro-mlflow
rpm_license: Apache Software License (Apache 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kedro-mlflow-0.13.4-1.src.rpm
location_href: Packages/python-kedro-mlflow-help-0.13.4-1.noarch.rpm
checksum_type: sha256
description:
  | Package manager | Software repository | Latest release                                                                                                                                | Total downloads                                                                                                                 |
  | --------------- | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
  | ``pip``         | PyPI                | [![PyPI version](https://badge.fury.io/py/kedro-mlflow.svg)](https://pypi.org/project/kedro-mlflow/)                                          | [![Downloads](https://pepy.tech/badge/kedro-mlflow)](https://pepy.tech/project/kedro-mlflow)                                    |
  | ``conda``       | conda-forge         | [![conda version](https://img.shields.io/conda/vn/conda-forge/kedro-mlflow?color=bright%20green)](https://anaconda.org/search?q=kedro+mlflow) | [![Downloads](https://img.shields.io/conda/dn/conda-forge/kedro-mlflow?color=blue)](https://anaconda.org/search?q=kedro+mlflow) |


pkgId: 5aa6146b4b70940560ae88f50febac64a12626c25f13d60c34aacddb484a1bf2
name: python-keibascraper-help
arch: noarch
version: 3.1.3
epoch: 0
release: 1
summary: Development documents and examples for keibascraper
url: https://github.com/new-village/KeibaScraper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-keibascraper-3.1.3-1.src.rpm
location_href: Packages/python-keibascraper-help-3.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Test](https://github.com/new-village/keibascraper/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/new-village/keibascraper/actions/workflows/unittest.yaml)
  [![PyPI](https://badge.fury.io/py/keibascraper.svg)](https://badge.fury.io/py/keibascraper)

  **keibascraper** is a Python library designed to parse data from [netkeiba.com](https://www.netkeiba.com/), a prominent Japanese horse racing website. It allows users to programmatically extract detailed information about races, entries, results, odds, and horses. Please note that depending on your usage, this may impose a significant load on netkeiba.com.




  - [Features](#features)
  - [Installation](#installation)
  - [Dependencies](#dependencies)
  - [Usage](#usage)
    - [Loading Entry Data (出走データ)](#loading-entry-data)
    - [Loading Result Data (結果データ)](#loading-result-data)
    - [Loading Odds Data (オッズデータ)](#loading-odds-data)
    - [Loading Horse Data (血統データ/出走履歴データ)](#loading-horse-data)
    - [Bulk Data Loading](#bulk-data-loading)
  - [API Reference](#api-reference)
    - [`load` Function](#load-function)
    - [`race_list` Function](#race_list-function)
  - [Contributing](#contributing)
  - [License](#license)




  - **Flexible Data Loading**: Supports loading of various data types such as race entries, results, odds, and horse information.
  - **Configurable Parsing**: Utilizes JSON configuration files to define parsing rules, making it easy to adapt to changes in the source website.
  - **Error Handling**: Provides robust error handling to manage network issues and data inconsistencies.
  - **Caching**: Implements caching mechanisms to improve performance and reduce redundant network requests.



  keibascraper is available on PyPI and can be installed using pip:

  ```bash
  $ python -m pip install keibascraper
  ```

  **Supported Python Versions**: keibascraper officially supports Python 3.8 and above.



  - [requests](https://pypi.org/project/requests/): For handling HTTP requests.
  - [BeautifulSoup4](https://pypi.org/project/beautifulsoup4/): For parsing HTML content.
  - [jq](https://pypi.org/project/jq/): For parsing JSON content using jq expressions.



  To use keibascraper, import the library and use the `load` function to fetch and parse data from netkeiba.com. The `load` function requires two parameters: the data type and the entity ID.



  ```python
  >>> import keibascraper
  >>> race, entry = keibascraper.load("entry", "201206050810")
  >>> print(race)
  [{'race_id': '201206050810', 'race_number': 10, 'race_name': '有馬記念', ... }]
  >>> print(entry)
  [{'bracket': 7, 'horse_number': 13, 'horse_name': 'ゴールドシップ', ...}, {...}, ...]

  ```



  ```python
  >>> import keibascraper
  >>> race, entry = keibascraper.load("result", "201206050810")
  >>> print(race)
  [{'race_id': '201206050810', 'race_number': 10, 'race_name': '有馬記念', ... }]
  >>> print(entry)
  [{'rank': 1, 'horse_name': 'ゴールドシップ', 'rap_time': 151.9,...}, {...}, ...]
  ```



  ```python
  >>> import keibascraper
  >>> odds = keibascraper.load("odds", "201206050810")
  >>> print(odds)
  [{'horse_number': 13, 'win': 2.7, 'show_min': 1.3, 'show_max': 1.5, ...}, {...}, ...]
  ```



  ```python
  >>> import keibascraper
  >>> horse, result = keibascraper.load("horse", "2009102739")
  >>> print(horse)
  [{'horse_id': '2009102739', 'father_name': 'ステイゴールド', ... }]
  >>> print(result)
  [{'race_date': '20151227', 'race_name': '有馬記念', 'rank': 8, ...}, {...}, ...]
  ```



  To load multiple races in bulk, you can use the `race_list` function to retrieve a list of race IDs for a specific year and month.

  ```python
  import keibascraper


  race_ids = keibascraper.race_list(2022, 7)


  for race_id in race_ids:
      race_info, entry_list = keibascraper.load("entry", race_id)
      
  ```



  The `create_table_sql` function generates an SQL query string for creating a table in an SQLite database. The table structure is dynamically defined based on the configuration file corresponding to the provided `data_type` like `race`, `entry`, `result` and etc. This function ensures that the table is created only if it does not already exist and assigns a primary key to the first column.

  ```python
  >>> import keibascraper
  >>> query = keibascraper.create_table_sql("entry")
  >>> print(query)
  CREATE TABLE IF NOT EXISTS entry (bracket text, ... weight_diff integer);
  ```





  ```python
  keibascraper.load(data_type, entity_id)
  ```

  - **Description**: Loads data from netkeiba.com based on the specified data type and entity ID.
  - **Parameters**:
    - `data_type` (str): Type of data to load. Supported types are `'entry'`, `'result'`, `'odds'`, and `'horse'`.
    - `entity_id` (str): Identifier for the data entity (e.g., race ID, horse ID).
  - **Returns**:
    - For `'entry'` and `'result'`: Returns a list of `[{race}]` and list of `[{entry1}, {entry2}...]`.
    - For `'odds'`: Returns a list of `[{odds1}, {odds2}...]`.
    - For `'horse'`: Returns a list of `[{horse}]` and list of `[{result1}, {result2}...]`.
  - **Raises**:
    - `ValueError`: If an unsupported data type is provided.
    - `RuntimeError`: If data loading or parsing fails.



  ```python
  keibascraper.race_list(year, month)
  ```

  - **Description**: Retrieves a list of race IDs for the specified year and month.
  - **Parameters**:
    - `year` (int): The target year.
    - `month` (int): The target month.
  - **Returns**:
    - A list of race IDs (list).




  Contributions are welcome! If you have suggestions or find bugs, please open an issue or submit a pull request on the [GitHub repository](https://github.com/new-village/keibascraper).

  When contributing, please follow these guidelines:

  - **Coding Standards**: Follow PEP 8 style guidelines.
  - **Testing**: Ensure that your code passes existing tests and add new tests for your changes.
  - **Documentation**: Update documentation and docstrings as needed.




  This project is licensed under the terms of the Apache-2.0 license. See the [LICENSE](https://github.com/new-village/keibascraper/blob/main/LICENSE) file for details.


  **Disclaimer**: This library is intended for personal use and educational purposes. Scraping data from websites may violate their terms of service. Please ensure that you comply with netkeiba.com's terms and conditions when using this library.


pkgId: 7058a069668dda421126a51dc0053407d1176093ec65f2adb24bca50dd377562
name: python-keras-hub-nightly-help
arch: noarch
version: 0.19.0.dev202412140350
epoch: 0
release: 1
summary: Development documents and examples for keras-hub-nightly
url: https://github.com/keras-team/keras-hub
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-keras-hub-nightly-0.19.0.dev202412140350-1.src.rpm
location_href: Packages/python-keras-hub-nightly-help-0.19.0.dev202412140350-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://github.com/keras-team/keras-hub/workflows/Tests/badge.svg?branch=master)](https://github.com/keras-team/keras-hub/actions?query=workflow%3ATests+branch%3Amaster)
  ![Python](https://img.shields.io/badge/python-v3.9.0+-success.svg)
  [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/keras-team/keras-hub/issues)

  > [!IMPORTANT]
  > 📢 KerasNLP is now KerasHub! 📢 Read
  > [the announcement](https://github.com/keras-team/keras-hub/issues/1831).

  **KerasHub** is a pretrained modeling library that aims to be simple, flexible,
  and fast. The library provides [Keras 3](https://keras.io/keras_3/)
  implementations of popular model architectures, paired with a collection of
  pretrained checkpoints available on [Kaggle Models](https://kaggle.com/models/).
  Models can be used with text, image, and audio data for generation, classification,
  and many other built in tasks.

  KerasHub is an extension of the core Keras API; KerasHub components are provided
  as `Layer` and `Model` implementations. If you are  familiar with Keras,
  congratulations! You already understand most of KerasHub.

  All models support JAX, TensorFlow, and PyTorch from a single model
  definition and can be fine-tuned on GPUs and TPUs out of the box. Models can
  be trained on individual accelerators with built-in PEFT techniques, or
  fine-tuned at scale with model and data parallel training. See our
  [Getting Started guide](https://keras.io/guides/keras_hub/getting_started)
  to start learning our API.





  - [Home page](https://keras.io/keras_hub)
  - [Getting started](https://keras.io/keras_hub/getting_started)
  - [Guides](https://keras.io/keras_hub/guides)
  - [API documentation](https://keras.io/keras_hub/api)
  - [Pre-trained models](https://keras.io/keras_hub/presets/)



  - [Call for Contributions](https://github.com/keras-team/keras-hub/issues/1835)
  - [Roadmap](https://github.com/keras-team/keras-hub/issues/1836)
  - [Contributing Guide](CONTRIBUTING.md)
  - [Style Guide](STYLE_GUIDE.md)
  - [API Design Guide](API_DESIGN_GUIDE.md)



  Choose a backend:

  ```python
  import os
  os.environ["KERAS_BACKEND"] = "jax"  # Or "tensorflow" or "torch"!
  ```

  Import KerasHub and other libraries:

  ```python
  import keras
  import keras_hub
  import numpy as np
  import tensorflow_datasets as tfds
  ```

  Load a resnet model and use it to predict a label for an image:

  ```python
  classifier = keras_hub.models.ImageClassifier.from_preset(
      "resnet_50_imagenet",
      activation="softmax",
  )
  url = "https://upload.wikimedia.org/wikipedia/commons/a/aa/California_quail.jpg"
  path = keras.utils.get_file(origin=url)
  image = keras.utils.load_img(path)
  preds = classifier.predict(np.array([image]))
  print(keras_hub.utils.decode_imagenet_predictions(preds))
  ```

  Load a Bert model and fine-tune it on IMDb movie reviews:

  ```python
  classifier = keras_hub.models.BertClassifier.from_preset(
      "bert_base_en_uncased",
      activation="softmax",
      num_classes=2,
  )
  imdb_train, imdb_test = tfds.load(
      "imdb_reviews",
      split=["train", "test"],
      as_supervised=True,
      batch_size=16,
  )
  classifier.fit(imdb_train, validation_data=imdb_test)
  preds = classifier.predict(["What an amazing movie!", "A total waste of time."])
  print(preds)
  ```



  To install the latest KerasHub release with Keras 3, simply run:

  ```
  pip install --upgrade keras-hub
  ```

  To install the latest nightly changes for both KerasHub and Keras, you can use
  our nightly package.

  ```
  pip install --upgrade keras-hub-nightly
  ```

  Currently, installing KerasHub will always pull in TensorFlow for use of the
  `tf.data` API for preprocessing. When pre-processing with `tf.data`, training
  can still happen on any backend.

  Visit the [core Keras getting started page](https://keras.io/getting_started/)
  for more information on installing Keras 3, accelerator support, and
  compatibility with different frameworks.



  If you have Keras 3 installed in your environment (see installation above),
  you can use KerasHub with any of JAX, TensorFlow and PyTorch. To do so, set the
  `KERAS_BACKEND` environment variable. For example:

  ```shell
  export KERAS_BACKEND=jax
  ```

  Or in Colab, with:

  ```python
  import os
  os.environ["KERAS_BACKEND"] = "jax"

  import keras_hub
  ```

  > [!IMPORTANT]
  > Make sure to set the `KERAS_BACKEND` **before** importing any Keras libraries;
  > it will be used to set up Keras when it is first imported.



  We follow [Semantic Versioning](https://semver.org/), and plan to
  provide backwards compatibility guarantees both for code and saved models built
  with our components. While we continue with pre-release `0.y.z` development, we
  may break compatibility at any time and APIs should not be considered stable.



  KerasHub provides access to pre-trained models via the `keras_hub.models` API.
  These pre-trained models are provided on an "as is" basis, without warranties
  or conditions of any kind. The following underlying models are provided by third
  parties, and subject to separate licenses:
  BART, BLOOM, DeBERTa, DistilBERT, GPT-2, Llama, Mistral, OPT, RoBERTa, Whisper,
  and XLM-RoBERTa.



  If KerasHub helps your research, we appreciate your citations.
  Here is the BibTeX entry:

  ```bibtex
  @misc{kerashub2024,
    title={KerasHub},
    author={Watson, Matthew, and  Chollet, Fran\c{c}ois and Sreepathihalli,
    Divyashree, and Saadat, Samaneh and Sampath, Ramesh, and Rasskin, Gabriel and
    and Zhu, Scott and Singh, Varun and Wood, Luke and Tan, Zhenyu and Stenbit,
    Ian and Qian, Chen, and Bischof, Jonathan and others},
    year={2024},
    howpublished={\url{https://github.com/keras-team/keras-hub}},
  }
  ```



  Thank you to all of our wonderful contributors!

  <a href="https://github.com/keras-team/keras-hub/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=keras-team/keras-hub" />
  </a>


pkgId: a6cd772747005c4f542270b0df6ea7bd89111296cce08ed35414c7b91fedf011
name: python-keras-nightly-help
arch: noarch
version: 3.7.0.dev2024121320
epoch: 0
release: 1
summary: Development documents and examples for keras-nightly
url: https://pypi.org/project/keras-nightly/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-keras-nightly-3.7.0.dev2024121320-1.src.rpm
location_href: Packages/python-keras-nightly-help-3.7.0.dev2024121320-1.noarch.rpm
checksum_type: sha256
description:
  Keras 3 is a multi-backend deep learning framework, with support for JAX, TensorFlow, and PyTorch.
  Effortlessly build and train models for computer vision, natural language processing, audio processing,
  timeseries forecasting, recommender systems, etc.

  - **Accelerated model development**: Ship deep learning solutions faster thanks to the high-level UX of Keras
  and the availability of easy-to-debug runtimes like PyTorch or JAX eager execution.
  - **State-of-the-art performance**: By picking the backend that is the fastest for your model architecture (often JAX!),
  leverage speedups ranging from 20% to 350% compared to other frameworks. [Benchmark here](https://keras.io/getting_started/benchmarks/).
  - **Datacenter-scale training**: Scale confidently from your laptop to large clusters of GPUs or TPUs.

  Join nearly three million developers, from burgeoning startups to global enterprises, in harnessing the power of Keras 3.






  Keras 3 is available on PyPI as `keras`. Note that Keras 2 remains available as the `tf-keras` package.

  1. Install `keras`:

  ```
  pip install keras --upgrade
  ```

  2. Install backend package(s).

  To use `keras`, you should also install the backend of choice: `tensorflow`, `jax`, or `torch`.
  Note that `tensorflow` is required for using certain Keras 3 features: certain preprocessing layers
  as well as `tf.data` pipelines.





  Keras 3 is compatible with Linux and MacOS systems. For Windows users, we recommend using WSL2 to run Keras.
  To install a local development version:

  1. Install dependencies:

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

  2. Run installation command from the root directory.

  ```
  python pip_build.py --install
  ```

  3. Run API generation script when creating PRs that update `keras_export` public APIs:

  ```
  ./shell/api_gen.sh
  ```



  The `requirements.txt` file will install a CPU-only version of TensorFlow, JAX, and PyTorch. For GPU support, we also
  provide a separate `requirements-{backend}-cuda.txt` for TensorFlow, JAX, and PyTorch. These install all CUDA
  dependencies via `pip` and expect a NVIDIA driver to be pre-installed. We recommend a clean python environment for each
  backend to avoid CUDA version mismatches. As an example, here is how to create a Jax GPU environment with `conda`:

  ```shell
  conda create -y -n keras-jax python=3.10
  conda activate keras-jax
  pip install -r requirements-jax-cuda.txt
  python pip_build.py --install
  ```



  You can export the environment variable `KERAS_BACKEND` or you can edit your local config file at `~/.keras/keras.json`
  to configure your backend. Available backend options are: `"tensorflow"`, `"jax"`, `"torch"`. Example:

  ```
  export KERAS_BACKEND="jax"
  ```

  In Colab, you can do:

  ```python
  import os
  os.environ["KERAS_BACKEND"] = "jax"

  import keras
  ```

  **Note:** The backend must be configured before importing `keras`, and the backend cannot be changed after
  the package has been imported.



  Keras 3 is intended to work as a drop-in replacement for `tf.keras` (when using the TensorFlow backend). Just take your
  existing `tf.keras` code, make sure that your calls to `model.save()` are using the up-to-date `.keras` format, and you're
  done.

  If your `tf.keras` model does not include custom components, you can start running it on top of JAX or PyTorch immediately.

  If it does include custom components (e.g. custom layers or a custom `train_step()`), it is usually possible to convert it
  to a backend-agnostic implementation in just a few minutes.

  In addition, Keras models can consume datasets in any format, regardless of the backend you're using:
  you can train your models with your existing `tf.data.Dataset` pipelines or PyTorch `DataLoaders`.



  - Run your high-level Keras workflows on top of any framework -- benefiting at will from the advantages of each framework,
  e.g. the scalability and performance of JAX or the production ecosystem options of TensorFlow.
  - Write custom components (e.g. layers, models, metrics) that you can use in low-level workflows in any framework.
      - You can take a Keras model and train it in a training loop written from scratch in native TF, JAX, or PyTorch.
      - You can take a Keras model and use it as part of a PyTorch-native `Module` or as part of a JAX-native model function.
  - Make your ML code future-proof by avoiding framework lock-in.
  - As a PyTorch user: get access to power and usability of Keras, at last!
  - As a JAX user: get access to a fully-featured, battle-tested, well-documented modeling and training library.


  Read more in the [Keras 3 release announcement](https://keras.io/keras_3/).


pkgId: 469de344a807ff6503e30b21c7c9397fe40020dbd6a41abeba7b9dffd03fd5ee
name: python-keras-nlp-nightly-help
arch: noarch
version: 0.19.0.dev202412140350
epoch: 0
release: 1
summary: Development documents and examples for keras-nlp-nightly
url: https://github.com/keras-team/keras-nlp
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-keras-nlp-nightly-0.19.0.dev202412140350-1.src.rpm
location_href: Packages/python-keras-nlp-nightly-help-0.19.0.dev202412140350-1.noarch.rpm
checksum_type: sha256
description:
  KerasNLP has renamed to KerasHub! Read the announcement
  [here](https://github.com/keras-team/keras-nlp/issues/1831).

  This directory contains a shim package for `keras-nlp` so that the old style
  `pip install keras-nlp` and `import keras_nlp` continue to work.


pkgId: d36fcd3cdc5381039a2e4f1c2718dfed654cb98f73c9419ceecc441a00e3987a
name: python-kerykeion-json-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for kerykeion-json
url: https://www.kerykeion.net/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kerykeion-json-1.0.1-1.src.rpm
location_href: Packages/python-kerykeion-json-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align=center>Kerykeion</h1>
  <div align="center">
      <a href="#">
          <img src="https://img.shields.io/github/contributors/g-battaglia/kerykeion?color=blue&logo=github" alt="contributors">
      </a>
      <a href="#">
          <img src="https://img.shields.io/github/stars/g-battaglia/kerykeion.svg?logo=github" alt="stars">
      </a>
      <a href="#">
          <img src="https://img.shields.io/github/forks/g-battaglia/kerykeion.svg?logo=github" alt="forks">
      </a>
      <a href="https://pypi.org/project/kerykeion" target="_blank">
          <img src="https://visitor-badge.laobi.icu/badge?page_id=g-battaglia.kerykeion" alt="visitors"/>
      </a>
      <a href="https://pypi.org/project/kerykeion" target="_blank">
          <img src="https://img.shields.io/pypi/v/kerykeion?label=pypi%20package" alt="Package version">
      </a>
      <a href="https://pypi.org/project/kerykeion" target="_blank">
          <img src="https://img.shields.io/pypi/pyversions/kerykeion.svg" alt="Supported Python versions">
      </a>
  </div>

  &nbsp;

  Kerykeion is a python library for Astrology.
  It can calculate all the planet and house position,
  also it can calculate the aspects of a single persone or between two, you can set how many planets you
  need in the settings in the utility module.
  It also can generate an SVG of a birthchart, a synastry chart or a transit chart.

  The core goal of this project is to provide a simple and easy approach to astrology in a data driven way.

  Here's an example of a birthchart:

  ![Kanye Birth Chart](https://www.kerykeion.net/docs/assets/img/examples/birth-chart.svg)



  If you want to use Kerykeion in a web application, I've created a web API for this purpose, you can find it here:

  **[AstrologerAPI](https://rapidapi.com/gbattaglia/api/astrologer/pricing)**

  It's [open source](https://github.com/g-battaglia/Astrologer-API), it's a way to support me and the project.



  Maintaining this project is a lot of work, the Astrologer API doesn't nearly cover the costs of a software engineer working on this project full time. I do this because I love it, but until I can make this my full time job, I won't be able to spend as much time on it.

  If you want to support me, you can do it here:

  [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/kerykeion)



  Kerykeion is a _Python 3.9_ package, make sure you have _Python 3.9_ or above installed on your system.

  ```bash
  pip3 install kerykeion
  ```



  The basic usage of the library is to create an instance of the AstrologicalSubject class and then access the properties of the instance to get the astrological information about the subject.

  Here's an example:

  ```python


  from kerykeion import AstrologicalSubject



  kanye = AstrologicalSubject("Kanye", 1977, 6, 8, 8, 45, "Atlanta", "US")



  kanye.sun




  kanye.first_house




  kanye.moon.element



  ```

  **To avoid connecting to GeoNames (eg. avoiding hourly limit or no internet connection) you should instance kerykeion like this:**

  ```python
  kanye = AstrologicalSubject(
      "Kanye", 1977, 6, 8, 8, 45, lng=50, lat=50, tz_str="Europe/Rome", city="Rome"
  )
  ```

  The difference is that you have to pass the longitude, latitude and the timezone string, instead of the city and nation.
  If you omit the nation, it will be set to "GB" by default, but the value is not used for calculations. It's better to set it to the correct value though.





  ```python
  from kerykeion import AstrologicalSubject, KerykeionChartSVG


  birth_chart = AstrologicalSubject("Kanye", 1977, 6, 8, 8, 45, "Atlanta", "US")
  birth_chart_svg = KerykeionChartSVG(birth_chart)

  birth_chart_svg.makeSVG()
  ```

  The SVG file will be saved in the home directory.
  ![John Lennon Birth Chart](https://www.kerykeion.net/docs/assets/img/examples/birth-chart.svg)



  ```python
  from kerykeion import AstrologicalSubject, KerykeionChartSVG

  first = AstrologicalSubject("John Lennon", 1940, 10, 9, 18, 30, "Liverpool", "GB")
  second = AstrologicalSubject("Paul McCartney", 1942, 6, 18, 15, 30, "Liverpool", "GB")


  synastry_chart = KerykeionChartSVG(first, "Synastry", second)
  synastry_chart.makeSVG()

  ```

  ![John Lennon and Paul McCartney Synastry](https://www.kerykeion.net/docs/assets/img/examples/synastry-chart.svg)



  By default the output directory is the home directory, you can change it by passing the new_output_directory parameter to the KerykeionChartSVG class:

  ```python
  from kerykeion import AstrologicalSubject, KerykeionChartSVG

  first = AstrologicalSubject("John Lennon", 1940, 10, 9, 18, 30, "Liverpool", "GB")
  second = AstrologicalSubject("Paul McCartney", 1942, 6, 18, 15, 30, "Liverpool", "GB")


  synastry_chart = KerykeionChartSVG(first, "Synastry", second, new_output_directory=".")
  synastry_chart.makeSVG()
  ```



  You can change the language of the SVG by passing the `chart_language` parameter to the KerykeionChartSVG class:

  ```python
  first = AstrologicalSubject("John Lennon", 1940, 10, 9, 18, 30, "Liverpool", "GB", chart_language="ES")
  ```
  More details [here](https://www.kerykeion.net/docs/examples/chart-language).



  To print a report of all the data:

  ```python
  from kerykeion import Report, AstrologicalSubject

  kanye = AstrologicalSubject("Kanye", 1977, 6, 8, 8, 45, "Atlanta", "US")
  report = Report(kanye)
  report.print_report()

  ```

  Returns:

  ```txt
  +- Kerykeion report for Kanye -+
  +----------+------+-------------+-----------+----------+
  | Date     | Time | Location    | Longitude | Latitude |
  +----------+------+-------------+-----------+----------+
  | 8/6/1977 | 8:45 | Atlanta, US | -84.38798 | 33.749   |
  +----------+------+-------------+-----------+----------+
  +-----------------+------+-------+------+----------------+
  | Planet          | Sign | Pos.  | Ret. | House          |
  +-----------------+------+-------+------+----------------+
  | Sun             | Gem  | 17.6  | -    | Twelfth_House  |
  | Moon            | Pis  | 16.43 | -    | Ninth_House    |
  | Mercury         | Tau  | 26.29 | -    | Eleventh_House |
  | Venus           | Tau  | 2.03  | -    | Tenth_House    |
  | Mars            | Tau  | 1.79  | -    | Tenth_House    |
  | Jupiter         | Gem  | 14.61 | -    | Eleventh_House |
  | Saturn          | Leo  | 12.8  | -    | Second_House   |
  | Uranus          | Sco  | 8.27  | R    | Fourth_House   |
  | Neptune         | Sag  | 14.69 | R    | Fifth_House    |
  | Pluto           | Lib  | 11.45 | R    | Fourth_House   |
  | Mean_Node       | Lib  | 21.49 | R    | Fourth_House   |
  | True_Node       | Lib  | 22.82 | R    | Fourth_House   |
  | Mean_South_Node | Ari  | 21.49 | R    | Tenth_House    |
  | True_South_Node | Ari  | 22.82 | R    | Tenth_House    |
  | Chiron          | Tau  | 4.17  | -    | Tenth_House    |
  +-----------------+------+-------+------+----------------+
  +----------------+------+----------+
  | House          | Sign | Position |
  +----------------+------+----------+
  | First_House    | Can  | 18.0     |
  | Second_House   | Leo  | 9.51     |
  | Third_House    | Vir  | 4.02     |
  | Fourth_House   | Lib  | 3.98     |
  | Fifth_House    | Sco  | 9.39     |
  | Sixth_House    | Sag  | 15.68    |
  | Seventh_House  | Cap  | 18.0     |
  | Eighth_House   | Aqu  | 9.51     |
  | Ninth_House    | Pis  | 4.02     |
  | Tenth_House    | Ari  | 3.98     |
  | Eleventh_House | Tau  | 9.39     |
  | Twelfth_House  | Gem  | 15.68    |
  +----------------+------+----------+

  ```

  And if you want to export it to a file:

  ```bash
  python3 your_script_name.py > file.txt
  ```



  ```python


  from kerykeion import SynastryAspects, AstrologicalSubject
  first = AstrologicalSubject("Jack", 1990, 6, 15, 15, 15, "Roma", "IT")
  second = AstrologicalSubject("Jane", 1991, 10, 25, 21, 00, "Roma", "IT")

  name = SynastryAspects(first, second)
  aspect_list = name.get_relevant_aspects()
  print(aspect_list[0])





  ```



  By default, the zodiac type is set to Tropic (Tropical).
  You can set the zodiac type to Sidereal and the sidereal mode in the AstrologicalSubject class:

  ```python
  johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", zodiac_type="Sidereal", sidereal_mode="LAHIRI")
  ```

  More examples [here](https://www.kerykeion.net/docs/examples/sidereal-modes/).

  Full list of supported sidereal modes [here](https://www.kerykeion.net/pydocs/kerykeion/kr_types/kr_literals.html#SiderealMode).



  By default, the houses system is set to Placidus.
  You can set the houses system in the AstrologicalSubject class:

  ```python
  johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", houses_system="M")
  ```

  More examples [here](https://www.kerykeion.net/docs/examples/houses-systems/).

  Full list of supported house systems [here](https://www.kerykeion.net/pydocs/kerykeion/kr_types/kr_literals.html#HousesSystem).

  So far all the available houses system in the Swiss Ephemeris are supported but the Gauquelin Sectors.



  By default, the perspective type is set to Apparent Geocentric (the most common standard for astrology).
  The perspective indicates the point of view from which the chart is calculated (Es. Apparent Geocentric, Heliocentric, etc.).
  You can set the perspective type in the AstrologicalSubject class:

  ```python
  johnny = AstrologicalSubject("Johnny Depp", 1963, 6, 9, 0, 0, "Owensboro", "US", perspective_type="Heliocentric")
  ```

  More examples [here](https://www.kerykeion.net/docs/examples/perspective-type/).

  Full list of supported perspective types [here](https://www.kerykeion.net/pydocs/kerykeion/kr_types/kr_literals.html#PerspectiveType).



  You can now personalize your astrological charts with different themes! Four themes are available:

  - **Classic** (default)
  - **Dark**
  - **Dark High Contrast**
  - **Light**

  Each theme offers a distinct visual style, allowing you to choose the one that best suits your preferences or presentation needs. If you prefer more control over the appearance, you can opt not to set any theme, making it easier to customize the chart by overriding the default CSS variables. For more detailed instructions on how to apply themes, check the [documentation](https://www.kerykeion.net/docs/examples/theming)

  Here's an example of how to set the theme:

  ```python
  from kerykeion import AstrologicalSubject, KerykeionChartSVG

  dark_theme_subject = AstrologicalSubject("John Lennon - Dark Theme", 1940, 10, 9, 18, 30, "Liverpool", "GB")
  dark_theme_natal_chart = KerykeionChartSVG(dark_high_contrast_theme_subject, theme="dark_high_contrast")
  dark_theme_natal_chart.makeSVG()
  ```

  ![John Lennon](https://www.kerykeion.net/assets/img/showcase/John%20Lennon%20-%20Dark%20-%20Natal%20Chart.svg)



  You can initialize the AstrologicalSubject from a **UTC** ISO 8601 string:

  ```python
  subject = AstrologicalSubject.get_from_iso_utc_time(
      "Johnny Depp", "1963-06-09T05:00:00Z", "Owensboro", "US")
  ```

  Note : The default time zone is UTC, with Greenwich longitude and latitude.

  The default online/offline mode is set to offline, if you set it online the default latitude and longitude will be ignored and
  calculated from the city and nation. Remember to pass also the geonames_username parameter if you want to use the online mode, like this:

  ```python
  from kerykeion.astrological_subject import AstrologicalSubject


  subject = AstrologicalSubject.get_from_iso_utc_time(
      "Johnny Depp", "1963-06-09T05:00:00Z", "Owensboro", "US", online=True)
  ```



  The following are present:

  - True North Lunar Node: Simply referred to as "true_node" (without the term "north") for backward compatibility.
  - True South Lunar Node: Referred to as "true_south_node."
  - Mean North Lunar Node: Referred to as "mean_node" (without the term "north") for backward compatibility.
  - Mean South Lunar Node: Referred to as "mean_south_node."

  In instances of the AstrologicalSubject class, all of them are active by default.

  In instances of the classes used to generate aspects and SVG charts, only the mean nodes are active. To activate the true nodes, you need to edit the configuration file (kr.config.json).
  Example:

  ```json
  ...
      {
        "id": 19,
        "name": "True_South_Node",
        "color": "var(--kerykeion-chart-color-true-node)",
        "is_active": true, // Set to true to activate the true node
        "element_points": 0,
        "related_zodiac_signs": [],
        "label": "True_South_Node"
      }
  ...
  ```



  Most of the functions and the classes are self documented by the types and have docstrings.
  An auto-generated documentation [is available here](https://www.kerykeion.net/pydocs/kerykeion.html).

  Sooner or later I'll try to write an extensive documentation.



  You can clone this repository or download a zip file using the right side buttons.



  If you are interested in integrating Kerykeion's astrological functionalities into your project, I would be happy to collaborate with you. Whether you need custom features, support, or consultation, feel free to reach out to me at my [email](mailto:kerykeion.astrology@gmail.com?subject=Integration%20Request) address.



  This project is licensed under the AGPL-3.0 License.
  To understand how this impacts your use of the software, please see the [LICENSE](LICENSE) file for details.
  If you have questions, you can reach out to me at my [email](mailto:kerykeion.astrology@gmail.com?subject=Kerykeion) address.
  As a rule of thumb, if you are using this library in a project, you should open source the code of the project with a compatible license.

  You can implement the logic of kerykeion in your project and also keep it closed source by using a third party API, like the [AstrologerAPI](https://rapidapi.com/gbattaglia/api/astrologer/). The AstrologerAPI is AGPL-3.0 compliant. Subscribing to the API is also, currently, the best way to support the project.



  Feel free to contribute to the code!


pkgId: 86adf02219f94be3ba3388de13b4a45d0599fd34637671bd871eba5f6fa187a3
name: python-kevin-toolbox-dev-help
arch: noarch
version: 1.4.3
epoch: 0
release: 1
summary: Development documents and examples for kevin-toolbox-dev
url: https://github.com/cantbeblank96/kevin_toolbox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kevin-toolbox-dev-1.4.3-1.src.rpm
location_href: Packages/python-kevin-toolbox-dev-help-1.4.3-1.noarch.rpm
checksum_type: sha256
description:
  一个通用的工具代码包集合



  环境要求

  ```shell
  numpy>=1.19
  pytorch>=1.2
  ```

  安装方法：

  ```shell
  pip install kevin-toolbox  --no-dependencies
  ```



  [项目地址 Repo](https://github.com/cantbeblank96/kevin_toolbox)

  [使用指南 User_Guide](./notes/User_Guide.md)

  [免责声明 Disclaimer](./notes/Disclaimer.md)

  [版本更新记录](./notes/Release_Record.md)：

  - v 1.4.3 （2024-12-14）【new feature】
    - nested_dict_list.serializer
      - modify write()，使用 while(detect) try it except wait 的结构包裹原来的 os.rename 操作，多次尝试，避免因为突发的文件系统阻塞（OSError: [Errno 5] Input/output error）导致保存失败。
    - patches.for_numpy.random
      - add get/set_rng_state()，用于获取/加载随机生成器的状态。
      - 添加了对应的测试用例


pkgId: 6f05d7fbda057b58897ded4d6d57a2cb78a26dd444742af6020ad6222966da6a
name: python-key-vault-interface-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for key-vault-interface
url: https://pypi.org/project/key-vault-interface/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-key-vault-interface-0.1.1-1.src.rpm
location_href: Packages/python-key-vault-interface-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <!-- key vault interface documentation master file, created by
  sphinx-quickstart on Tue Dec 17 11:19:41 2024.
  You can adapt this file completely to your liking, but it should at least
  contain the root `toctree` directive. -->



  Add your content using `reStructuredText` syntax. See the
  [reStructuredText](https://www.sphinx-doc.org/en/master/usage/restructuredtext/index.html)
  documentation for details.





  Bases: `object`

  This class serves as an interface for interacting with Azure Key Vault.

  Implements a singleton pattern to ensure only one instance is created.
  It handles the interaction with Azure Key Vault to retrieve secrets and manage them in memory.

  * **Parameters:**
    * **key_vault_name** – The Azure Key Vault name.
    * **tenant_id** – Azure AD Tenant ID.
    * **client_id** – Azure Client ID.
    * **secrets_to_load** (*dict* *,* *optional*) – Optional dictionary of secrets to load into the interface.



  Removes a secret from memory.

  * **Parameters:**
    **alias** (*str*) – Alias of the secret to remove.
  * **Raises:**
    **KeyError** – If the secret alias is not found in the loaded secrets.



  Retrieve a secret value from loaded secrets.

  * **Parameters:**
    **secret_name** (*str*) – Name of the secret.
  * **Returns:**
    Value of the secret or None if not found.
  * **Return type:**
    str
  * **Raises:**
    **ValueError** – If the secret_name is not a string.



  Loads all secrets specified in ‘secrets_to_load’ into memory.

  Iterates over the secrets_to_load dictionary and fetches each secret from the Azure Key Vault.



  Updates the list of secrets to load and reloads them.

  * **Parameters:**
    **new_secrets** (*dict*) – Dictionary of new secrets to load.
  * **Raises:**
    **TypeError** – If new_secrets is not a dictionary.


pkgId: 5776acb9760633c4870349aacbaedf77c69da910c0cb2b94911ba7e0f50e4da7
name: python-kfactory-help
arch: noarch
version: 0.22.0
epoch: 0
release: 1
summary: Development documents and examples for kfactory
url: https://pypi.org/project/kfactory/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kfactory-0.22.0-1.src.rpm
location_href: Packages/python-kfactory-help-0.22.0-1.noarch.rpm
checksum_type: sha256
description:
  Kfactory is a [gdsfactory](https://github.com/gdsfactory/gdsfactory)-like tool. It is built with [KLayout](https://klayout.de) as a backend instead of gdstk, but aims to offer the similar features.

  > [!CAUTION]
  > KFactory is still experimental
  > Expect API changes without notice (even though we try to keep it to a minimum!). The core should be fairly stable with the exception of the all-angle router.
  > It is likely to change in future releases

  It is suggest to pin the version of KFactory in `requirements.txt` or `pyproject.toml` with `kfactory==0.22.0` for example.

  Features similar to gdsfactory:

  - [x] Cells & decorator for caching & storing cells
  - [x] Simple routing (point to point and simpl bundle routes for electrical routes)
  - [x] Basic cells like euler/circular bends, taper, waveguide
  - [x] Path extrusion (no interface with CrossSections)
  - [x] Jupyter integration
  - [x] PDK/package configuration
  - [x] Plugin system (simulations etc.) - Check [kplugins](https://github.com/gdsfactory/kplugins)
  - [x] Generic PDK example - Check [kgeneric](https://github.com/gdsfactory/kgeneric)


  Notable missing Features:

  - [ ] CrossSection
  - [ ] Netlist/Schematics and LVS
  - [ ] More advanced routing


  New/Improved Features:

  - Fully hierarchical bi-directional conversion to YAML
  - Automatic snapping to grid thanks to KLayout
  - More features for vector geometries due to concept of Point/Edge/Vector/Polygon from Klayout
  - Easy booleans thanks to KLayout Regions
  - Enclosures: use the concept of enclosures, similar to cross sections, to allow automatic
    calculation of boolean layers for structures based on [minkowski sum](https://en.wikipedia.org/wiki/Minkowski_addition),
    which are built into KLayout




  kfactory is available on [pypi](https://pypi.org/project/kfactory/)

  ```bash
  pip install kfactory
  ```

  At the moment kfactory works only on python 3.10 and above




  A development environment can be installed with

  ```bash
  python -m pip install -e .[dev]
  ```

  It is defined in `pyproject.toml`. For committing `pre-commit` should be installed with `pre-commit install`.


pkgId: ba79f6ec3ac79d489bdbeaf565b2846dc34a5892ccdcd18ad84f5ba1c2693462
name: python-kframework-help
arch: noarch
version: 7.1.190
epoch: 0
release: 1
summary: Development documents and examples for kframework
url: https://pypi.org/project/kframework/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kframework-7.1.190-1.src.rpm
location_href: Packages/python-kframework-help-7.1.190-1.noarch.rpm
checksum_type: sha256
description:
  [API documentation](https://kframework.org/pyk/)




  ```bash
  pip install kframework
  ```




  Prerequsites: `python >= 3.10`, `poetry >= 1.3.2`.

  Use `make` to run common tasks
  (see the [Makefile](https://github.com/runtimeverification/k/blob/master/pyk/Makefile)
  for a complete list of available targets).

  * `make build`: Build wheel
  * `make check`: Check code style
  * `make format`: Format code
  * `make test-unit`: Run unit tests
  * `make test-integration`: Run integration tests

  For interactive use, spawn a shell with `poetry shell` (after `poetry install`), then run an interpreter.


pkgId: 9b3f996023c11bc491bf4beaca43009d1caff282f87c3a147d2d8b346ac01bc3
name: python-kgrid-sdk-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for kgrid-sdk
url: https://pypi.org/project/kgrid-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kgrid-sdk-1.2.0-1.src.rpm
location_href: Packages/python-kgrid-sdk-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  To manage dependencies and make it possible to only install dependencies required for what you want to use from SDK we decided to use Python's Optional Dependencies rather than creating separate packages for each class.

  Packaging each class separately has its advantages, especially if each class represents a distinct, independent feature with unique dependencies which is not the case in our usecase. However, using optional dependencies within a single package can offer significant benefits in terms of usability and maintainability. Here’s a comparison to help decide which approach might work best for you

  1. Installation Simplicity
  With optional dependencies, users install a single package (kgrid_sdk) and add only the extra features they need using extras (e.g., kgrid_sdk[cli]). This is generally simpler and more user-friendly, as all features are accessible through a single, central package

  2. Namespace and Code Organization
  Keeping everything in a single package means all classes share the same namespace and project structure, making the API simpler and more cohesive for users. They import from kgrid_sdk package regardless of the feature set they need, which simplifies code and documentation.

  3. Code Reusability and Dependency Management
  A single package with optional dependencies is easier to manage if some classes share common dependencies. You only define common dependencies once, and updates propagate across all features. It also avoids versioning conflicts between interdependent features.

  4. User Flexibility and Lightweight Installation
  Users can install only what they need, making the package lightweight without requiring multiple packages. It provides flexibility without adding complexity since extras are not installed by default.

  5. Version Management and Compatibility
  You manage versioning in one central package. Compatibility between the core and extras is generally simpler to control, as everything is versioned and released together.

  The current version of the SDK only has optional dependencies for Ko_API class. If this class is used, these optional dependencies could be installed with the package using `-E api` if you are using `poetry install` or `poetry add` and using `[api]` if you are using `pip install`.


  You can use this package to implement python Knowledge Objects.


  The `kgrid_sdk` package is available on PyPI and can be easily added as a dependency to your project. Here’s how to include it in your project based on your setup:


  - For the base package:
  ```bash
  poetry add kgrid_sdk
  ```

  - If you need to use the KO-API class, include the api extra:
  ```
  poetry add kgrid_sdk -E api
  ```


  If you are not using Poetry, you can install the package with pip:
  - For the base package:
  ```
  pip install kgrid_sdk
  ```
  - To include the KO-API extra:
  ```
  pip install kgrid_sdk[api]
  ```

  To inherit the core functionalities of the SDK, extend the `kgrid_sdk.Ko` class in your knowledge object. For example:
  ```python
  from kgrid_sdk import Ko

  class Prevent_obesity_morbidity_mortality(Ko):
      def __init__(self):
          super().__init__()
  ```
  This class adds core functionalities to the knowledge object (KO), such as `get_version` and `get_metadata`.


  The `Ko_Execution` class extends `Ko` to include a universal `execute` method for knowledge objects. The constructor of this class accepts an array of knowledge representations (functions), and the `execute` method can optionally take the name of the function to execute. If no function name is provided, the `execute` method defaults to executing the first function. This is particularly useful for KOs with only one knowledge representation. The knowledge representations could be added as static methods of the knowledge object class or could be defined as individual functions.
  ```python
  from kgrid_sdk import Ko_Execution

  class Pregnancy_healthy_weight_gain(Ko_Execution):
      def __init__(self):
          super().__init__([self.get_pregnancy_healthy_weight_gain_recommendation])

      @staticmethod
      def get_pregnancy_healthy_weight_gain_recommendation(pregnant):
      ...
  ```
  The `execute` method takes a JSON input, mapping it to the knowledge representation's input parameters using a wrapper. The JSON input may include unrelated parameters, which are ignored by the wrapper.

  The `execute` method is used by the SDK's collection class, API, and CLI services.


  To implement an API or CLI service for your knowledge object, extend the `kgrid_sdk.Ko_API` and `kgrid_sdk.Ko_CLI` classes:
  ```python
  from kgrid_sdk import Ko_API
  from kgrid_sdk import Ko_CLI

  class Abdominal_aortic_aneurysm_screening(Ko_API,Ko_CLI):
      def __init__(self):
          super().__init__([self.get_abdominal_aortic_aneurysm_screening])
  ```

  These classes extend `Ko_Execution` and therefore they include the `execute` method to your knowledge object.

  For a complete example of implementing API, CLI, and activator services using the SDK, see the knowledge objects created in our USPSTF collection repository or refer to the example code below:
  ```python
  from kgrid_sdk import Ko_API
  from kgrid_sdk import Ko_CLI


  class Abdominal_aortic_aneurysm_screening(Ko_API,Ko_CLI):
      def __init__(self):
          super().__init__([self.get_abdominal_aortic_aneurysm_screening])
          self.add_endpoint("/check-inclusion", tags=["abdominal_aortic_aneurysm_screening"])

      @staticmethod
      def get_abdominal_aortic_aneurysm_screening(age, gender, has_never_smoked):
          """
          Parameters:
          - age (int): Age of the person.
          - gender (int): Gender of the individual (0 for women, 1 for men).
          - has_never_smoked (bool): Whether this person has never smoked or not.
          """

          if gender == 1:
              if age >= 65 and age <= 75 and not has_never_smoked:
                  return {
                      "inclusion": True,
                      "title": "Abdominal Aortic Aneurysm: Screening",
                      "recommendation": "The USPSTF recommends 1-time screening for abdominal aortic aneurysm (AAA) with ultrasonography in men aged 65 to 75 years who have ever smoked.",
                      "grade": "B",
                      "URL": "https://www.uspreventiveservicestaskforce.org/uspstf/index.php/recommendation/abdominal-aortic-aneurysm-screening"
                      }
              elif age >= 65 and age <= 75 and has_never_smoked:
                  return {
                      "inclusion": True,
                      "title": "Abdominal Aortic Aneurysm: Screening",
                      "recommendation": "The USPSTF recommends that clinicians selectively offer screening for AAA with ultrasonography in men aged 65 to 75 years who have never smoked rather than routinely screening all men in this group. Evidence indicates that the net benefit of screening all men in this group is small. In determining whether this service is appropriate in individual cases, patients and clinicians should consider the balance of benefits and harms on the basis of evidence relevant to the patient's medical history, family history, other risk factors, and personal values.",
                      "grade": "C",
                      "URL": "https://www.uspreventiveservicestaskforce.org/uspstf/index.php/recommendation/abdominal-aortic-aneurysm-screening"
                      }
          elif gender == 0:
              if has_never_smoked:
                  return {
                      "inclusion": True,
                      "title": "Abdominal Aortic Aneurysm: Screening",
                      "recommendation": "The USPSTF recommends against routine screening for AAA with ultrasonography in women who have never smoked and have no family history of AAA.",
                      "grade": "D",
                      "URL": "https://www.uspreventiveservicestaskforce.org/uspstf/index.php/recommendation/abdominal-aortic-aneurysm-screening"
                      }
              elif age >= 65 and age <= 75 and not has_never_smoked:
                  return {
                      "inclusion": True,
                      "title": "Abdominal Aortic Aneurysm: Screening",
                      "recommendation": "The USPSTF concludes that the current evidence is insufficient to assess the balance of benefits and harms of screening for AAA with ultrasonography in women aged 65 to 75 years who have ever smoked or have a family history of AAA.",
                      "grade": "I",
                      "URL": "https://www.uspreventiveservicestaskforce.org/uspstf/index.php/recommendation/abdominal-aortic-aneurysm-screening"
                      }


          return {
              "inclusion": False,
              "title": "Abdominal Aortic Aneurysm: Screening"
              }


  abdominal_aortic_aneurysm_screening = Abdominal_aortic_aneurysm_screening()
  app = abdominal_aortic_aneurysm_screening.app

  abdominal_aortic_aneurysm_screening.define_cli()
  abdominal_aortic_aneurysm_screening.add_argument(
      "-a", "--age", type=float, required=True, help="Age of the person"
  )
  abdominal_aortic_aneurysm_screening.add_argument(
      "-g", "--gender", type=float, required=True, help="Gender of the individual (0 for women, 1 for men)."
  )
  abdominal_aortic_aneurysm_screening.add_argument(
      "--has_never_smoked", action='store_true', help="Indicate if the person has never smoked."
  )
  abdominal_aortic_aneurysm_screening.add_argument(
      "--has_ever_smoked", action='store_false', dest='has_never_smoked', help="Indicate if the person has ever smoked."
  )


  def cli():
      abdominal_aortic_aneurysm_screening.execute_cli()


  def apply(input):
      return abdominal_aortic_aneurysm_screening.execute(input)
  ```

  Note: The activator example requires a service specification file and a deployment file pointing to the `apply` method. For more details, refer to the [Python Activator](https://github.com/kgrid/python-activator) documentation.


  The `kgrid_sdk.Collection` class can be used to create a collection of knowledge objects. Start by importing and creating an instance of the `Collection` class. Use the `add_knowledge_object` method to add knowledge objects that extend `kgrid_sdk.Ko_Execution` or higher-level SDK classes like `kgrid_sdk.Ko_API` or `kgrid_sdk.Ko_CLI`. This requirement ensures that the collection works with KOs containing the SDK `execute` method.
  ```python
  from abdominal_aortic_aneurysm_screening import abdominal_aortic_aneurysm_screening
  from cardiovascular_prevention_diet_activity import cardiovascular_prevention_diet_activity
  from cardiovascular_prevention_statin_use import cardiovascular_prevention_statin_use
  from hypertension_screening import hypertension_screening
  from diabetes_screening import diabetes_screening
  from high_body_mass_index import high_body_mass_index

  from kgrid_sdk.collection import Collection


  USPSTF_Collection = Collection("USPSTF_Collection")
  USPSTF_Collection.add_knowledge_object( abdominal_aortic_aneurysm_screening )
  USPSTF_Collection.add_knowledge_object( cardiovascular_prevention_diet_activity )
  USPSTF_Collection.add_knowledge_object( cardiovascular_prevention_statin_use )
  USPSTF_Collection.add_knowledge_object( hypertension_screening )
  USPSTF_Collection.add_knowledge_object( diabetes_screening )
  USPSTF_Collection.add_knowledge_object( high_body_mass_index )
  ```
  Once ready, the collection can be packaged and installed as an external package in any Python application. Here is an example:
  ```bash
  pip install https://github.com/kgrid/python-sdk/releases/download/1.0/uspstf_collection-0.1.0-py3-none-any.whl
  ```

  To execute the collection on a patient's data, install and import the `USPSTF_Collection` (if used as a package). Use the `calculate_for_all` method, passing a JSON input that includes all the required parameters for each knowledge object in the collection.
  ```python
  from uspstf_collection import USPSTF_Collection
  import json

  patient_data={
      "age":42,
      "bmi":33,
      "bmi_percentile":95.5,
      "has_never_smoked": True,
      "has_cardiovascular_risk_factors":True,
      "ten_year_CVD_risk":8,
      "hypertension":False
  }

  result = USPSTF_Collection.calculate_for_all(patient_data)
  print(json.dumps(result, indent=4))
  ```


  Use the `package` CLI command to package the content of a Knowledge Object (KO) based on its metadata. Currently, all relative and absolute local URIs in the metadata are resolved towards the location of the metadata, but external URLs are not included in the package. If a URI resolves to a folder, all contents within the folder are included; if it resolves to a file, only the file is included. By default, the metadata file is always included in the package.


  To use the command line interface (CLI) from the kgrid_sdk package, you must install the CLI as an **_extra_**. Extras are optional dependencies that provide additional functionality. If you are installing the kgrid-sdk from PiPY use `-E cli` using the following command:

  ```bash
  pip install kgrid-sdk -E cli
  ```
  If you are installing the package from a `.whl` file, add `[cli]` to the end of the `.whl` package name and quote the entire package path. for example:

  ```bash
  pip install "kgrid-sdk[cli]@https://github.com/kgrid/python-sdk/releases/download/1.0/kgrid_sdk-1.2.0-py3-none-any.whl"
  ```

  After installation, confirm that the CLI is installed and view the list of available commands by running:
  ```bash
  kgrid-sdk --help
  ```

  To package the content of the Knowledge Object using its metadata, run the following command:
  ```bash
  kgrid-sdk package --metadata-path /path/to/metadata.json --output output.tar.gz
  ```

  This command processes the specified metadata file and gathers all referenced content. By default the metadata file is included in the package. The resulting package will be saved as a tar.gz file with the specified output location and name. `--metadata-path` and `--output` are optional. If `--metadata-path` is not provided the command will look for `metadata.json` in the current directory. If `--output` is not provided the name of the parent directory where the metadata file is located and the version name will be used as the name of the outpu file and the output package will be saved in the current directory.

  By default all the file and folders will be added to the root of the package file. Use the option `--nested`to have all the files and folders copied in a folder in the created package with the name of the parent directory and the version. For example

  ```bash
  kgrid-sdk package --metadata-path /path/to/metadata.json --nested
  ```


pkgId: 4ef934bc35dd942388b9c67240aec35d9f2ea78dff79559b1bc267ed1b714f2d
name: python-khoj-help
arch: noarch
version: 1.32.0
epoch: 0
release: 1
summary: Development documents and examples for khoj
url: https://khoj.dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-khoj-1.32.0-1.src.rpm
location_href: Packages/python-khoj-help-1.32.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center"><img src="src/khoj/interface/web/assets/icons/khoj-logo-sideways-500.png" width="230" alt="Khoj Logo"></p>

  <div align="center">

  [![test](https://github.com/khoj-ai/khoj/actions/workflows/test.yml/badge.svg)](https://github.com/khoj-ai/khoj/actions/workflows/test.yml)
  [![docker](https://github.com/khoj-ai/khoj/actions/workflows/dockerize.yml/badge.svg)](https://github.com/khoj-ai/khoj/pkgs/container/khoj)
  [![pypi](https://github.com/khoj-ai/khoj/actions/workflows/pypi.yml/badge.svg)](https://pypi.org/project/khoj/)
  [![discord](https://img.shields.io/discord/1112065956647284756?style=plastic&label=discord)](https://discord.gg/BDgyabRM6e)

  </div>

  <div align="center">
  <b>Your AI second brain</b>
  </div>

  <br />

  <div align="center">

  [📑 Docs](https://docs.khoj.dev)
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  [🌐 Web](https://khoj.dev)
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  [🔥 App](https://app.khoj.dev)
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  [💬 Discord](https://discord.gg/BDgyabRM6e)
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  [✍🏽 Blog](https://blog.khoj.dev)

  </div>

  ***


  * Start any message with `/research` to try out the experimental research mode with Khoj.
  * Anyone can now [create custom agents](https://blog.khoj.dev/posts/create-agents-on-khoj/) with tunable personality, tools and knowledge bases.
  * [Read](https://blog.khoj.dev/posts/evaluate-khoj-quality/) about Khoj's excellent performance on modern retrieval and reasoning benchmarks.

  ***



  [Khoj](https://khoj.dev) is a personal AI app to extend your capabilities. It smoothly scales up from an on-device personal AI to a cloud-scale enterprise AI.

  - Chat with any local or online LLM (e.g llama3, qwen, gemma, mistral, gpt, claude, gemini).
  - Get answers from the internet and your docs (including image, pdf, markdown, org-mode, word, notion files).
  - Access it from your Browser, Obsidian, Emacs, Desktop, Phone or Whatsapp.
  - Create agents with custom knowledge, persona, chat model and tools to take on any role.
  - Automate away repetitive research. Get personal newsletters and smart notifications delivered to your inbox.
  - Find relevant docs quickly and easily using our advanced semantic search.
  - Generate images, talk out loud, play your messages.
  - Khoj is open-source, self-hostable. Always.
  - Run it privately on [your computer](https://docs.khoj.dev/get-started/setup) or try it on our [cloud app](https://app.khoj.dev).

  ***



  ![demo_chat](https://github.com/khoj-ai/khoj/blob/master/documentation/assets/img/quadratic_equation_khoj_web.gif?raw=true)

  Go to https://app.khoj.dev to see Khoj live.


  You can see the full feature list [here](https://docs.khoj.dev/category/features).



  To get started with self-hosting Khoj, [read the docs](https://docs.khoj.dev/get-started/setup).


  Cheers to our awesome contributors! 🎉

  <a href="https://github.com/khoj-ai/khoj/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=khoj-ai/khoj" />
  </a>

  Made with [contrib.rocks](https://contrib.rocks).



  We are always looking for contributors to help us build new features, improve the project documentation, or fix bugs. If you're interested, please see our [Contributing Guidelines](https://docs.khoj.dev/contributing/development) and check out our [Contributors Project Board](https://github.com/orgs/khoj-ai/projects/4).


pkgId: 19dc84495f2baee6306a10ffa68764c83495926800a11a016c99c5b5cd9b2d86
name: python-khoj-help
arch: noarch
version: 1.32.2
epoch: 0
release: 1
summary: Development documents and examples for khoj
url: https://khoj.dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-khoj-1.32.2-1.src.rpm
location_href: Packages/python-khoj-help-1.32.2-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center"><img src="https://assets.khoj.dev/khoj-logo-sideways-1200x540.png" width="230" alt="Khoj Logo"></p>

  <div align="center">

  [![test](https://github.com/khoj-ai/khoj/actions/workflows/test.yml/badge.svg)](https://github.com/khoj-ai/khoj/actions/workflows/test.yml)
  [![docker](https://github.com/khoj-ai/khoj/actions/workflows/dockerize.yml/badge.svg)](https://github.com/khoj-ai/khoj/pkgs/container/khoj)
  [![pypi](https://github.com/khoj-ai/khoj/actions/workflows/pypi.yml/badge.svg)](https://pypi.org/project/khoj/)
  [![discord](https://img.shields.io/discord/1112065956647284756?style=plastic&label=discord)](https://discord.gg/BDgyabRM6e)

  </div>

  <div align="center">
  <b>Your AI second brain</b>
  </div>

  <br />

  <div align="center">

  [📑 Docs](https://docs.khoj.dev)
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  [🌐 Web](https://khoj.dev)
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  [🔥 App](https://app.khoj.dev)
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  [💬 Discord](https://discord.gg/BDgyabRM6e)
  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
  [✍🏽 Blog](https://blog.khoj.dev)

  </div>

  ***


  * Start any message with `/research` to try out the experimental research mode with Khoj.
  * Anyone can now [create custom agents](https://blog.khoj.dev/posts/create-agents-on-khoj/) with tunable personality, tools and knowledge bases.
  * [Read](https://blog.khoj.dev/posts/evaluate-khoj-quality/) about Khoj's excellent performance on modern retrieval and reasoning benchmarks.

  ***



  [Khoj](https://khoj.dev) is a personal AI app to extend your capabilities. It smoothly scales up from an on-device personal AI to a cloud-scale enterprise AI.

  - Chat with any local or online LLM (e.g llama3, qwen, gemma, mistral, gpt, claude, gemini).
  - Get answers from the internet and your docs (including image, pdf, markdown, org-mode, word, notion files).
  - Access it from your Browser, Obsidian, Emacs, Desktop, Phone or Whatsapp.
  - Create agents with custom knowledge, persona, chat model and tools to take on any role.
  - Automate away repetitive research. Get personal newsletters and smart notifications delivered to your inbox.
  - Find relevant docs quickly and easily using our advanced semantic search.
  - Generate images, talk out loud, play your messages.
  - Khoj is open-source, self-hostable. Always.
  - Run it privately on [your computer](https://docs.khoj.dev/get-started/setup) or try it on our [cloud app](https://app.khoj.dev).

  ***



  ![demo_chat](https://github.com/khoj-ai/khoj/blob/master/documentation/assets/img/quadratic_equation_khoj_web.gif?raw=true)

  Go to https://app.khoj.dev to see Khoj live.


  You can see the full feature list [here](https://docs.khoj.dev/category/features).



  To get started with self-hosting Khoj, [read the docs](https://docs.khoj.dev/get-started/setup).


  Cheers to our awesome contributors! 🎉

  <a href="https://github.com/khoj-ai/khoj/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=khoj-ai/khoj" />
  </a>

  Made with [contrib.rocks](https://contrib.rocks).



  We are always looking for contributors to help us build new features, improve the project documentation, or fix bugs. If you're interested, please see our [Contributing Guidelines](https://docs.khoj.dev/contributing/development) and check out our [Contributors Project Board](https://github.com/orgs/khoj-ai/projects/4).


pkgId: 93b9d2739f43d9bc5634bc3fdfd451b873d20d2acbb28d1eeb356fb7b7553017
name: python-kiara-help
arch: noarch
version: 0.5.13
epoch: 0
release: 1
summary: Development documents and examples for kiara
url: https://pypi.org/project/kiara/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kiara-0.5.13-1.src.rpm
location_href: Packages/python-kiara-help-0.5.13-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI status](https://img.shields.io/pypi/status/kiara.svg)](https://pypi.python.org/pypi/kiara/)
  [![PyPI version](https://img.shields.io/pypi/v/kiara.svg)](https://pypi.python.org/pypi/kiara/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/kiara.svg)](https://pypi.python.org/pypi/kiara/)
  [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2FDHARPA-Project%2Fkiara%2Fbadge%3Fref%3Ddevelop&style=flat)](https://actions-badge.atrox.dev/DHARPA-Project/kiara/goto?ref=develop)
  [![Coverage Status](https://coveralls.io/repos/github/DHARPA-Project/kiara/badge.svg?branch=develop)](https://coveralls.io/github/DHARPA-Project/kiara?branch=develop)
  [![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  *A data-centric workflow orchestration framework.*

   - *kiara* user documentation: [https://dharpa.org/kiara.documentation](https://dharpa.org/kiara.documentation/)
   - Code: [https://github.com/DHARPA-Project/kiara](https://github.com/DHARPA-Project/kiara)
   - Development documentation for this repo: [https://dharpa.org/kiara](https://dharpa.org/kiara)



  *Kiara* is the data orchestration engine developed by the DHARPA project. It uses a modular approach
  to let users re-use tried and tested data orchestration pipelines, as well as create new ones from existing building
  blocks. It also helps you manage your research data, and augment it with automatically-, semi-automatically-, and manually-
  created metadata. Most of this is not yet implemented.





  - Python (version >=3.6 -- some make targets only work for Python >=3.7, but *kiara* itself should work on 3.6)
  - pip, virtualenv
  - git
  - make
  - [direnv](https://direnv.net/) (optional)




  ```console
  git clone https://github.com/DHARPA-Project/kiara.git
  cd kiara
  python3 -m venv .venv
  source .venv/bin/activate
  make init
  ```

  If you use [direnv](https://direnv.net/), you can alternatively do:

  ``` console
  git clone https://github.com/DHARPA-Project/kiara.git
  cd kiara
  cp .envrc.disabled .envrc
  direnv allow
  make init
  ```

  *Note*: you might want to adjust the Python version in ``.envrc`` (should not be necessary in most cases though)



  - ``init``: init development project (install project & dev dependencies into virtualenv, as well as pre-commit git hook)
  - ``update-modules``: update default kiara modules package from git
  - ``flake``: run *flake8* tests
  - ``mypy``: run *mypy* tests
  - ``test``: run unit tests
  - ``docs``: create static documentation pages (under ``build/site``)
  - ``serve-docs``: serve documentation pages (incl. auto-reload) for getting direct feedback when working on documentation
  - ``clean``: clean build directories

  For details (and other, minor targets), check the ``Makefile``.




  ``` console
  > make test

  > make coverage
  ```




  This project is MPL v2.0 licensed, for the license text please check the [LICENSE](/LICENSE) file in this repository.

  - Copyright (c) 2021, 2022 [DHARPA project](https://dharpa.org)
  - Copyright (c) 2021, 2022 Markus Binsteiner


pkgId: adc84a0357b6444348c3de8de307ade65934e81d7da921bb52aa6f768f6917f0
name: python-kiara-plugin.develop-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for kiara-plugin.develop
url: https://pypi.org/project/kiara-plugin.develop/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kiara-plugin.develop-0.5.3-1.src.rpm
location_href: Packages/python-kiara-plugin.develop-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI status](https://img.shields.io/pypi/status/kiara_plugin.develop.svg)](https://pypi.python.org/pypi/kiara_plugin.develop/)
  [![PyPI version](https://img.shields.io/pypi/v/kiara_plugin.develop.svg)](https://pypi.python.org/pypi/kiara_plugin.develop/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/kiara_plugin.develop.svg)](https://pypi.python.org/pypi/kiara_plugin.develop/)
  [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2FDHARPA-Project%2Fkiara%2Fbadge%3Fref%3Ddevelop&style=flat)](https://actions-badge.atrox.dev/DHARPA-Project/kiara_plugin.develop/goto?ref=develop)
  [![Coverage Status](https://coveralls.io/repos/github/DHARPA-Project/kiara_plugin.develop/badge.svg?branch=develop)](https://coveralls.io/github/DHARPA-Project/kiara_plugin.develop?branch=develop)
  [![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  Development utilities for kiara.

   - Documentation: [https://DHARPA-Project.github.io/kiara_plugin.develop](https://DHARPA-Project.github.io/kiara_plugin.develop)
   - Code: [https://github.com/DHARPA-Project/kiara_plugin.develop](https://github.com/DHARPA-Project/kiara_plugin.develop)
   - `kiara`: [https://dharpa.org/kiara.documentation](https://dharpa.org/kiara.documentation)



  TODO





  - Python (version >= 3.8)
  - pip, virtualenv
  - git
  - make (on Linux / Mac OS X -- optional)




  If you only want to work on the modules, and not the core *Kiara* codebase, follow the instructions below. Otherwise, please
  check the notes on how to setup a *Kiara* development environment under (TODO).



  The recommended way to setup a development environment is to use [pixi](https://github.com/prefix-dev/pixi). Check out [their install instructions](https://github.com/prefix-dev/pixi#installation).

  Once you have `pixi` installed, you need to initialize the environment once:

  ```
  pixi run install-dev-dependencies
  ```

  You also need to do this whenever a depdendency of this plugin is updated (for example the core `kiara` package).

  Once that is done, you can enter the environment with:

  ```
  pixi shell
  ```

  This will start a sub-shell with the virtual environment activated, and all dependencies of the plugin package installed. To confirm it works, you can run any `kiara` command:

  ```
  kiara --version

  kiara operation list

  ...
  ...
  ```

  Once you are finished with your development session, you can exit the sub-shell as you would normally do in such cases:

  ```
  exit
  ```

  Alternatively, you can also run the `kiara` executable directly, it is located in `.pixi/env/bin/kiara`. So either adapt your `PATH` variable, or do something like:

  ```
  .pixi/env/bin/kiara operation list
  ```

  In most cases it's recommended to use a pixi shell though.




  The included `pyproject.toml` file includes some useful tasks that help with development:

  - `pixi run pre-commit-check`: runs a set of checks against all files
  - `pixi run tests`: runs the unit tests
  - `pixi run mypy`: run mypy checks



  This project is MPL v2.0 licensed, for the license text please check the [LICENSE](/LICENSE) file in this repository.


pkgId: df4d7e5c7bd4d97d651d70b5749a4bbd47498eafe1ae3f369e3c1fe10c3c3394
name: python-kiara-plugin.jupyter-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for kiara-plugin.jupyter
url: https://pypi.org/project/kiara-plugin.jupyter/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kiara-plugin.jupyter-0.5.1-1.src.rpm
location_href: Packages/python-kiara-plugin.jupyter-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI status](https://img.shields.io/pypi/status/kiara_plugin.jupyter.svg)](https://pypi.python.org/pypi/kiara_plugin.jupyter/)
  [![PyPI version](https://img.shields.io/pypi/v/kiara_plugin.jupyter.svg)](https://pypi.python.org/pypi/kiara_plugin.jupyter/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/kiara_plugin.jupyter.svg)](https://pypi.python.org/pypi/kiara_plugin.jupyter/)
  [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2FDHARPA-Project%2Fkiara%2Fbadge%3Fref%3Ddevelop&style=flat)](https://actions-badge.atrox.dev/DHARPA-Project/kiara_plugin.jupyter/goto?ref=develop)
  [![Coverage Status](https://coveralls.io/repos/github/DHARPA-Project/kiara_plugin.jupyter/badge.svg?branch=develop)](https://coveralls.io/github/DHARPA-Project/kiara_plugin.jupyter?branch=develop)
  [![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  Jupyter integration for kiara

   - Documentation: [https://DHARPA-Project.github.io/kiara_plugin.jupyter](https://DHARPA-Project.github.io/kiara_plugin.jupyter)
   - Code: [https://github.com/DHARPA-Project/kiara_plugin.jupyter](https://github.com/DHARPA-Project/kiara_plugin.jupyter)
   - `kiara`: [https://dharpa.org/kiara.documentation](https://dharpa.org/kiara.documentation)



  TODO





  - Python (version >= 3.8)
  - pip, virtualenv
  - git
  - make (on Linux / Mac OS X -- optional)




  If you only want to work on the modules, and not the core *Kiara* codebase, follow the instructions below. Otherwise, please
  check the notes on how to setup a *Kiara* development environment under (TODO).



  The recommended way to setup a development environment is to use [pixi](https://github.com/prefix-dev/pixi). Check out [their install instructions](https://github.com/prefix-dev/pixi#installation).

  Once you have `pixi` installed, you need to initialize the environment once:

  ```
  pixi run install-dev-dependencies
  ```

  You also need to do this whenever a depdendency of this plugin is updated (for example the core `kiara` package).

  Once that is done, you can enter the environment with:

  ```
  pixi shell
  ```

  This will start a sub-shell with the virtual environment activated, and all dependencies of the plugin package installed. To confirm it works, you can run any `kiara` command:

  ```
  kiara --version

  kiara operation list

  ...
  ...
  ```

  Once you are finished with your development session, you can exit the sub-shell as you would normally do in such cases:

  ```
  exit
  ```

  Alternatively, you can also run the `kiara` executable directly, it is located in `.pixi/env/bin/kiara`. So either adapt your `PATH` variable, or do something like:

  ```
  .pixi/env/bin/kiara operation list
  ```

  In most cases it's recommended to use a pixi shell though.




  The included `pyproject.toml` file includes some useful tasks that help with development:

  - `pixi run pre-commit-check`: runs a set of checks against all files
  - `pixi run tests`: runs the unit tests
  - `pixi run mypy`: run mypy checks



  This project is MPL v2.0 licensed, for the license text please check the [LICENSE](/LICENSE) file in this repository.


pkgId: f95ec055ab4034f55bb30fc60f1512876d29a506d2c58a98d32a6aace1f4fe8e
name: python-kiara-plugin.onboarding-help
arch: noarch
version: 0.5.2
epoch: 0
release: 1
summary: Development documents and examples for kiara-plugin.onboarding
url: https://pypi.org/project/kiara-plugin.onboarding/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kiara-plugin.onboarding-0.5.2-1.src.rpm
location_href: Packages/python-kiara-plugin.onboarding-help-0.5.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI status](https://img.shields.io/pypi/status/kiara_plugin.onboarding.svg)](https://pypi.python.org/pypi/kiara_plugin.onboarding/)
  [![PyPI version](https://img.shields.io/pypi/v/kiara_plugin.onboarding.svg)](https://pypi.python.org/pypi/kiara_plugin.onboarding/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/kiara_plugin.onboarding.svg)](https://pypi.python.org/pypi/kiara_plugin.onboarding/)
  [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2FDHARPA-Project%2Fkiara%2Fbadge%3Fref%3Ddevelop&style=flat)](https://actions-badge.atrox.dev/DHARPA-Project/kiara_plugin.onboarding/goto?ref=develop)
  [![Coverage Status](https://coveralls.io/repos/github/DHARPA-Project/kiara_plugin.onboarding/badge.svg?branch=develop)](https://coveralls.io/github/DHARPA-Project/kiara_plugin.onboarding?branch=develop)
  [![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  kiara modules for data onboarding.

   - Documentation: [https://DHARPA-Project.github.io/kiara_plugin.onboarding](https://DHARPA-Project.github.io/kiara_plugin.onboarding)
   - Code: [https://github.com/DHARPA-Project/kiara_plugin.onboarding](https://github.com/DHARPA-Project/kiara_plugin.onboarding)
   - `kiara`: [https://dharpa.org/kiara.documentation](https://dharpa.org/kiara.documentation)



  TODO





  - Python (version >= 3.8)
  - pip, virtualenv
  - git
  - make (on Linux / Mac OS X -- optional)




  If you only want to work on the modules, and not the core *Kiara* codebase, follow the instructions below. Otherwise, please
  check the notes on how to setup a *Kiara* development environment under (TODO).



  The recommended way to setup a development environment is to use [pixi](https://github.com/prefix-dev/pixi). Check out [their install instructions](https://github.com/prefix-dev/pixi#installation).

  Once you have `pixi` installed, you need to initialize the environment once:

  ```
  pixi run install-dev-dependencies
  ```

  You also need to do this whenever a depdendency of this plugin is updated (for example the core `kiara` package).

  Once that is done, you can enter the environment with:

  ```
  pixi shell
  ```

  This will start a sub-shell with the virtual environment activated, and all dependencies of the plugin package installed. To confirm it works, you can run any `kiara` command:

  ```
  kiara --version

  kiara operation list

  ...
  ...
  ```

  Once you are finished with your development session, you can exit the sub-shell as you would normally do in such cases:

  ```
  exit
  ```

  Alternatively, you can also run the `kiara` executable directly, it is located in `.pixi/env/bin/kiara`. So either adapt your `PATH` variable, or do something like:

  ```
  .pixi/env/bin/kiara operation list
  ```

  In most cases it's recommended to use a pixi shell though.




  The included `pyproject.toml` file includes some useful tasks that help with development:

  - `pixi run pre-commit-check`: runs a set of checks against all files
  - `pixi run tests`: runs the unit tests
  - `pixi run mypy`: run mypy checks



  This project is MPL v2.0 licensed, for the license text please check the [LICENSE](/LICENSE) file in this repository.


pkgId: 15d39b8e64e6f53b41a4a546304714c305129c5819ec010bb28d0eb43d5e1c97
name: python-kiara-plugin.tabular-help
arch: noarch
version: 0.5.6
epoch: 0
release: 1
summary: Development documents and examples for kiara-plugin.tabular
url: https://pypi.org/project/kiara-plugin.tabular/
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kiara-plugin.tabular-0.5.6-1.src.rpm
location_href: Packages/python-kiara-plugin.tabular-help-0.5.6-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI status](https://img.shields.io/pypi/status/kiara_plugin.tabular.svg)](https://pypi.python.org/pypi/kiara_plugin.tabular/)
  [![PyPI version](https://img.shields.io/pypi/v/kiara_plugin.tabular.svg)](https://pypi.python.org/pypi/kiara_plugin.tabular/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/kiara_plugin.tabular.svg)](https://pypi.python.org/pypi/kiara_plugin.tabular/)
  [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2FDHARPA-Project%2Fkiara%2Fbadge%3Fref%3Ddevelop&style=flat)](https://actions-badge.atrox.dev/DHARPA-Project/kiara_plugin.tabular/goto?ref=develop)
  [![Coverage Status](https://coveralls.io/repos/github/DHARPA-Project/kiara_plugin.tabular/badge.svg?branch=develop)](https://coveralls.io/github/DHARPA-Project/kiara_plugin.tabular?branch=develop)
  [![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)



  kiara data-types and modules for working with tables and databases.

   - Documentation: [https://DHARPA-Project.github.io/kiara_plugin.tabular](https://DHARPA-Project.github.io/kiara_plugin.tabular)
   - Code: [https://github.com/DHARPA-Project/kiara_plugin.tabular](https://github.com/DHARPA-Project/kiara_plugin.tabular)
   - `kiara`: [https://dharpa.org/kiara.documentation](https://dharpa.org/kiara.documentation)



  TODO





  - Python (version >= 3.8)
  - pip, virtualenv
  - git
  - make (on Linux / Mac OS X -- optional)




  If you only want to work on the modules, and not the core *Kiara* codebase, follow the instructions below. Otherwise, please
  check the notes on how to setup a *Kiara* development environment under (TODO).



  The recommended way to setup a development environment is to use [pixi](https://github.com/prefix-dev/pixi). Check out [their install instructions](https://github.com/prefix-dev/pixi#installation).

  Once you have `pixi` installed, you need to initialize the environment once:

  ```
  pixi run install-dev-dependencies
  ```

  You also need to do this whenever a depdendency of this plugin is updated (for example the core `kiara` package).

  Once that is done, you can enter the environment with:

  ```
  pixi shell
  ```

  This will start a sub-shell with the virtual environment activated, and all dependencies of the plugin package installed. To confirm it works, you can run any `kiara` command:

  ```
  kiara --version

  kiara operation list

  ...
  ...
  ```

  Once you are finished with your development session, you can exit the sub-shell as you would normally do in such cases:

  ```
  exit
  ```

  Alternatively, you can also run the `kiara` executable directly, it is located in `.pixi/env/bin/kiara`. So either adapt your `PATH` variable, or do something like:

  ```
  .pixi/env/bin/kiara operation list
  ```

  In most cases it's recommended to use a pixi shell though.




  The included `pyproject.toml` file includes some useful tasks that help with development:

  - `pixi run pre-commit-check`: runs a set of checks against all files
  - `pixi run tests`: runs the unit tests
  - `pixi run mypy`: run mypy checks



  This project is MPL v2.0 licensed, for the license text please check the [LICENSE](/LICENSE) file in this repository.


pkgId: 8f989e7b9042f3ddd80f4b284f0c53f06d9da490bd4994dafeea4bc5a6bc1344
name: python-kiln-ai-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for kiln-ai
url: https://getkiln.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kiln-ai-0.7.1-1.src.rpm
location_href: Packages/python-kiln-ai-help-0.7.1-1.noarch.rpm
checksum_type: sha256
description:
  ```console
  pip install kiln_ai
  ```

  This package is the Kiln AI core library. There is also a separate desktop application and server package. Learn more about Kiln AI at [getkiln.ai](https://getkiln.ai) and on Github: [github.com/Kiln-AI/kiln](https://github.com/Kiln-AI/kiln).

  In this guide we'll walk common examples of how to use the library.

  The library has a [comprehensive set of docs](https://kiln-ai.github.io/Kiln/kiln_core_docs/index.html).

  - [Using the Kiln Data Model](#using-the-kiln-data-model)
    - [Understanding the Kiln Data Model](#understanding-the-kiln-data-model)
    - [Datamodel Overview](#datamodel-overview)
    - [Load a Project](#load-a-project)
    - [Load an Existing Dataset into a Kiln Task Dataset](#load-an-existing-dataset-into-a-kiln-task-dataset)
    - [Using your Kiln Dataset in a Notebook or Project](#using-your-kiln-dataset-in-a-notebook-or-project)
    - [Using Kiln Dataset in Pandas](#using-kiln-dataset-in-pandas)
  - [Advanced Usage](#advanced-usage)

  ```bash
  pip install kiln-ai
  ```


  Kiln projects are simply a directory of files (mostly JSON files with the extension `.kiln`) that describe your project, including tasks, runs, and other data.
  This dataset design was chosen for several reasons:
  - Git compatibility: Kiln project folders are easy to collaborate on in git. The filenames use unique IDs to avoid conflicts and allow many people to work in parallel. The files are small and easy to compare using standard diff tools.
  - JSON allows you to easily load and manipulate the data using standard tools (pandas, polars, etc)
  The Kiln Python library provides a set of Python classes that which help you easily interact with your Kiln dataset. Using the library to load and manipulate your dataset is the fastest way to get started, and will guarantees you don't insert any invalid data into your dataset. There's extensive validation when using the library, so we recommend using it to load and manipulate your dataset over direct JSON manipulation.

  - Project: a Kiln Project that organizes related tasks
    - Task: a specific task including prompt instructions, input/output schemas, and requirements
      - TaskRun: a sample (run) of a task including input, output and human rating information
      - DatasetSplit: a frozen collection of task runs divided into train/test/validation splits
      - Finetune: configuration and status tracking for fine-tuning models on task data

  Assuming you've created a project in the Kiln UI, you'll have a `project.kiln` file in your `~/Kiln Projects/Project Name` directory.
  ```python
  from kiln_ai.datamodel import Project
  project = Project.load_from_file("path/to/your/project.kiln")
  print("Project: ", project.name, " - ", project.description)

  tasks = project.tasks()
  for task in tasks:
      print("Task: ", task.name, " - ", task.description)
      print("Total dataset size:", len(task.runs()))
  ```

  If you already have a dataset in a file, you can load it into a Kiln project.
  **Important**: Kiln will validate the input and output schemas, and ensure that each datapoint in the dataset is valid for this task.
  - Plaintext input/output: ensure "output_json_schema" and "input_json_schema" not set in your Task definition.
  - JSON input/output: ensure "output_json_schema" and "input_json_schema" are valid JSON schemas in your Task definition. Every datapoint in the dataset must be valid JSON fitting the schema.
  Here's a simple example of how to load a dataset into a Kiln task:
  ```python
  import kiln_ai
  import kiln_ai.datamodel

  task_path = "/Users/youruser/Kiln Projects/test project/tasks/632780983478 - Joke Generator/task.kiln"
  task = kiln_ai.datamodel.Task.load_from_file(task_path)

  item = kiln_ai.datamodel.TaskRun(
      parent=task,
      input='{"topic": "AI"}',
      output=kiln_ai.datamodel.TaskOutput(
          output='{"setup": "What is AI?", "punchline": "content_here"}',
      ),
  )
  item.save_to_file()
  print("Saved item to file: ", item.path)
  ```
  And here's a more complex example of how to load a dataset into a Kiln task. This example sets the source of the data (human in this case, but you can also set it be be synthetic), the created_by property, and a 5-star rating.
  ```python
  import kiln_ai
  import kiln_ai.datamodel

  task_path = "/Users/youruser/Kiln Projects/test project/tasks/632780983478 - Joke Generator/task.kiln"
  task = kiln_ai.datamodel.Task.load_from_file(task_path)

  item = kiln_ai.datamodel.TaskRun(
      parent=task,
      input='{"topic": "AI"}',
      input_source=kiln_ai.datamodel.DataSource(
          type=kiln_ai.datamodel.DataSourceType.human,
          properties={"created_by": "John Doe"},
      ),
      output=kiln_ai.datamodel.TaskOutput(
          output='{"setup": "What is AI?", "punchline": "content_here"}',
          source=kiln_ai.datamodel.DataSource(
              type=kiln_ai.datamodel.DataSourceType.human,
              properties={"created_by": "Jane Doe"},
          ),
          rating=kiln_ai.datamodel.TaskOutputRating(score=5,type="five_star"),
      ),
  )
  item.save_to_file()
  print("Saved item to file: ", item.path)
  ```

  You can use your Kiln dataset in a notebook or project by loading the dataset into a pandas dataframe.
  ```python
  import kiln_ai
  import kiln_ai.datamodel

  task_path = "/Users/youruser/Kiln Projects/test project/tasks/632780983478 - Joke Generator/task.kiln"
  task = kiln_ai.datamodel.Task.load_from_file(task_path)
  runs = task.runs()
  for run in runs:
      print(f"Input: {run.input}")
      print(f"Output: {run.output.output}")
  print(f"Total runs: {len(runs)}")
  ```

  You can also use your Kiln dataset in a pandas dataframe, or a similar script for other tools like polars.
  ```python
  import glob
  import json
  import pandas as pd
  from pathlib import Path
  task_dir = "/Users/youruser/Kiln Projects/test project/tasks/632780983478 - Joke Generator"
  dataitem_glob = task_dir + "/runs/*/task_run.kiln"
  dfs = []
  for file in glob.glob(dataitem_glob):
      js = json.loads(Path(file).read_text())
      df = pd.DataFrame([{
          "input": js["input"],
          "output": js["output"]["output"],
      }])
      
      
      dfs.append(df)
  final_df = pd.concat(dfs, ignore_index=True)
  print(final_df)
  ```

  The library can do a lot more than the examples we've shown here.
  See the [docs](https://kiln-ai.github.io/Kiln/kiln_core_docs/index.html) for more information.


pkgId: 03aad444322c0063d92da6824cb23ff8a98d1978a534dfa6443675cdd40e4b9e
name: python-kinfer-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for kinfer
url: https://github.com/kscalelabs/kinfer.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kinfer-0.0.6-1.src.rpm
location_href: Packages/python-kinfer-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  This package is designed to support exporting and running inference on PyTorch models.



  ```bash
  pip install kinfer
  ```



  You can install the latest version of ONNX Runtime on Mac with:

  ```bash
  brew install onnxruntime
  ```

  You may need to add the binary to your DYLD_LIBRARY_PATH:

  ```bash
  $ brew ls onnxruntime
  /opt/homebrew/Cellar/onnxruntime/1.20.1/include/onnxruntime/ (11 files)
  /opt/homebrew/Cellar/onnxruntime/1.20.1/lib/libonnxruntime.1.20.1.dylib  # <-- This is the binary
  /opt/homebrew/Cellar/onnxruntime/1.20.1/lib/cmake/ (4 files)
  /opt/homebrew/Cellar/onnxruntime/1.20.1/lib/pkgconfig/libonnxruntime.pc
  /opt/homebrew/Cellar/onnxruntime/1.20.1/lib/libonnxruntime.dylib
  /opt/homebrew/Cellar/onnxruntime/1.20.1/sbom.spdx.json
  $ export DYLD_LIBRARY_PATH=/opt/homebrew/Cellar/onnxruntime/1.20.1/lib:$DYLD_LIBRARY_PATH
  ```


pkgId: c06408ab50893b30f96438139237e4576492cdd1a554fddf5e0c480fc96f851b
name: python-kishu-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for kishu
url: https://pypi.org/project/kishu/
rpm_license: License not determined
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kishu-0.3.0-1.src.rpm
location_href: Packages/python-kishu-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Intelligent checkpointing framework for Python-based machine learning and scientific computing.
  Under development as part of a research project at the University of Illinois at Urbana-Champaign.

  `kishu` contains core Kishu components: a Jupyter instrument and a library of Kishu commands. Main user interface is Kishu's command line interface (CLI): `kishu`.




  Install from PyPI.
  ```
  pip install kishu
  ```



  Installing Kishu in the editable mode.

  ```bash
  make install
  ```

  Formatting source code.

  ```bash
  make fmt
  ```

  Linting source code (e.g., definitions, type checking).

  ```bash
  make lint
  ```

  Running all unit tests. It generates a coverage report at `./htmlcov/index.html`.
  ```bash
  make test
  ```

  Running PyTest with benchmarks.
  ```bash
  pytest --run-benchmark
  ```



  The following command will upload this project to pypi (https://pypi.org/project/kishu/).

  ```
  bash upload2pypi.sh
  ```


pkgId: e84f4da8cef5f66fd36cd119465cad11c433c005aaef0acf25dbb8d3940ba255
name: python-kivera-sdk-help
arch: noarch
version: 1.30.0
epoch: 0
release: 1
summary: Development documents and examples for kivera-sdk
url: https://github.com/kivera-io/python-client
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kivera-sdk-1.30.0-1.src.rpm
location_href: Packages/python-kivera-sdk-help-1.30.0-1.noarch.rpm
checksum_type: sha256
description:
  Python library to interact with the Kivera Graphql API



  ```
  pip install kivera-sdk
  ```


  ```
  import kivera
  import json

  creds = "/path/to/user-api-key.json"
  with open(creds) as f:
    creds_json = json.load(f)
  client = kivera.Client(credentials=creds_json)
  print(client.ListOrganizationPolicyFunctions())
  print(client.ListRulesV4())
  ```


pkgId: 4484a7f1b38308039b476f3b0ac7d6ba17c1577ee6c5bb6b3cbdf152d5959a89
name: python-kiwi-help
arch: noarch
version: 10.2.4
epoch: 0
release: 1
summary: Development documents and examples for kiwi
url: https://osinside.github.io/kiwi/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kiwi-10.2.4-1.src.rpm
location_href: Packages/python-kiwi-help-10.2.4-1.noarch.rpm
checksum_type: sha256
description:
  |GitHub Action Code Style| |GitHub Action Config Functions| |GitHub Action Documentation| |GitHub Action Publish Pages| |GitHub Action Publish PyPi| |GitHub Action Unit Types| |Health|
  **KIWI, the OS image and appliance builder.**
  * |Installation|
  * |Contributing|
  * |Doc|
  We'll donate it for good luck so's you're sure to come back :)
  |Donate|


pkgId: 7651f900b8e9afc4c027bc158c4fbe27a83fed829c8f3504bc8d228efe004257
name: python-klfuncutil-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for klfuncutil
url: https://pypi.org/project/klfuncutil/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-klfuncutil-1.0.2-1.src.rpm
location_href: Packages/python-klfuncutil-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  "Functional Programming" distinguishes between:

  1. Data
  2. Functions
  3. Actions


  Data should be treated as immutable.
  For example, if an element is added to a list,
  a new "list" object is created. The source remains
  unchanged. This corresponds to the behavior of strings in Python.
  The situation is different with the "Collection" objects in Python.
  The classes:
  - list
  - dict

  can be changed "in place". "tuple" and "set" cannot, however.
  The module "collection.py" provides the functions:
  - append_element
  - append_collection
  - remove_element

  which can be used to edit:
  - list
  - dict
  - tuple

  in the same way. The source remains
  unchanged in each case. The result is always a new object of the same class as the source.


  Functions - or "pure functions" are used to implement
  business rules. The result depends only on the
  input parameters of the function. The iterators, which are also frequently used in
  functional programming, lead to surprising effects.

  Example:
  ```
  def get_even_num(list_of_numbers):
  return filter(lambda x: x % 2 == 0, list_of_numbers)


  coll_even_num = get_even_num([1,2,3,4,5,6,7,8])

  print(sum(coll_even_num))
  print(sum(coll_even_num))
  ```
  The output is:
  ```
  20
  0
  ```
  The result is quickly explained: the function "sum" used up the iterator "coll_even_num" with the first call. With the second call, this iterator no longer returns any values ​​- the result is "0".
  If you run the example shown above with an object of the class "list", a different result is returned:

  ```
  def get_even_num_as_list(list_of_numbers):
  return list(filter(lambda x: x % 2 == 0, list_of_numbers))


  coll_even_num = get_even_num([1,2,3,4,5,6,7,8])

  print(sum(coll_even_num))
  print(sum(coll_even_num))
  ```
  The output is:
  ```
  20
  20
  ```

  An important feature of Python is generic algorithms.
  These (like the "sum" function) can work with different input data such as:
  - tuple
  - list
  - iterator

  The "iterator.py" module provides the "decorators":
  - restartable_t
  - restartable_m

  These can be used on functions that return "iterators".
  The "decorator" is used to package the "iterator" in a class that returns a new "iterator" every time the function ``__iter__()`` is called. "restartable_t" and "restartable_m" use different methods to
  get a new "iterator":
  - "restartable_t" calls the function that created the original "iterator" again.
  - "restartable_m" uses the "itertools.tee" function internally.

  "restartable_t" and "restartable_m" cannot, of course, perform miracles - they merely compensate for the unexpected behavior of the "iterator". "restartable_t" does this at the expense of runtime - "restartable_m" at the expense of storage space.

  Example:
  ```
  from klfuncutil.iterator import restartable_t

  @restartable_t
  def get_even_num(list_of_numbers):
  return filter(lambda x: x % 2 == 0, list_of_numbers)


  coll_even_num = get_even_num([1,2,3,4,5,6,7,8])

  print(sum(coll_even_num))
  print(sum(coll_even_num))
  ```
  The output is:
  ```
   20
   20
  ```


  https://github.com/nuuk42/klfuncutil.git


  Use: pip install klfuncutil


pkgId: 775819f286f87d92588b3c3cad4df6eb77c8eaea41c8f144a6fa810e37cd41cf
name: python-kloppy-help
arch: noarch
version: 3.16.0
epoch: 0
release: 1
summary: Development documents and examples for kloppy
url: https://kloppy.pysport.org/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kloppy-3.16.0-1.src.rpm
location_href: Packages/python-kloppy-help-3.16.0-1.noarch.rpm
checksum_type: sha256
description:
  > klop·pen (klopte, heeft geklopt) - juist zijn; overeenkomen, uitkomen met: *dat klopt, dat kan kloppen* is juist; *dat klopt als een zwerende vinger* dat is helemaal juist

  [![PyPI Latest Release](https://img.shields.io/pypi/v/kloppy.svg)](https://pypi.org/project/kloppy/)
  [![Downloads](https://pepy.tech/badge/kloppy/month)](https://pepy.tech/project/kloppy/month)
  ![](https://img.shields.io/github/license/PySport/kloppy)
  ![](https://img.shields.io/pypi/pyversions/kloppy)
  [![Powered by PySport](https://img.shields.io/badge/powered%20by-PySport-orange.svg?style=flat&colorA=104467&colorB=007D8A)](https://pysport.org)



  Each vendor of soccer data uses its own unique format to describe the course of a game. Hence, software written to analyze this data has to be tailored to a specific vendor and cannot be used without modifications to analyze data from other vendors. Kloppy is a Python package that addresses the challenges posed by the variety of data formats and aims to be the fundamental building block for processing soccer tracking and event data. It provides (de)serializers, standardized data models, filters, and transformers which make working with tracking and event data from different vendors a breeze.



  Here are just a few of the things that kloppy does well:


  - Load **public datasets** to get started right away
  - Understandable **standardized data models** for tracking and event data
  - Out-of-the-box **(de)serializing** tracking and event data from different vendors into standardized models and vice versa


  - Flexibly transform a dataset's **pitch dimensions** from one format to another (e.g., from OPTA's 100x100 to TRACAB meters)
  - Transform the **orientation** of a dataset (e.g., from TRACAB fixed orientation to "Home Team" orientation)


  - Search for **[complex patterns](https://github.com/PySport/kloppy/blob/master/examples/pattern_matching/repository/README.md)** in event data
  - Use `kloppy-query` to export fragments to XML file




  The source code is currently hosted on GitHub at: [https://github.com/PySport/kloppy](https://github.com/PySport/kloppy).

  Installers for the latest released version are available at the [Python package index](https://pypi.org/project/kloppy).

  ```sh
  pip install kloppy
  ```

  Install from github (dev version)

  ```sh
  pip install git+https://github.com/PySport/kloppy.git
  ```



  The official documentation is hosted on pysport.org: [https://kloppy.pysport.org](https://kloppy.pysport.org).




  All contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome.

  An overview on how to contribute can be found in the **[contributing guide](https://kloppy.pysport.org/contributing)**.

  If you are simply looking to start working with the kloppy codebase, navigate to the GitHub "issues" tab and start looking through interesting issues.



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

  Made with [contrib.rocks](https://contrib.rocks).


pkgId: 066cff992c8bf7d887151ea56a95c1046e054da6ac8bcfa2bda1c03e50638b27
name: python-klp-logviewer-help
arch: noarch
version: 0.73.0
epoch: 0
release: 1
summary: Development documents and examples for klp-logviewer
url: https://pypi.org/project/klp-logviewer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-klp-logviewer-0.73.0-1.src.rpm
location_href: Packages/python-klp-logviewer-help-0.73.0-1.noarch.rpm
checksum_type: sha256
description:
  _Kool Log Parser_

  klp is a lightweight, command-line interface (CLI) tool for analyzing and understanding structured logs in various formats.
  Designed for software developers involved in debugging and troubleshooting.

  Supports [logfmt](https://brandur.org/logfmt), [JSON Lines](https://jsonlines.org),
  [CSV](https://en.wikipedia.org/wiki/Comma-separated_values), [TSV](https://en.wikipedia.org/wiki/Tab-separated_values), [SQLite](https://sqlite.org) and many other formats.

  Single file Python script without dependencies apart from Python 3.7+ and its standard library.

  ![](demo/basic.png)



  - [Key Features](#key-features)
  - [Getting Started](#getting-started)
    - [Installation](#installation)
    - [Quick Start](#quick-start)
    - [Basic Usage](#basic-usage)
  - [Core Features](#core-features)
    - [Input Handling](#input-handling)
    - [Error Handling](#error-handling)
    - [Event Creation](#event-creation)
    - [Overview and Statistics](#overview-and-statistics)
    - [Time Management](#time-management)
    - [Search and Filter](#search-and-filter)
    - [Output Control](#output-control)
  - [Advanced Usage](#advanced-usage)
    - [Complex Filtering with Python Expressions](#complex-filtering-with-python-expressions)
    - [Advanced Input Transformations Using Python Code](#advanced-input-transformations-using-python-code)
    - [Custom Output Formatting using Python](#custom-output-formatting-using-python)
  - [Additional Resources](#additional-resources)
    - [Complementary Tools](#complementary-tools)
    - [Alternative Tools](#alternative-tools)



  - **Focus on Essentials**:
  Instantly highlight key fields: timestamp, log level, and message.
  - **Advanced Time Analysis**:
  Track time gaps in logs, fuse bursts of events, and filter by complex time ranges.
  - **Smart Filtering**:
  Filter by log level, time spans, or using Python expressions.
  - **Pattern Search**:
  Grep in specific fields and show context lines.
  Use a wide range of built-in patterns to search or extract URLs, IPs, paths, email addresses, errors, and more.
  - **Visual Insights**:
  Get statistics about the number of events and the occuring log levels, visually mark time gaps between events and see a succinct map of log level patterns.
  - **Enhanced Readability**:
  Color-coding, per-key display, expandable newlines and custom output templates using Python expressions.
  - **Format Conversion**:
  Convert between common formats like logfmt, JSON, JSONL, CSV, TSV and SQLite.
  - **Powerful Log Transformation**:
  Transform unstructured logs into structured data using Python code and convenient helper methods.
  Create simple ad-hoc parsers for your own custom formats, add proper field names and save the result in any of the supported output formats.





  Install using pip:

  ```bash
  $ pip install klp-logviewer
  ```

  Or just download `klp.py` and run it using `python3`, without any installation.



  Here are some basic examples to get you started with klp:

  ```bash

  $ klp mylog.logfmt


  $ klp -f jsonl applog.jsonl
  $ klp -f csv mydata.csv
  $ klp -f line text.txt


  $ klp -k timestamp,level,message mylog.logfmt


  $ klp -p mylog.logfmt


  $ klp -l error,warning mylog.logfmt


  $ klp -S mylog.logfmt


  $ tail -f mylog.logfmt | klp -n
  ```



  klp can be used as a filter, reading from stdin:

  ```bash
  $ tail -f log.txt | klp
  ```

  Or you can read from a file:

  ```bash
  $ klp log.txt
  ```

  klp can directly process compressed log files:

  ```bash
  $ klp app.log.gz
  $ klp logs.zip
  ```

  Options can be given before or after the filename.
  See `klp --help` for the list of available options.




  **Filter by Log Level:**
  Use `--loglevels`/`-l` to restrict the output to specific log levels:

  ```bash
  $ cat mylog.txt | klp -l warning,error,fatal
  ```

  Exclude log levels with `--not-loglevel`/`-L`:
  ```bash
  $ cat mylog.txt | klp -L trace,debug
  ```

  **Filter by Time:**
  klp tries to parse timestamps automatically.
  The following keys are treated as possibly holding timestamps: `timestamp`, `ts`, `time`, `at`.

  ```bash

  $ klp --since 1h app.log


  $ klp --from "2024-02-05T20:18:10Z" --to "2024-02-05T20:19:20Z" app.log
  ```

  **Filter by Regex:**

  Use `--grep`/`-g` for simple text search with regular expressions:

  ```bash

  $ klp -g "error" app.log


  $ klp -g "error" -i app.log


  $ klp -g "message~error" app.log
  ```







  klp supports a wide range of input formats:

  - `logfmt`: Key-value pairs (**default**)
  - `jsonl`: JSON Lines (shortcut: `-j`)
  - `json`: JSON (only for complete files, not for streaming)
  - `csv`: Comma-separated values
  - `tsv`: Tab separated values
  - `psv`: Pipe separated values
  - `line`: lines of text (trailing whitespace removed)
  - `tsNm`: logs containing a timestamp (with N components) and a message. See below for examples.
  - `tsNlm`: logs containing a timestamp (with N components), a log level and a message
  - `unix`: Common format of Unix server logs (timestamp, hostname, service, optional pid, message)
  - `clf`: NCSA Common Log Format
  - `combined`: Combined Log Format of Apache httpd
  - `sqlite`: SQLite database (use `--input-tablename` if more than one table is present)
  - `data`: Parse everything as one string

  Use the `--input-format` or `-f` option to specify the input format. For example:

  ```bash
  $ klp -f jsonl input.log
  ```

  The `tsNm` formats allows parsing logs that consist of a timestamp, and a message.
  `N` indicates how many whitespace-separated components the timestamp consists of.
  Use `tsNlm` for logs that contain a log level between the timestamp and the message.
  Here are some examples:

  ```bash


  $ klp -f ts1m server.log



  $ klp -f ts2lm worker.log



  $ klp -f ts3m batch.log
  ```

  Similar formats exist up to `ts5m`/`ts5lm` for logs with more timestamp components.
  The timestamp parts are joined and parsed using klp's standard timestamp parsing logic.

  More complicated formats can often be parsed using the `line` format and creating or transforming events using Python code (`--input-exec`).
  See the [Advanced input transformations using Python code](#advanced-input-transformations-using-python-code) section below.
  Alternatively, you can check out [jc](https://github.com/kellyjonbrazil/jc), a tool that converts numerous formats to JSON, which can be read by klp `-f json`.



  klp provides several options to control how input data is read and parsed:

  - `--input-encoding`: Specify the text encoding of the input data (default: utf-8)
    ```bash
    
    $ klp --input-encoding latin1 legacy.logfmt

    
    $ klp -f line --input-encoding cp1252 windows.log
    ```

  - `--no-header`: For CSV, TSV, or PSV formats, indicates that the file has no header row.
    This will auto-generate numbered column keys.
    ```bash
    
    $ klp -f csv --no-header data.csv
    ```

  - `--input-delimiter`: Specify the delimiter for CSV, TSV, or PSV formats
    ```bash
    
    $ klp -f csv --input-delimiter ";" european.csv

    
    $ klp -f csv --input-delimiter ":" custom.log
    ```

  - `--skip`: Avoid parsing the first N lines (e.g. to skip comments or old data).
    ```bash
    
    $ klp -f csv --skip 5 data.csv
    ```



  Control how klp handles errors with the `--errors` option:

  - `ignore` (default): Silently continue processing when errors occur. With `--debug`, errors will still be printed.
  - `print`: Print error messages to stderr but continue processing
  - `exit`: Print error messages to stderr and exit with status code 1

  ```bash

  $ klp --errors print malformed.log


  $ klp --errors exit app.log


  $ klp --errors ignore mixed.log


  $ klp --errors ignore --debug mixed.log
  ```



  klp parses each line of the input file (or stdin stream) into an *event*.
  If a line cannot be parsed, it is ignored silently.
  An event can have several *fields* (key/value pairs).
  The events in a file or stream don't have to have the same fields.

  klp tries to automatically detect timestamps, log levels and log messages
  by looking for the following keys:

  * Timestamp keys: `timestamp`, `time`, `ts`, `t`, `at`
  * Log level keys: `log_level`, `loglevel`, `level`, `lvl`, `severity`
  * Message keys: `message`, `msg`

  klp has special features to select events by timestamp or log level (see below).





  Use `--stats-only`/`-S` to get some basic statistics about number of events in the log file,
  the timespan, the names of the keys and the log levels:

  ```bash
  $ klp -S mylog.logfmt
  Events shown: 8043 (100% of 8043 lines seen)
  Time span shown: 2024-02-05T19:58:59.874Z to 2024-02-05T20:19:20.575Z (0:20:20.701000)
  Keys seen: timestamp,log_level,source,target,thread_id,message
  Log levels seen: DEBUG,TRACE,INFO (keys: log_level)
  ```

  Or use `--stats`/`-s` to print those stats (to stderr), in addition to regular output.


  Use `--levelmap`/`-M` to print only the first character of the log level of each event.
  The timestamp is for the first event shown in that line:

  ```bash
  $ klp -M mylog.logfmt
  2024-02-05T20:18:10.538Z TTTTDTTTDITITTTTTTTTTTTTTTTDTTTDITITTTTTTTTTTTTTTTDTTTDITITTTTTTTTTTTTTTTDTTTDIT
  2024-02-05T20:18:30.546Z ITTTTTTTTTTTTTTTDDTTITITTTTTTTTTTTTTTITITTTTTTTTTTTTTTTTITITTTTTTTTTTTTTTTTITITT
  ```


  Visualize patterns for any key:

  ```bash
  $ klp --keymap status_code app.log
  ```





  klp tries to parse timestamps automatically.
  The following keys are treated as possibly holding timestamps: `timestamp`, `ts`, `time`, `at`.
  You can specify your own key with `--ts-key KEY`.

  klp includes a list of common time formats that will be tried for parsing.
  Use `--ts-format` to specify your own format, using [Python strptime() format codes](https://docs.python.org/3/library/datetime.html#format-codes) (e.g. `%a %d %b %Y, %I:%M%p` to parse `Mon 31 Jan 2022, 11:59PM`).
  A short reference of the format codes can be printed with `klp --help-time`.

  There are multiple ways to specify the time range that you're interested in:

  * absolute time: `--from ISODATETIME` and `--to ISODATETIME`
  * relative from now: `--since INTERVAL` and `--until INTERVAL`
  * timespan, computed from program start: `--duration INTERVAL`
  * timespan, computed from first event shown: , `--timespan INTERVAL`

  Timespans can be specified with these units (for example: `--since 1w2h3.2s`):

  - `w` = weeks
  - `d` = days
  - `h` = hours
  - `m` = minutes
  - `s` = seconds
  - `ms` = milliseconds
  - `us` = microseconds


  By default, klp preserves timestamps as they appear in the logs.
  Use the following options to control how timestamps are displayed:

  * `--localtime`/`-z`: Convert timestamps to your local timezone
  * `--utc`/`-Z`: Convert timestamps to UTC

  ```bash

  $ klp --localtime -c mylog.logfmt
  2015-03-26T06:27:38.000+01:00 debug Started observing beach


  $ klp --utc -c mylog.logfmt
  2015-03-26T05:27:38.000Z debug Started observing beach
  ```

  Note that timezone conversion can slightly impact performance when processing large log files.
  Only use these options when timezone conversion is specifically needed.

  These options cannot be used together - choose either local time or UTC.
  They work with all input formats and can be combined with other timestamp-related features like `--since`, `--until`, and `--timespan`.



  Use `--mark-gaps` to visually separate events that are far apart in time:

  ```bash
  $ klp prometheus.logfmt -c --mark-gaps 1h
  2024-02-05T11:00:02.081Z info Deleting obsolete block
  _______________________________ time gap: 1:59:59.984000 ________________________________
  2024-02-05T13:00:02.065Z info write block
  2024-02-05T13:00:02.075Z info Head GC completed
  2024-02-05T13:00:02.076Z info Creating checkpoint
  2024-02-05T13:00:02.235Z info WAL checkpoint complete
  _______________________________ time gap: 1:59:59.666000 ________________________________
  2024-02-05T15:00:01.901Z info write block
  2024-02-05T15:00:01.905Z info Head GC completed
  _______________________________ time gap: 1:59:59.984000 ________________________________
  2024-02-05T17:00:01.889Z info write block
  2024-02-05T17:00:01.893Z info Head GC completed
  ```


  The `--fuse` option allows you to condense events that occur close together in time.

  ```bash
  $ klp -c --fuse 1h prometheus.logfmt
  1 2024-02-05T15:00:01.901Z info write block
  3 2024-02-05T15:00:01.905Z info Head GC completed
  _______________________________ time gap: 1:59:59.984000 ________________________________
  1 2024-02-05T17:00:01.889Z info write block
  9 2024-02-05T17:00:02.111Z info Deleting obsolete block
  _______________________________ time gap: 1:59:59.782000 ________________________________
  1 2024-02-05T19:00:01.893Z info write block
  3 2024-02-05T19:00:01.897Z info Head GC completed
  ```

  This shows only the first and last events for each group of events that occur within 1 hour of each other.
  From the event number in the first column you can see how many events were left out.




  Use `--grep`/`-g` to limit the processing to lines that match a given regular expression.
  When this flag is given multiple times, any of those regexes matching
  will allow the line to be processed (logical OR).

  ```bash

  $ klp -g "error" -g "warning" app.log


  $ klp -g "message~error" app.log
  ```

  To specify lines that should NOT be processed, use `--grep-not`/`-G`/`-v`.

  Search is case-sensitive by default.
  Use `--ignore-case`/`-i` for case-insensitive matches.


  Like with the original UNIX grep, klp can print context lines:
  - `-B N`: Show N lines before match
  - `-A N`: Show N lines after match
  - `-C N`: Show N lines before and after match

  Events before the matching line are visually marked with `/`, lines after with `\`.


  klp has several builtin regexes to match URLs, email addresses, common errors, path names, FQDN's or IPv4 addresses.
  Use `--grep-builtin`/`-r` to use them for matching lines or `--grep-builtin-not`/`-R` for ignoring them.

  Use `--extract`/`-x` to output only the matched portions:

  ```bash

  $ klp -f line -x email mail.log


  $ klp -f jsonl --extract url app.jsonl


  $ klp -x ipv4 -x err server.logfmt
  ```

  Use `klp -x ?` to list all available extraction patterns.
  They are also documented as `extract_*()` functions in `klp --help-python` screen.



  You can define start and stop conditions to process specific blocks of logs:

  - `--start-after REGEX`: Start processing after a line matching REGEX
  - `--start-with REGEX`: Start processing when a line matches REGEX
  - `--stop-with REGEX`: Stop processing after a line matches REGEX
  - `--stop-before REGEX`: Stop processing when a line matches REGEX

  ```bash
  $ klp --start-after "Session started" --stop-before "Session ended" app.log
  $ klp --start-with "[Uu]ser \w+ logged in" --stop-with "[Uu]ser \w+ logged out" app.log
  ```

  Use `--num-blocks` to limit the number of start/stop blocks processed.






  By default, klp prints every event that was recognized and shows both the key and the value of each field.
  Colors are used for syntax-highlighting (use `--no-color` or the `NOCOLOR` environment variable to turn this off or `--theme` to select different colors).



  To select specific fields, use `--keys`/`-k` and a comma-separated list of keys:

  ```bash
  $ klp -k timestamp,message mylog.txt
  timestamp="2022-09-05T06:25:27.465Z" message="poll_read: waiting on response"
  ```

  Or specify fields to exclude using `--keys-not`/`-K`.

  Use `--plain`/`-p` to leave out the keys and only print the values:

  ```bash
  $ cat mylog.txt | klp -k -p timestamp,message
  2022-09-05T06:25:27.465Z poll_read: waiting on response
  ```



  Often the time stamp, log level and message are the most important fields.
  Use `--common`/`-c` to print them, without showing the names of the keys (only the values):

  ```bash
  $ klp -c mylog.txt
  2023-01-17T07:55:48.233Z DEBUG preparing query s190578: select * from applications
  2023-01-17T07:55:48.234Z DEBUG executing statement s190578 with parameters: []
  2023-01-17T07:55:48.656Z DEBUG preparing query s190579: select * from oauthproviderconfig where id = 0
  2023-01-17T07:55:48.657Z DEBUG executing statement s190579 with parameters: []
  2023-01-17T07:55:48.662Z DEBUG preparing query s190580: select * from oauthproviderconfig where id = 0
  2023-01-17T07:55:48.663Z DEBUG executing statement s190580 with parameters: []
  ```


  klp can add some additional, synthetic fields to the event.
  For performance reasons this is only done if you explicitly list these keys using `--keys`/`-k`.

  * `_klp_timedelta`: time span between this event and the event before (hours:minutes:seconds.microseconds)
  * `_klp_ts`: timestamp showing when the event was shown by klp


  klp supports multiple output formats:

  - `default`: Colored and formatted logfmt
  - `logfmt`: Plain logfmt
  - `jsonl`: JSON Lines (shortcut: `-J`)
  - `json`: JSON
  - `csv`: Comma separated values
  - `tsv`: Tab separated values
  - `psv`: Pipe separated values
  - `sqlite`: SQLite database
  - `extract`: Only output the grep matches

  Select an output format with `--output-format` or `-F`:

  ```bash
  $ klp -F jsonl app.log > output.jsonl
  $ klp -F sqlite -o app.db app.log
  ```


  Customize your output with:

  - `--header`: Add text before the first event
  - `--footer`: Add text after the last event
  - `--output-sep`: Specify the separator between fields
  - `--output-event-sep`: Specify the separator between events (default: newline)
  - `--output-delimiter`: CSV/TSV/PSV output delimiter
  - `--output-quoting`: CSV/TSV/PSV output quoting (`minimal`,`all`,`nonnumeric`,`none`)
  - `--indent`, `--no-indent`: Control indentation
  - `--expand`: Expand newlines
  - `--no-wrap`: Disable line wrapping
  - `--each-key`: Print each key on a separate line

  For advanced formatting, see [Custom Output Formatting using Python](#custom-output-formatting-using-python).


  Use `--output-file`/`-o` to direct output to a file instead of stdout.
  This can be used to convert the events to a different file format:

  ```bash

  $ klp app.log -o processed.log


  $ klp app.log -F json -o events.json


  $ klp app.log -s -F jsonl -o events.jsonl
  ```

  Note: Using `--output-file` disables color output by default, unless explicitly requested with `--color`.





  Use `--where EXPR` to only process lines where the given Python expression is True.
  All fields of the event are available by their key name.

  ```bash
  $ cat httplog.txt | klp --where "len(message) > 10 and int(response[:3] > 499"
  ```

  The whole event dict can be accessed as the underscore `_`.

  By default, errors are ignored, because some keys might not be available in all lines.
  Use `--debug` to print exceptions.

  This can be combined with other filters, such as `--grep` and grep context lines.



  Use `--input-exec`/`-I` to transform events using Python code. The code is executed for each event, with all event fields available as Python variables. New fields can be created by assigning to variables, and any field can be modified or deleted.

  ```bash

  $ klp app.log -I 'msg_upper = message.upper(); status = int(response[:3]); severity = "error" if status >= 500 else  "info"'


  $ klp app.log -I 'msg_upper = message.upper()' -I 'word_count = len(message.split())'


  $ klp app.log -f line -I 'ts,level,msg = line.split(maxsplit=2); del line' -I 'level = level.strip("[]")'
  ```

  This shows how to use Python code to transform events, create new fields through assignment, chain multiple transformations, and remove intermediate fields that are no longer needed.
  Each transformation has access to fields created by previous ones.



  When using `--input-exec`/`-I`, there are three special variables available for more complex transformations.
  Each has an equivalent short form using only underscores:

  * `_klp_event` or `_`: Provides read-access to the current event dictionary. This is useful for keys that aren't valid Python identifiers.
  * `_klp_event_add` or `__`: The contents of this dictionary will be merged into the current event.
  * `_klp_events` or `___`: A list of dictionaries, where each dictionary represents an event. This lets you create multiple events from a single input event.

  ```bash

  $ klp examples/qryn.jsonl -j -I "method=_['req.method'].lower()"


  $ klp app.log -I "_klp_event_add={'new_field': 'value', 'updated_field': msg.upper()}"


  $ klp app.log -I "_klp_events=[{'split': word} for word in msg.split()]"
  ```



  When using `--input-exec`/`-I`, any string value in your event (whether from the original parsed event or created during processing) can be split into columns using the `cols()` method.
  This is especially useful for processing fixed-format logs or extracting information from complex field values.

  Background: This method is available because the event key variables are an enhanced string type, which includes additional methods, such as `.cols()`.

  ```python
  cols(column_spec, sep=None, outsep=" ")
  ```

  - `column_spec`: One or more column selectors (see below)
  - `sep`: Optional separator between input columns (defaults to whitespace)
  - `outsep`: String used to join columns within each selector (defaults to space)

  Column selectors can be:
  - Single index: `"0"` or `0` (first column)
  - Multiple indices: `"0,2"` (first and third columns, joined)
  - Slice: `"1:3"` (second and third columns, joined)
  - Negative indices: `"-2"` (second-to-last column)
  - Mix of these: `"-2,2,4:"` (combines columns in each argument)

  Multiple arguments return a list instead of a string.
  So with Python's tuple unpacking, you can create multiple new keys from just one `cols()` call:

  ```bash

  $ klp app.log -f line -I 'ts,level,msg=line.cols("0,1", "2", "3:")'


  $ klp myapp.logfmt -I 'user,action=message.cols("1,2", "3:", sep="|")'
  ```

  Example inputs/outputs to explain the column spec syntax:

  ```python
  line = "alpha beta gamma delta epsilon"
  line.cols(0)          # Returns "alpha"
  line.cols("0,2")      # Returns "alpha gamma"
  line.cols(0, 2)       # Returns ["alpha", "gamma"]
  line.cols("1:3")      # Returns "beta gamma"
  line.cols(1, "-2,2,4:", 3)  # Returns ["beta", "delta gamma epsilon", "delta"]
  ```

  This method can be called on any string field in your event.
  Out-of-range indices are silently ignored, returning an empty string for invalid selections.

  As a shortcut, you can just call the field, which will call the `cols()` method:

  ```python
  line(1, "-2,2,4:", 3)  # Returns ["beta", "delta gamma epsilon", "delta"]
  ```



  When using `--input-exec`, you have access to a variety of helper functions designed for common log processing tasks. The full list of available functions and modules can be viewed using `klp --help-python`.
  Here are some that need more explanation:



  `extract_regex(pattern, text, *groupargs)`: Extract text matching a regular expression pattern, with optional capture group selection

    - `pattern`: Regular expression pattern to match
    - `text`: String to search within
    - `groupargs`: Optional indices of capture groups to extract

  Returns matched text, or `None` if no match. With `groupargs`, returns tuple of matched groups.

  ```bash

  $ echo 'time=2024-02-08T15:04:05Z msg="Server CPU usage: 95.2%"' | \
    klp -I 'cpu=extract_regex(r"CPU usage: (\d+\.?\d*)%", msg, 1)'
  time=2024-02-08T15:04:05Z msg="Server CPU usage: 95.2%" cpu=95.2


  $ echo 'time=2024-02-08T15:04:05Z msg="User alice (role=admin) accessed /api/users"' | \
    klp -I 'user,role = extract_regex(r"User (\w+) \(role=(\w+)\)", msg, 1, 2)'
  time=2024-02-08T15:04:05Z msg="User alice (role=admin) accessed /api/users" user=alice role=admin
  ```

  Like `cols()` and other helper functions, this is available as a method on the fields as well:

  ```bash

  $ echo 'time=2024-02-08T15:04:05Z msg="Request from 192.168.1.100"' | \
    klp -I 'ip=msg.extract_regex(r"\d+\.\d+\.\d+\.\d+")'
  time=2024-02-08T15:04:05Z msg="Request from 192.168.1.100" ip=192.168.1.100
  ```



  `parse_kv(text, sep=None, kvsep="=")`: Parse key-value pairs from a string and merge them into the current event
    - `text`: Input string containing key-value pairs
    - `sep`: Separator between different pairs (whitespace by default)
    - `kvsep`: Separator between keys and values (defaults to "=")
    - Commonly used with `__` to add the parsed fields to the current event

  ```bash

  $ echo 'time=2024-02-08T15:04:05Z msg="GET /search" query="user=alice&role=admin"' | \
    klp -I '__=parse_kv(query, sep="&")'
  time="2024-02-08T15:04:05Z" msg="GET /search" query="user=alice&role=admin" user="alice" role="admin"


  $ echo 'time=2024-02-08T15:04:05Z msg="System stats" metrics="cpu:95.2 mem:87.5 disk:45.8"' | \
    klp -I '__=parse_kv(metrics, kvsep=":")'
  time="2024-02-08T15:04:05Z" msg="System stats" metrics="cpu:95.2 mem:87.5 disk:45.8" cpu="95.2" mem="87.5" disk="45.8"
  ```



  `parse_jsonl(line)`: Returns a dictionary with key-value pairs representing the fields in the first JSON object found.
  - `line`: A string that includes JSON somewhere in it.

  ```bash

  $ echo 'time=2024-02-08T15:04:05Z level=info msg="User details" data={"user_id": "12345", "action": "login"}' |   klp -f line -I '__=parse_jsonl(line)'
  line="time=2024-02-08T15:04:05Z level=info msg=\"User details\" data={\"user_id\": \"12345\", \"action\": \"login\"}" user_id=12345 action=login
  ```



  `sh(command, **kwargs)`: Execute a shell command and return its output
    - `command`: The shell command to execute
    - Returns the command's stdout as a string (stripped of trailing whitespace)
    - Raises an exception if the command fails (disable with `check=False`)
    - Can be customized with subprocess.run keyword arguments

  ```bash

  $ echo 'time=2024-02-08T15:04:05Z level=info msg="Deployment started"' | \
    klp -I '__={"git_rev": sh("git rev-parse HEAD")[:7]}'
  time=2024-02-08T15:04:05Z level=info msg="Deployment started" git_rev=62efbb3


  $ echo 'time=2024-02-08T15:04:05Z level=info msg="Health check"' | \
    klp -I '__={"load": sh("uptime").split("load average:")[-1].strip()}'
  ```

  Note: Use the `sh()` function carefully, and only with trusted input to avoid command injection vulnerabilities.



  For advanced output formatting, use `--output-template` (with Python f-strings) or `--output-eval` which allows Python code:

  ```bash
  $ klp --output-template "{format_datetime(timestamp)} - {extract_ipv4(message) or 'no IP'}" app.log
  $ klp --output-eval "f'{ts} {pprint_json(data)}'" app.log
  ```

  Several Python modules can be used in output expressions.
  Use `--help-python` to show the list of available modules and functions.

  The following additional functions are available:

  * `extract_json()`: return the first JSON object or array in a given string as a string
  * `extract_email()`: return the first email address in a given string
  * `extract_fqdn()`: return the first FQDN in a given string
  * `extract_ipv4()`: return the first IPv4 address in a given string
  * `extract_regex()`: return first part of the string matching a regex
  * `extract_url()`: return the first URL in a given string
  * `format_datetime()`: format given string according to ISO 8601 (with millisecond precision), guessing the datetime format
  * `guess_datetime()`: convert a string into a Python datetime object
  * `pprint_json()`: pretty print JSON data






  These tools aren't specialized for log files but are useful to post-process or view klp's output, particularly the JSONL or TSV formats:


  - [jq](https://jqlang.github.io/jq/): A lightweight and flexible command-line JSON processor
  - [jaq](https://github.com/01mf02/jaq): A jq clone focussed on correctness, speed, and simplicity
  - [yq](https://github.com/mikefarah/yq): A portable command-line YAML, JSON, XML, CSV, TOML and properties processor
  - [Miller](https://github.com/johnkerl/miller): Like awk, sed, cut, join, and sort for name-indexed data such as CSV, TSV, and tabular JSON
  - [dasel](https://github.com/TomWright/dasel): Select, put and delete data from JSON, TOML, YAML, XML and CSV files with a single tool. Supports conversion between formats


  - [qsv](https://github.com/jqnatividad/qsv): CSVs sliced, diced & analyzed
  - [csvlens](https://github.com/YS-L/csvlens): Command line csv viewer


  - [jc](https://github.com/kellyjonbrazil/jc): CLI tool and python library that converts the output of popular command-line tools, file-types, and common strings to JSON, YAML, or Dictionaries
  - [jtbl](https://github.com/kellyjonbrazil/jtbl): CLI tool to convert JSON and JSON Lines to terminal, CSV, HTTP, and markdown tables
  - [ov](https://github.com/noborus/ov): Feature-rich terminal-based text viewer. It is a so-called terminal pager.
  - [Visidata](https://www.visidata.org): A terminal spreadsheet multitool for discovering and arranging data
  - [Benthos](https://github.com/benthosdev/benthos.git): High performance and resilient stream processor, able to connect various sources and sinks


  The TSV format can be processed by spreadsheet software and common Unix tools:

  - [cut](https://man7.org/linux/man-pages/man1/cut.1.html): Uses tab separator by default
  - [AWK](https://man7.org/linux/man-pages/man1/awk.1p.html): `-F$'\t'`
  - [sort](https://man7.org/linux/man-pages/man1/sort.1.html): `-t$'\t'`
  - [column](https://man7.org/linux/man-pages/man1/column.1.html): `-s$'\t' -N timestamp,log_level,message -J` (can convert to JSON)
  - [Vim](https://www.vim.org): `:set list    :set listchars=tab:>-`
  - [Pandas](https://pandas.pydata.org): `pd.read_table()`
  - [SQLite](https://www.sqlite.org):
  ```sql
  sqlite> .mode tabs
  sqlite> .import data.tsv data
  sqlite> select date(timestamp) as day, count(*) from data group by day;
  ```



  If klp doesn't meet your needs, here are some alternatives:


  - [hutils](https://github.com/brandur/hutils): The original logfmt tools (Ruby)
  - [lfq](https://github.com/mattcontinisio/lfq): Command-line logfmt processor (Go). Quite similar to klp. Faster, but fewer features
  - [angle-grinder](https://github.com/rcoh/angle-grinder): Slice and dice logs on the command line (Rust). Flexible query syntax
  - [pq](https://github.com/iximiuz/pq): Parse and Query log files as time series
  - [Kelpie](https://github.com/Yord/klp): Small, fast, and magical command-line data processor similar to pxi, jq, mlr, and awk
  - [lnav](https://github.com/tstack/lnav): Very advanced log file viewer. Files-only (no streaming), lots of formats


  - [fblog](https://github.com/brocode/fblog): Small command-line JSON Log viewer (Rust). Lua filters.
  - [json-log-viewer](https://github.com/gistia/json-log-viewer): Powerful terminal based viewer for JSON logs using ncurses (JavaScript). TUI
  - [Toolong](https://github.com/Textualize/toolong): A terminal application to view, tail, merge, and search log files, plus JSONL (Python). TUI
  - [sumoshell](https://github.com/SumoLogic/sumoshell): Collection of utilities to improve analyzing log files (Go). Successor is angle-grinder.
  - [l'oGGo](https://github.com/aurc/loggo): A powerful terminal app for structured log streaming (Go). TUI
  - [hl](https://github.com/pamburus/hl): A log viewer that translates JSON logs into human-readable representation (Rust)
  - [logdissect](https://github.com/dogoncouch/logdissect.git): CLI utility and Python module for analyzing log files and other data (Python). Multiple input formats


  - [tailspin](https://github.com/bensadeh/tailspin): A log file highlighter (Rust)
  - [GoAccess](https://goaccess.io): Real-time web log analyzer and interactive viewer that runs in a terminal in *nix systems or through your browser


  - [Klogg](https://github.com/variar/klogg): Multi-platform GUI application that helps browse and search through long and complex log files
  - [frontail](https://github.com/mthenw/frontail/): Streaming logs to the browser
  - [LogScreen](https://github.com/soorajshankar/logScreen): Loglines can be messy, read it better on a browser, `command | npx logscreen`
  - [Logdy](https://logdy.dev): Web based real-time log viewer. Stream ANY content to a web UI with autogenerated filters. Parse any format with TypeScript


  - [OpenObserve](https://github.com/openobserve/openobserve): Cloud-native observability platform built specifically for logs, metrics, traces, analytics, RUM, designed to work at petabyte scale
  - [Graylog](https://github.com/Graylog2/graylog2-server): Free and open log management
  - [Grafana Loki](https://grafana.com/docs/loki/latest/visualize/grafana/): Horizontally-scalable, highly-available, multi-tenant log aggregation system


pkgId: 65954764926c07b786a6ede9259a429eba553a286e4cfb36daf4fa84686b4777
name: python-knockapi-help
arch: noarch
version: 0.5.10
epoch: 0
release: 1
summary: Development documents and examples for knockapi
url: https://github.com/knocklabs/knock-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-knockapi-0.5.10-1.src.rpm
location_href: Packages/python-knockapi-help-0.5.10-1.noarch.rpm
checksum_type: sha256
description:
  Knock API access for applications written in Python.



  See the [documentation](https://docs.knock.app) for Python usage examples.



  To install from PyPi, run the following:

  ```bash
  pip install knockapi
  ```

  To install from source, clone the repo and run the following:

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



  To use the library you must provide a secret API key, provided in the Knock dashboard.

  ```python
  from knockapi import Knock
  client = Knock(api_key="sk_12345")
  ```





  ```python
  from knockapi import Knock
  client = Knock(api_key="sk_12345")

  client.users.identify(id="jhammond", data={"name": "John Hammond", "email": "jhammond@ingen.net"})
  ```



  ```python
  from knockapi import Knock
  client = Knock(api_key="sk_12345")

  client.users.get_user(id="jhammond")
  ```



  ```python
  from knockapi import Knock
  client = Knock(api_key="sk_12345")

  client.workflows.trigger(
    key="dinosaurs-loose",
    actor="dnedry",
    recipients=["jhammond", "agrant", "imalcolm", "esattler"],
    cancellation_key=alert.id,
    tenant="jurassic-park",
    data={
      "type": "trex",
      "priority": 1
    }
  )

  ```



  ```python
  from knockapi import Knock
  client = Knock(api_key="sk_12345")


  client.users.set_channel_data(
    id="jhammond",
    channel_id=KNOCK_APNS_CHANNEL_ID,
    channel_data={
      "tokens": [apns_token]
    }
  )


  client.users.get_channel_data(id="jhammond", channel_id=KNOCK_APNS_CHANNEL_ID)
  ```



  ```python
  from knockapi import Knock
  client = Knock(api_key="sk_12345")

  client.workflows.cancel(
    key="dinosaurs-loose",
    cancellation_key=alert.id,
    recipients=["jhammond", "agrant", "imalcolm", "esattler"],
  )
  ```



  ```python
  from knockapi import Knock
  client = Knock(api_key="sk_12345")


  client.users.set_preferences(
    user_id="jhammond",
    channel_types={'email': True},
    workflows={'dinosaurs-loose': False}
  )


  client.users.get_preferences(user_id="jhammond")
  ```



  You can use the `pyjwt` package to [sign JWTs easily](https://pyjwt.readthedocs.io/en/stable/usage.html#encoding-decoding-tokens-with-rs256-rsa).
  You will need to generate an environment specific signing key, which you can find in the Knock dashboard.

  If you're using a signing token you will need to pass this to your client to perform authentication.
  You can read more about [client-side authentication here](https://docs.knock.app/client-integration/authenticating-users).

  ```python
  import jwt
  import os

  private_key = os.getenv("KNOCK_SIGNING_KEY")
  encoded = jwt.encode({"sub": "jhammond"}, private_key, algorithm="RS256")
  ```


